LLVMFuzzerTestOneInput:
   27|  7.70k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   28|  7.70k|  if (size < 4)
  ------------------
  |  Branch (28:7): [True: 2, False: 7.70k]
  ------------------
   29|      2|    return 0;
   30|       |
   31|  7.70k|  FuzzedDataProvider fdp(data, size);
   32|       |
   33|       |  // Split data: most goes to model, some to test text
   34|  7.70k|  std::string model_data = fdp.ConsumeRandomLengthString(size);
   35|  7.70k|  std::string test_text = fdp.ConsumeRemainingBytesAsString();
   36|       |
   37|  7.70k|  sentencepiece::SentencePieceProcessor processor;
   38|       |
   39|       |  // Try loading fuzz data as a serialized model proto
   40|  7.70k|  auto status = processor.LoadFromSerializedProto(model_data);
   41|  7.70k|  if (!status.ok())
  ------------------
  |  Branch (41:7): [True: 5.66k, False: 2.03k]
  ------------------
   42|  5.66k|    return 0;
   43|       |
   44|       |  // Model loaded successfully - exercise all major operations
   45|       |
   46|       |  // Basic encoding
   47|  2.03k|  std::vector<std::string> pieces;
   48|  2.03k|  processor.Encode(test_text, &pieces);
   49|       |
   50|       |  // Encode to IDs
   51|  2.03k|  std::vector<int> ids;
   52|  2.03k|  processor.Encode(test_text, &ids);
   53|       |
   54|       |  // Decode from pieces
   55|  2.03k|  if (!pieces.empty()) {
  ------------------
  |  Branch (55:7): [True: 1.93k, False: 102]
  ------------------
   56|  1.93k|    std::string decoded;
   57|  1.93k|    processor.Decode(pieces, &decoded);
   58|  1.93k|  }
   59|       |
   60|       |  // Decode from IDs
   61|  2.03k|  if (!ids.empty()) {
  ------------------
  |  Branch (61:7): [True: 1.95k, False: 81]
  ------------------
   62|  1.95k|    std::string decoded;
   63|  1.95k|    processor.Decode(ids, &decoded);
   64|  1.95k|  }
   65|       |
   66|       |  // Normalization
   67|  2.03k|  std::string normalized;
   68|  2.03k|  processor.Normalize(test_text, &normalized);
   69|       |
   70|       |  // Vocabulary operations
   71|  2.03k|  int vocab_size = processor.GetPieceSize();
   72|  2.03k|  if (vocab_size > 0) {
  ------------------
  |  Branch (72:7): [True: 2.03k, False: 0]
  ------------------
   73|       |    // PieceToId / IdToPiece round-trip
   74|  12.4k|    for (int i = 0; i < vocab_size && i < 10; i++) {
  ------------------
  |  Branch (74:21): [True: 10.9k, False: 1.54k]
  |  Branch (74:39): [True: 10.4k, False: 485]
  ------------------
   75|  10.4k|      std::string piece = processor.IdToPiece(i);
   76|  10.4k|      processor.PieceToId(piece);
   77|  10.4k|      processor.GetScore(i);
   78|  10.4k|      processor.IsUnknown(i);
   79|  10.4k|      processor.IsControl(i);
   80|  10.4k|      processor.IsUnused(i);
   81|  10.4k|      processor.IsByte(i);
   82|  10.4k|    }
   83|       |
   84|       |    // Try lookup with test_text as a piece
   85|  2.03k|    processor.PieceToId(test_text);
   86|  2.03k|  }
   87|       |
   88|       |  // Special token IDs
   89|  2.03k|  processor.unk_id();
   90|  2.03k|  processor.bos_id();
   91|  2.03k|  processor.eos_id();
   92|  2.03k|  processor.pad_id();
   93|       |
   94|       |  // NBest encoding (with small nbest_size to avoid slowness)
   95|  2.03k|  std::vector<std::vector<std::string>> nbest_pieces;
   96|  2.03k|  processor.NBestEncode(test_text, 2, &nbest_pieces);
   97|       |
   98|       |  // Sample encoding
   99|  2.03k|  std::vector<std::string> sampled;
  100|  2.03k|  processor.SampleEncode(test_text, 1, 0.5, &sampled);
  101|       |
  102|       |  // Encode as serialized proto
  103|  2.03k|  processor.EncodeAsSerializedProto(test_text);
  104|  2.03k|  processor.SampleEncodeAsSerializedProto(test_text, 1, 0.5);
  105|       |
  106|       |  // Get serialized model
  107|  2.03k|  processor.serialized_model_proto();
  108|       |
  109|  2.03k|  return 0;
  110|  7.70k|}

_ZNK13sentencepiece4util6Status2okEv:
   64|   430M|  inline bool ok() const { return rep_ == nullptr; }
_ZNK13sentencepiece22SentencePieceProcessor23EncodeAsSerializedProtoENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  529|  2.03k|  virtual util::bytes EncodeAsSerializedProto(absl::string_view input) const {
  530|  2.03k|    DEFINE_SPP_SERIALIZED_PROTO_IMPL(Encode, ImmutableSentencePieceText, input);
  ------------------
  |  |  440|  2.03k|  OutType output;                                                    \
  |  |  441|  2.03k|  const auto status = FuncName(__VA_ARGS__, output.mutable_proto()); \
  |  |  442|  2.03k|  SPP_SWIG_CHECK_AND_THROW;                                          \
  |  |  ------------------
  |  |  |  |  429|  2.03k|  if (!status.ok()) {            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (429:7): [True: 21, False: 2.01k]
  |  |  |  |  ------------------
  |  |  |  |  430|     21|  }
  |  |  ------------------
  |  |  443|  2.03k|  return output.SerializeAsString();
  ------------------
  531|      0|  }
_ZNK13sentencepiece22SentencePieceProcessor29SampleEncodeAsSerializedProtoENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEif:
  535|  2.03k|                                                    float alpha) const {
  536|  2.03k|    DEFINE_SPP_SERIALIZED_PROTO_IMPL(SampleEncode, ImmutableSentencePieceText,
  ------------------
  |  |  440|  2.03k|  OutType output;                                                    \
  |  |  441|  2.03k|  const auto status = FuncName(__VA_ARGS__, output.mutable_proto()); \
  |  |  442|  2.03k|  SPP_SWIG_CHECK_AND_THROW;                                          \
  |  |  ------------------
  |  |  |  |  429|  2.03k|  if (!status.ok()) {            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (429:7): [True: 392, False: 1.64k]
  |  |  |  |  ------------------
  |  |  |  |  430|    392|  }
  |  |  ------------------
  |  |  443|  2.03k|  return output.SerializeAsString();
  ------------------
  537|  2.03k|                                     input, nbest_size, alpha);
  538|      0|  }

_ZN13sentencepiece3bpe5ModelC2ERKNS_10ModelProtoE:
   37|    287|Model::Model(const ModelProto &model_proto) {
   38|    287|  model_proto_ = &model_proto;
   39|    287|  InitializePieces();
   40|    287|}
_ZN13sentencepiece3bpe5ModelD2Ev:
   42|    287|Model::~Model() {}
_ZNK13sentencepiece3bpe5Model12SampleEncodeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEf:
   45|    379|    absl::string_view normalized, float alpha) const {
   46|    379|  if (!status().ok() || normalized.empty()) {
  ------------------
  |  Branch (46:7): [True: 0, False: 379]
  |  Branch (46:7): [True: 3, False: 376]
  |  Branch (46:25): [True: 3, False: 376]
  ------------------
   47|      3|    return {};
   48|      3|  }
   49|       |
   50|    376|  struct SymbolPair {
   51|    376|    union {
   52|    376|      float score;  // score of this pair. large is better.
   53|    376|      int32_t int_score;
   54|    376|    };
   55|    376|    uint32_t left;      // left index of this pair
   56|    376|    int right;          // right index of this pair
   57|    376|    unsigned int size;  // length of this piece
   58|    376|  };
   59|       |
   60|    376|  class SymbolPairComparator {
   61|    376|   public:
   62|    376|    ABSL_ATTRIBUTE_ALWAYS_INLINE inline bool operator()(const SymbolPair &h1,
   63|    376|                                                        const SymbolPair &h2) {
   64|    376|      const int32_t i1 = h1.int_score;
   65|    376|      const int32_t i2 = h2.int_score;
   66|       |
   67|       |      // Fast path for the common case where both scores are negative because
   68|       |      // they are log-probabilities.
   69|       |      // Note: we use the fact that IEEE 754 floating point format enables
   70|       |      // to compare the integer representation of negative floats which is
   71|       |      // cheaper than using float comparison. And it works the same way for
   72|       |      // little endian and big endian machines because the IEEE 754 format is
   73|       |      // aligned with the endianness.
   74|       |      // `(i1 & i2) < 0` is an efficient way to check `i1 < 0 && i2 < 0`.
   75|    376|      if ((i1 & i2) < 0) {
   76|       |        // For negative floats, their integer representation order is the
   77|       |        // reverse of the float order. That is, for two negative floats f1, f2,
   78|       |        // f1 < f2 iff i1 > i2.
   79|    376|        return (i1 > i2) || (i1 == i2 && h1.left > h2.left);
   80|    376|      }
   81|       |
   82|       |      // Slow path for uncommon cases (mixed signs or both positive).
   83|       |      // Note: the comparison between NaN and +0 and +1 can be different than
   84|       |      // if we used float numbers but it should not influence the result.
   85|    376|      bool score_less;
   86|       |      // If signs are different ((i1 ^ i2) < 0), the negative score is smaller.
   87|    376|      if ((i1 ^ i2) < 0) {
   88|    376|        score_less = i1 < 0;
   89|    376|      } else {
   90|       |        // If signs are the same (and not both negative), they must both be
   91|       |        // non-negative. For non-negative floats, integer order is the same as
   92|       |        // float order.
   93|    376|        score_less = i1 < i2;
   94|    376|      }
   95|       |
   96|    376|      return score_less || (i1 == i2 && h1.left > h2.left);
   97|    376|    }
   98|    376|  };
   99|       |
  100|    376|  struct Symbol {
  101|    376|    int prev;     // prev index of this symbol. -1 for BOS.
  102|    376|    int next;     // next index of tihs symbol. -1 for EOS.
  103|    376|    bool freeze;  // this symbol is never be merged.
  104|    376|    absl::string_view piece;
  105|    376|  };
  106|       |
  107|    376|  std::vector<Symbol> symbols;
  108|    376|  symbols.reserve(normalized.size());
  109|       |
  110|       |  // Splits the input into Symbols doing longest prefix match of the input
  111|       |  // from pieces(type:UNUSED) in the vocabulary.
  112|       |  // Does character splitting as a fallback of longest prefix match.
  113|    376|  int index = 0;
  114|   820k|  while (!normalized.empty()) {
  ------------------
  |  Branch (114:10): [True: 820k, False: 376]
  ------------------
  115|   820k|    Symbol s;
  116|   820k|    const int mblen = matcher_->PrefixMatch(normalized, &s.freeze);
  117|   820k|    s.piece = absl::string_view(normalized.data(), mblen);
  118|   820k|    s.prev = index == 0 ? -1 : index - 1;
  ------------------
  |  Branch (118:14): [True: 376, False: 819k]
  ------------------
  119|   820k|    normalized.remove_prefix(mblen);
  120|   820k|    s.next = normalized.empty() ? -1 : index + 1;
  ------------------
  |  Branch (120:14): [True: 376, False: 819k]
  ------------------
  121|   820k|    ++index;
  122|   820k|    symbols.emplace_back(s);
  123|   820k|  }
  124|       |
  125|    376|  if (symbols.empty()) {
  ------------------
  |  Branch (125:7): [True: 0, False: 376]
  ------------------
  126|      0|    return {};
  127|      0|  }
  128|       |
  129|    376|  std::vector<SymbolPair> agenda_vec;
  130|    376|  agenda_vec.reserve(symbols.size());
  131|       |
  132|       |  // Reverse merge rules.
  133|       |  // key: merged symbol, value: pair of original symbols.
  134|    376|  absl::flat_hash_map<absl::string_view,
  135|    376|                      std::pair<absl::string_view, absl::string_view>>
  136|    376|      rev_merge;
  137|       |
  138|       |  // Lookup all bigrams.
  139|    376|  if (symbols.size() > 1) {
  ------------------
  |  Branch (139:7): [True: 376, False: 0]
  ------------------
  140|    376|    int left = 0;
  141|    376|    int right = 1;
  142|    376|    Symbol *symbol_left = &symbols[left];
  143|    376|    Symbol *symbol_right = &symbols[right];
  144|   820k|    for (; right < symbols.size();
  ------------------
  |  Branch (144:12): [True: 819k, False: 376]
  ------------------
  145|   819k|         left = right, symbol_left = symbol_right, ++right, ++symbol_right) {
  146|   819k|      if (symbol_left->freeze || symbol_right->freeze) continue;
  ------------------
  |  Branch (146:11): [True: 0, False: 819k]
  |  Branch (146:34): [True: 0, False: 819k]
  ------------------
  147|   819k|      const absl::string_view piece(
  148|   819k|          symbol_left->piece.data(),
  149|   819k|          symbol_left->piece.size() + symbol_right->piece.size());
  150|   819k|      const auto it = pieces_.find(piece);
  151|   819k|      if (it == pieces_.end()) continue;
  ------------------
  |  Branch (151:11): [True: 819k, False: 0]
  ------------------
  152|      0|      SymbolPair &h = agenda_vec.emplace_back();
  153|      0|      h.left = left;
  154|      0|      h.right = right;
  155|      0|      h.score = GetScore(it->second);
  156|      0|      h.size = piece.size();
  157|       |
  158|       |      // Makes `rev_merge` for resegmentation.
  159|      0|      if (IsUnusedInlined(it->second))
  ------------------
  |  Branch (159:11): [True: 0, False: 0]
  ------------------
  160|      0|        rev_merge[piece] =
  161|      0|            std::make_pair(symbol_left->piece, symbol_right->piece);
  162|      0|    }
  163|    376|  }
  164|       |
  165|    376|  using Agenda = std::priority_queue<SymbolPair, std::vector<SymbolPair>,
  166|    376|                                     SymbolPairComparator>;
  167|    376|  Agenda agenda(SymbolPairComparator(), std::move(agenda_vec));
  168|       |  // Lookup new symbol pair at [left, right] and inserts it to agenda.
  169|    376|  auto MaybeAddNewSymbolPair = [this, &symbols, &agenda, &rev_merge](
  170|    376|                                   int left, int right) {
  171|    376|    if (left == -1 || right == -1) return;
  172|    376|    const Symbol &left_symbol = symbols[left];
  173|    376|    const Symbol &right_symbol = symbols[right];
  174|    376|    if (left_symbol.freeze || right_symbol.freeze) return;
  175|    376|    const absl::string_view piece(
  176|    376|        left_symbol.piece.data(),
  177|    376|        left_symbol.piece.size() + right_symbol.piece.size());
  178|    376|    const auto it = pieces_.find(piece);
  179|    376|    if (it == pieces_.end()) {
  180|    376|      return;
  181|    376|    }
  182|    376|    const int id = it->second;
  183|    376|    SymbolPair h;
  184|    376|    h.left = left;
  185|    376|    h.right = right;
  186|    376|    h.score = GetScore(id);
  187|    376|    h.size = piece.size();
  188|    376|    agenda.push(h);
  189|       |
  190|       |    // Makes `rev_merge` for resegmentation.
  191|    376|    if (IsUnusedInlined(id))
  192|    376|      rev_merge[piece] = std::make_pair(left_symbol.piece, right_symbol.piece);
  193|    376|  };
  194|       |
  195|    376|  absl::BitGen *rand_gen = nullptr;
  196|       |  // Main loop.
  197|    376|  while (!agenda.empty()) {
  ------------------
  |  Branch (197:10): [True: 0, False: 376]
  ------------------
  198|       |    // Pop the top pair if it is stale.
  199|      0|    const SymbolPair &top_ref = agenda.top();
  200|      0|    if (symbols[top_ref.left].piece.empty() ||
  ------------------
  |  Branch (200:9): [True: 0, False: 0]
  ------------------
  201|      0|        symbols[top_ref.right].piece.empty() ||
  ------------------
  |  Branch (201:9): [True: 0, False: 0]
  ------------------
  202|      0|        (symbols[top_ref.left].piece.size() +
  ------------------
  |  Branch (202:9): [True: 0, False: 0]
  ------------------
  203|      0|             symbols[top_ref.right].piece.size() !=
  204|      0|         top_ref.size)) {
  205|      0|      agenda.pop();
  206|      0|      continue;
  207|      0|    }
  208|       |
  209|      0|    SymbolPair top = agenda.top();
  210|      0|    agenda.pop();
  211|       |
  212|      0|    Symbol &left_symbol = symbols[top.left];
  213|      0|    Symbol &right_symbol = symbols[top.right];
  214|       |
  215|       |    // Note that original BPE-dropout paper assumes that all merged symbols are
  216|       |    // pre computed, but here we randomly skip merge operation inside this loop.
  217|       |    // This implementation is theoretically equivalent to the original one.
  218|       |    // BPE-dropout: https://arxiv.org/pdf/1910.13267.pdf
  219|      0|    if (alpha > 0.0) {
  ------------------
  |  Branch (219:9): [True: 0, False: 0]
  ------------------
  220|      0|      if (alpha >= 1.0) continue;
  ------------------
  |  Branch (220:11): [True: 0, False: 0]
  ------------------
  221|      0|      if (rand_gen == nullptr) rand_gen = random::GetRandomGenerator();
  ------------------
  |  Branch (221:11): [True: 0, False: 0]
  ------------------
  222|      0|      std::uniform_real_distribution<> gen(0.0, 1.0);
  223|      0|      if (gen(*rand_gen) < alpha) continue;
  ------------------
  |  Branch (223:11): [True: 0, False: 0]
  ------------------
  224|      0|    }
  225|       |
  226|       |    // Replaces symbols with `top` rule.
  227|      0|    left_symbol.piece =
  228|      0|        absl::string_view(left_symbol.piece.data(),
  229|      0|                          left_symbol.piece.size() + right_symbol.piece.size());
  230|       |
  231|       |    // Updates prev/next pointers.
  232|      0|    left_symbol.next = right_symbol.next;
  233|      0|    if (right_symbol.next >= 0) {
  ------------------
  |  Branch (233:9): [True: 0, False: 0]
  ------------------
  234|      0|      symbols[right_symbol.next].prev = top.left;
  235|      0|    }
  236|      0|    right_symbol.piece = absl::string_view("");
  237|       |
  238|       |    // Adds new symbol pairs which are newly added after symbol replacement.
  239|      0|    MaybeAddNewSymbolPair(left_symbol.prev, top.left);
  240|      0|    MaybeAddNewSymbolPair(top.left, left_symbol.next);
  241|      0|  }
  242|       |
  243|    376|  std::function<void(absl::string_view, EncodeResult *)> resegment;
  244|    376|  resegment = [this, &resegment, &rev_merge](absl::string_view w,
  245|    376|                                             EncodeResult *output) -> void {
  246|    376|    const int id = PieceToId(w);
  247|    376|    if (id == -1 || !IsUnusedInlined(id)) {
  248|    376|      output->emplace_back(w, id);
  249|    376|      return;
  250|    376|    }
  251|    376|    const auto p = rev_merge.find(w);
  252|    376|    if (p == rev_merge.end()) {
  253|       |      // This block will never be called, as `rev_merge` stores all the
  254|       |      // resegmentation info for unused id.
  255|    376|      output->emplace_back(w, id);
  256|    376|      return;
  257|    376|    }
  258|       |    // Recursively resegment left and right symbols.
  259|    376|    resegment(p->second.first, output);
  260|    376|    resegment(p->second.second, output);
  261|    376|  };
  262|       |
  263|    376|  EncodeResult output;
  264|    376|  output.reserve(symbols.size());
  265|   820k|  for (int index = 0; index != -1; index = symbols[index].next) {
  ------------------
  |  Branch (265:23): [True: 820k, False: 376]
  ------------------
  266|   820k|    if (index >= 0 && index < static_cast<int>(symbols.size())) {
  ------------------
  |  Branch (266:9): [True: 820k, False: 0]
  |  Branch (266:23): [True: 820k, False: 0]
  ------------------
  267|   820k|      resegment(symbols[index].piece, &output);
  268|   820k|    }
  269|   820k|  }
  270|       |
  271|    376|  return output;
  272|    376|}
bpe_model.cc:_ZZNK13sentencepiece3bpe5Model12SampleEncodeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEfENK3$_0clES6_PNS2_6vectorINS2_4pairIS6_iEENS2_9allocatorISA_EEEE:
  245|   820k|                                             EncodeResult *output) -> void {
  246|   820k|    const int id = PieceToId(w);
  247|   820k|    if (id == -1 || !IsUnusedInlined(id)) {
  ------------------
  |  Branch (247:9): [True: 0, False: 820k]
  |  Branch (247:21): [True: 820k, False: 0]
  ------------------
  248|   820k|      output->emplace_back(w, id);
  249|   820k|      return;
  250|   820k|    }
  251|      0|    const auto p = rev_merge.find(w);
  252|      0|    if (p == rev_merge.end()) {
  ------------------
  |  Branch (252:9): [True: 0, False: 0]
  ------------------
  253|       |      // This block will never be called, as `rev_merge` stores all the
  254|       |      // resegmentation info for unused id.
  255|      0|      output->emplace_back(w, id);
  256|      0|      return;
  257|      0|    }
  258|       |    // Recursively resegment left and right symbols.
  259|      0|    resegment(p->second.first, output);
  260|      0|    resegment(p->second.second, output);
  261|      0|  };

_ZNK13sentencepiece3bpe5Model6EncodeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   35|    229|  EncodeResult Encode(absl::string_view normalized) const override {
   36|    229|    return SampleEncode(normalized, 0.0);
   37|    229|  }
_ZNK13sentencepiece3bpe5Model23IsSampleEncodeAvailableEv:
   46|    150|  bool IsSampleEncodeAvailable() const override { return true; }
_ZNK13sentencepiece3bpe5Model22IsNBestEncodeAvailableEv:
   48|    225|  bool IsNBestEncodeAvailable() const override { return false; }

_ZN13sentencepiece31SentencePieceText_SentencePieceC2EPN6google8protobuf5ArenaE:
   96|  11.5M|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
   97|  11.5M|  _extensions_(arena) {
   98|  11.5M|  SharedCtor();
   99|  11.5M|  RegisterArenaDtor(arena);
  100|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.SentencePieceText.SentencePiece)
  101|  11.5M|}
_ZN13sentencepiece31SentencePieceText_SentencePieceD2Ev:
  133|  11.5M|SentencePieceText_SentencePiece::~SentencePieceText_SentencePiece() {
  134|       |  // @@protoc_insertion_point(destructor:sentencepiece.SentencePieceText.SentencePiece)
  135|  11.5M|  SharedDtor();
  136|  11.5M|  _internal_metadata_.Delete<std::string>();
  137|  11.5M|}
_ZNK13sentencepiece31SentencePieceText_SentencePiece13SetCachedSizeEi:
  151|  3.10M|void SentencePieceText_SentencePiece::SetCachedSize(int size) const {
  152|  3.10M|  _cached_size_.Set(size);
  153|  3.10M|}
_ZNK13sentencepiece31SentencePieceText_SentencePiece18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
  263|  3.10M|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  264|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.SentencePieceText.SentencePiece)
  265|  3.10M|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  266|  3.10M|  (void) cached_has_bits;
  267|       |
  268|  3.10M|  cached_has_bits = _has_bits_[0];
  269|       |  // optional string piece = 1;
  270|  3.10M|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (270:7): [True: 3.10M, False: 0]
  ------------------
  271|  3.10M|    target = stream->WriteStringMaybeAliased(
  272|  3.10M|        1, this->_internal_piece(), target);
  273|  3.10M|  }
  274|       |
  275|       |  // optional uint32 id = 2;
  276|  3.10M|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (276:7): [True: 3.10M, False: 0]
  ------------------
  277|  3.10M|    target = stream->EnsureSpace(target);
  278|  3.10M|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_id(), target);
  279|  3.10M|  }
  280|       |
  281|       |  // optional string surface = 3;
  282|  3.10M|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (282:7): [True: 3.10M, False: 983]
  ------------------
  283|  3.10M|    target = stream->WriteStringMaybeAliased(
  284|  3.10M|        3, this->_internal_surface(), target);
  285|  3.10M|  }
  286|       |
  287|       |  // optional uint32 begin = 4;
  288|  3.10M|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (288:7): [True: 3.10M, False: 0]
  ------------------
  289|  3.10M|    target = stream->EnsureSpace(target);
  290|  3.10M|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(4, this->_internal_begin(), target);
  291|  3.10M|  }
  292|       |
  293|       |  // optional uint32 end = 5;
  294|  3.10M|  if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (294:7): [True: 3.10M, False: 0]
  ------------------
  295|  3.10M|    target = stream->EnsureSpace(target);
  296|  3.10M|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(5, this->_internal_end(), target);
  297|  3.10M|  }
  298|       |
  299|       |  // Extension range [200, 536870912)
  300|  3.10M|  target = _extensions_._InternalSerialize(
  301|  3.10M|      200, 536870912, target, stream);
  302|       |
  303|  3.10M|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  3.10M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 3.10M]
  |  |  ------------------
  ------------------
  304|      0|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
  305|      0|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  306|      0|  }
  307|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.SentencePieceText.SentencePiece)
  308|  3.10M|  return target;
  309|  3.10M|}
_ZNK13sentencepiece31SentencePieceText_SentencePiece12ByteSizeLongEv:
  311|  3.10M|size_t SentencePieceText_SentencePiece::ByteSizeLong() const {
  312|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.SentencePieceText.SentencePiece)
  313|  3.10M|  size_t total_size = 0;
  314|       |
  315|  3.10M|  total_size += _extensions_.ByteSize();
  316|       |
  317|  3.10M|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  318|       |  // Prevent compiler warnings about cached_has_bits being unused
  319|  3.10M|  (void) cached_has_bits;
  320|       |
  321|  3.10M|  cached_has_bits = _has_bits_[0];
  322|  3.10M|  if (cached_has_bits & 0x0000001fu) {
  ------------------
  |  Branch (322:7): [True: 3.10M, False: 0]
  ------------------
  323|       |    // optional string piece = 1;
  324|  3.10M|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (324:9): [True: 3.10M, False: 0]
  ------------------
  325|  3.10M|      total_size += 1 +
  326|  3.10M|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
  327|  3.10M|          this->_internal_piece());
  328|  3.10M|    }
  329|       |
  330|       |    // optional string surface = 3;
  331|  3.10M|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (331:9): [True: 3.10M, False: 983]
  ------------------
  332|  3.10M|      total_size += 1 +
  333|  3.10M|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
  334|  3.10M|          this->_internal_surface());
  335|  3.10M|    }
  336|       |
  337|       |    // optional uint32 id = 2;
  338|  3.10M|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (338:9): [True: 3.10M, False: 0]
  ------------------
  339|  3.10M|      total_size += 1 +
  340|  3.10M|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
  341|  3.10M|          this->_internal_id());
  342|  3.10M|    }
  343|       |
  344|       |    // optional uint32 begin = 4;
  345|  3.10M|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (345:9): [True: 3.10M, False: 0]
  ------------------
  346|  3.10M|      total_size += 1 +
  347|  3.10M|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
  348|  3.10M|          this->_internal_begin());
  349|  3.10M|    }
  350|       |
  351|       |    // optional uint32 end = 5;
  352|  3.10M|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (352:9): [True: 3.10M, False: 0]
  ------------------
  353|  3.10M|      total_size += 1 +
  354|  3.10M|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32Size(
  355|  3.10M|          this->_internal_end());
  356|  3.10M|    }
  357|       |
  358|  3.10M|  }
  359|  3.10M|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  3.10M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 3.10M]
  |  |  ------------------
  ------------------
  360|      0|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  361|      0|  }
  362|  3.10M|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  363|  3.10M|  SetCachedSize(cached_size);
  364|  3.10M|  return total_size;
  365|  3.10M|}
_ZN13sentencepiece17SentencePieceTextC2EPN6google8protobuf5ArenaE:
  451|  14.4k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  452|  14.4k|  _extensions_(arena),
  453|  14.4k|  pieces_(arena) {
  454|  14.4k|  SharedCtor();
  455|  14.4k|  RegisterArenaDtor(arena);
  456|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.SentencePieceText)
  457|  14.4k|}
_ZN13sentencepiece17SentencePieceTextD2Ev:
  479|  14.4k|SentencePieceText::~SentencePieceText() {
  480|       |  // @@protoc_insertion_point(destructor:sentencepiece.SentencePieceText)
  481|  14.4k|  SharedDtor();
  482|  14.4k|  _internal_metadata_.Delete<std::string>();
  483|  14.4k|}
_ZNK13sentencepiece17SentencePieceText13SetCachedSizeEi:
  496|  4.06k|void SentencePieceText::SetCachedSize(int size) const {
  497|  4.06k|  _cached_size_.Set(size);
  498|  4.06k|}
_ZN13sentencepiece17SentencePieceText16default_instanceEv:
  499|  4.06k|const SentencePieceText& SentencePieceText::default_instance() {
  500|  4.06k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SentencePieceText_sentencepiece_2eproto.base);
  501|  4.06k|  return *internal_default_instance();
  502|  4.06k|}
_ZN13sentencepiece17SentencePieceText5ClearEv:
  505|  12.3k|void SentencePieceText::Clear() {
  506|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.SentencePieceText)
  507|  12.3k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  508|       |  // Prevent compiler warnings about cached_has_bits being unused
  509|  12.3k|  (void) cached_has_bits;
  510|       |
  511|  12.3k|  _extensions_.Clear();
  512|  12.3k|  pieces_.Clear();
  513|  12.3k|  cached_has_bits = _has_bits_[0];
  514|  12.3k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (514:7): [True: 0, False: 12.3k]
  ------------------
  515|      0|    text_.ClearNonDefaultToEmpty();
  516|      0|  }
  517|  12.3k|  score_ = 0;
  518|  12.3k|  _has_bits_.Clear();
  519|  12.3k|  _internal_metadata_.Clear<std::string>();
  520|  12.3k|}
_ZNK13sentencepiece17SentencePieceText18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
  588|  4.06k|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  589|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.SentencePieceText)
  590|  4.06k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  591|  4.06k|  (void) cached_has_bits;
  592|       |
  593|  4.06k|  cached_has_bits = _has_bits_[0];
  594|       |  // optional string text = 1;
  595|  4.06k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (595:7): [True: 3.65k, False: 413]
  ------------------
  596|  3.65k|    target = stream->WriteStringMaybeAliased(
  597|  3.65k|        1, this->_internal_text(), target);
  598|  3.65k|  }
  599|       |
  600|       |  // repeated .sentencepiece.SentencePieceText.SentencePiece pieces = 2;
  601|  4.06k|  for (unsigned int i = 0,
  602|  3.10M|      n = static_cast<unsigned int>(this->_internal_pieces_size()); i < n; i++) {
  ------------------
  |  Branch (602:69): [True: 3.10M, False: 4.06k]
  ------------------
  603|  3.10M|    target = stream->EnsureSpace(target);
  604|  3.10M|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
  605|  3.10M|      InternalWriteMessage(2, this->_internal_pieces(i), target, stream);
  606|  3.10M|  }
  607|       |
  608|       |  // optional float score = 3;
  609|  4.06k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (609:7): [True: 0, False: 4.06k]
  ------------------
  610|      0|    target = stream->EnsureSpace(target);
  611|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_score(), target);
  612|      0|  }
  613|       |
  614|       |  // Extension range [200, 536870912)
  615|  4.06k|  target = _extensions_._InternalSerialize(
  616|  4.06k|      200, 536870912, target, stream);
  617|       |
  618|  4.06k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.06k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.06k]
  |  |  ------------------
  ------------------
  619|      0|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
  620|      0|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  621|      0|  }
  622|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.SentencePieceText)
  623|  4.06k|  return target;
  624|  4.06k|}
_ZNK13sentencepiece17SentencePieceText12ByteSizeLongEv:
  626|  4.06k|size_t SentencePieceText::ByteSizeLong() const {
  627|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.SentencePieceText)
  628|  4.06k|  size_t total_size = 0;
  629|       |
  630|  4.06k|  total_size += _extensions_.ByteSize();
  631|       |
  632|  4.06k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  633|       |  // Prevent compiler warnings about cached_has_bits being unused
  634|  4.06k|  (void) cached_has_bits;
  635|       |
  636|       |  // repeated .sentencepiece.SentencePieceText.SentencePiece pieces = 2;
  637|  4.06k|  total_size += 1UL * this->_internal_pieces_size();
  638|  3.10M|  for (const auto& msg : this->pieces_) {
  ------------------
  |  Branch (638:24): [True: 3.10M, False: 4.06k]
  ------------------
  639|  3.10M|    total_size +=
  640|  3.10M|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  641|  3.10M|  }
  642|       |
  643|  4.06k|  cached_has_bits = _has_bits_[0];
  644|  4.06k|  if (cached_has_bits & 0x00000003u) {
  ------------------
  |  Branch (644:7): [True: 3.65k, False: 413]
  ------------------
  645|       |    // optional string text = 1;
  646|  3.65k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (646:9): [True: 3.65k, False: 0]
  ------------------
  647|  3.65k|      total_size += 1 +
  648|  3.65k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
  649|  3.65k|          this->_internal_text());
  650|  3.65k|    }
  651|       |
  652|       |    // optional float score = 3;
  653|  3.65k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (653:9): [True: 0, False: 3.65k]
  ------------------
  654|      0|      total_size += 1 + 4;
  655|      0|    }
  656|       |
  657|  3.65k|  }
  658|  4.06k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.06k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.06k]
  |  |  ------------------
  ------------------
  659|      0|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  660|      0|  }
  661|  4.06k|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  662|  4.06k|  SetCachedSize(cached_size);
  663|  4.06k|  return total_size;
  664|  4.06k|}
_ZN13sentencepiece22NBestSentencePieceTextC2EPN6google8protobuf5ArenaE:
  731|  2.03k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  732|  2.03k|  nbests_(arena) {
  733|  2.03k|  SharedCtor();
  734|  2.03k|  RegisterArenaDtor(arena);
  735|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.NBestSentencePieceText)
  736|  2.03k|}
_ZN13sentencepiece22NBestSentencePieceTextD2Ev:
  748|  2.03k|NBestSentencePieceText::~NBestSentencePieceText() {
  749|       |  // @@protoc_insertion_point(destructor:sentencepiece.NBestSentencePieceText)
  750|  2.03k|  SharedDtor();
  751|  2.03k|  _internal_metadata_.Delete<std::string>();
  752|  2.03k|}
_ZN13sentencepiece22NBestSentencePieceText5ClearEv:
  773|  2.03k|void NBestSentencePieceText::Clear() {
  774|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.NBestSentencePieceText)
  775|  2.03k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  776|       |  // Prevent compiler warnings about cached_has_bits being unused
  777|  2.03k|  (void) cached_has_bits;
  778|       |
  779|  2.03k|  nbests_.Clear();
  780|  2.03k|  _internal_metadata_.Clear<std::string>();
  781|  2.03k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece31SentencePieceText_SentencePieceEJEEEPT_PS1_DpOT0_:
  911|  11.5M|template<> PROTOBUF_NOINLINE ::sentencepiece::SentencePieceText_SentencePiece* Arena::CreateMaybeMessage< ::sentencepiece::SentencePieceText_SentencePiece >(Arena* arena) {
  912|  11.5M|  return Arena::CreateMessageInternal< ::sentencepiece::SentencePieceText_SentencePiece >(arena);
  913|  11.5M|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece17SentencePieceTextEJEEEPT_PS1_DpOT0_:
  914|  2.14k|template<> PROTOBUF_NOINLINE ::sentencepiece::SentencePieceText* Arena::CreateMaybeMessage< ::sentencepiece::SentencePieceText >(Arena* arena) {
  915|  2.14k|  return Arena::CreateMessageInternal< ::sentencepiece::SentencePieceText >(arena);
  916|  2.14k|}
sentencepiece.pb.cc:_ZL65InitDefaultsscc_info_NBestSentencePieceText_sentencepiece_2eprotov:
   30|      1|static void InitDefaultsscc_info_NBestSentencePieceText_sentencepiece_2eproto() {
   31|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   32|       |
   33|      1|  {
   34|      1|    void* ptr = &::sentencepiece::_NBestSentencePieceText_default_instance_;
   35|      1|    new (ptr) ::sentencepiece::NBestSentencePieceText();
   36|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   37|      1|  }
   38|      1|}
sentencepiece.pb.cc:_ZL60InitDefaultsscc_info_SentencePieceText_sentencepiece_2eprotov:
   44|      1|static void InitDefaultsscc_info_SentencePieceText_sentencepiece_2eproto() {
   45|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   46|       |
   47|      1|  {
   48|      1|    void* ptr = &::sentencepiece::_SentencePieceText_default_instance_;
   49|      1|    new (ptr) ::sentencepiece::SentencePieceText();
   50|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   51|      1|  }
   52|      1|}
sentencepiece.pb.cc:_ZL74InitDefaultsscc_info_SentencePieceText_SentencePiece_sentencepiece_2eprotov:
   58|      1|static void InitDefaultsscc_info_SentencePieceText_SentencePiece_sentencepiece_2eproto() {
   59|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   60|       |
   61|      1|  {
   62|      1|    void* ptr = &::sentencepiece::_SentencePieceText_SentencePiece_default_instance_;
   63|      1|    new (ptr) ::sentencepiece::SentencePieceText_SentencePiece();
   64|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   65|      1|  }
   66|      1|}
_ZN13sentencepiece31SentencePieceText_SentencePiece10SharedCtorEv:
  123|  11.5M|void SentencePieceText_SentencePiece::SharedCtor() {
  124|  11.5M|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SentencePieceText_SentencePiece_sentencepiece_2eproto.base);
  125|  11.5M|  piece_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  126|  11.5M|  surface_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  127|  11.5M|  ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
  128|  11.5M|      reinterpret_cast<char*>(&id_) - reinterpret_cast<char*>(this)),
  129|  11.5M|      0, static_cast<size_t>(reinterpret_cast<char*>(&end_) -
  130|  11.5M|      reinterpret_cast<char*>(&id_)) + sizeof(end_));
  131|  11.5M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece10SharedDtorEv:
  139|  11.5M|void SentencePieceText_SentencePiece::SharedDtor() {
  140|  11.5M|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  11.5M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 11.5M]
  |  |  ------------------
  ------------------
  141|  11.5M|  piece_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  142|  11.5M|  surface_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  143|  11.5M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece17RegisterArenaDtorEPN6google8protobuf5ArenaE:
  149|  11.5M|void SentencePieceText_SentencePiece::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  150|  11.5M|}
_ZN13sentencepiece17SentencePieceText10SharedCtorEv:
  473|  14.4k|void SentencePieceText::SharedCtor() {
  474|  14.4k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SentencePieceText_sentencepiece_2eproto.base);
  475|  14.4k|  text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  476|  14.4k|  score_ = 0;
  477|  14.4k|}
_ZN13sentencepiece17SentencePieceText10SharedDtorEv:
  485|  14.4k|void SentencePieceText::SharedDtor() {
  486|  14.4k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  14.4k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 14.4k]
  |  |  ------------------
  ------------------
  487|  14.4k|  text_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  488|  14.4k|}
_ZN13sentencepiece17SentencePieceText17RegisterArenaDtorEPN6google8protobuf5ArenaE:
  494|  14.4k|void SentencePieceText::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  495|  14.4k|}
_ZN13sentencepiece22NBestSentencePieceText10SharedCtorEv:
  744|  2.03k|void NBestSentencePieceText::SharedCtor() {
  745|  2.03k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NBestSentencePieceText_sentencepiece_2eproto.base);
  746|  2.03k|}
_ZN13sentencepiece22NBestSentencePieceText10SharedDtorEv:
  754|  2.03k|void NBestSentencePieceText::SharedDtor() {
  755|  2.03k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  2.03k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 2.03k]
  |  |  ------------------
  ------------------
  756|  2.03k|}
_ZN13sentencepiece22NBestSentencePieceText17RegisterArenaDtorEPN6google8protobuf5ArenaE:
  762|  2.03k|void NBestSentencePieceText::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  763|  2.03k|}

_ZNK13sentencepiece31SentencePieceText_SentencePiece5pieceEv:
  621|  8.41M|inline const std::string& SentencePieceText_SentencePiece::piece() const {
  622|       |  // @@protoc_insertion_point(field_get:sentencepiece.SentencePieceText.SentencePiece.piece)
  623|  8.41M|  return _internal_piece();
  624|  8.41M|}
_ZNK13sentencepiece31SentencePieceText_SentencePiece15_internal_pieceEv:
  633|  14.6M|inline const std::string& SentencePieceText_SentencePiece::_internal_piece() const {
  634|  14.6M|  return piece_.Get();
  635|  14.6M|}
_ZNK13sentencepiece31SentencePieceText_SentencePiece17_internal_surfaceEv:
  734|  6.20M|inline const std::string& SentencePieceText_SentencePiece::_internal_surface() const {
  735|  6.20M|  return surface_.Get();
  736|  6.20M|}
_ZNK13sentencepiece31SentencePieceText_SentencePiece2idEv:
  697|  6.26M|inline ::PROTOBUF_NAMESPACE_ID::uint32 SentencePieceText_SentencePiece::id() const {
  698|       |  // @@protoc_insertion_point(field_get:sentencepiece.SentencePieceText.SentencePiece.id)
  699|  6.26M|  return _internal_id();
  700|  6.26M|}
_ZNK13sentencepiece31SentencePieceText_SentencePiece12_internal_idEv:
  694|  12.4M|inline ::PROTOBUF_NAMESPACE_ID::uint32 SentencePieceText_SentencePiece::_internal_id() const {
  695|  12.4M|  return id_;
  696|  12.4M|}
_ZNK13sentencepiece31SentencePieceText_SentencePiece15_internal_beginEv:
  795|  6.20M|inline ::PROTOBUF_NAMESPACE_ID::uint32 SentencePieceText_SentencePiece::_internal_begin() const {
  796|  6.20M|  return begin_;
  797|  6.20M|}
_ZNK13sentencepiece31SentencePieceText_SentencePiece13_internal_endEv:
  823|  6.20M|inline ::PROTOBUF_NAMESPACE_ID::uint32 SentencePieceText_SentencePiece::_internal_end() const {
  824|  6.20M|  return end_;
  825|  6.20M|}
_ZNK13sentencepiece17SentencePieceText11pieces_sizeEv:
  920|  47.8M|inline int SentencePieceText::pieces_size() const {
  921|  47.8M|  return _internal_pieces_size();
  922|  47.8M|}
_ZNK13sentencepiece17SentencePieceText21_internal_pieces_sizeEv:
  917|  47.9M|inline int SentencePieceText::_internal_pieces_size() const {
  918|  47.9M|  return pieces_.size();
  919|  47.9M|}
_ZNK13sentencepiece17SentencePieceText6piecesEi:
  938|  3.13M|inline const ::sentencepiece::SentencePieceText_SentencePiece& SentencePieceText::pieces(int index) const {
  939|       |  // @@protoc_insertion_point(field_get:sentencepiece.SentencePieceText.pieces)
  940|  3.13M|  return _internal_pieces(index);
  941|  3.13M|}
_ZNK13sentencepiece17SentencePieceText16_internal_piecesEi:
  935|  6.23M|inline const ::sentencepiece::SentencePieceText_SentencePiece& SentencePieceText::_internal_pieces(int index) const {
  936|  6.23M|  return pieces_.Get(index);
  937|  6.23M|}
_ZNK13sentencepiece17SentencePieceText14_internal_textEv:
  867|  7.30k|inline const std::string& SentencePieceText::_internal_text() const {
  868|  7.30k|  return text_.Get();
  869|  7.30k|}
_ZNK13sentencepiece17SentencePieceText6piecesEv:
  950|  9.88k|SentencePieceText::pieces() const {
  951|       |  // @@protoc_insertion_point(field_list:sentencepiece.SentencePieceText.pieces)
  952|  9.88k|  return pieces_;
  953|  9.88k|}
_ZN13sentencepiece17SentencePieceText12mutable_textEv:
  863|  7.76k|inline std::string* SentencePieceText::mutable_text() {
  864|       |  // @@protoc_insertion_point(field_mutable:sentencepiece.SentencePieceText.text)
  865|  7.76k|  return _internal_mutable_text();
  866|  7.76k|}
_ZN13sentencepiece17SentencePieceText22_internal_mutable_textEv:
  893|  7.76k|inline std::string* SentencePieceText::_internal_mutable_text() {
  894|  7.76k|  _has_bits_[0] |= 0x00000001u;
  895|  7.76k|  return text_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
  896|  7.76k|}
_ZNK13sentencepiece22NBestSentencePieceText6nbestsEv:
 1021|  3.16k|NBestSentencePieceText::nbests() const {
 1022|       |  // @@protoc_insertion_point(field_list:sentencepiece.NBestSentencePieceText.nbests)
 1023|  3.16k|  return nbests_;
 1024|  3.16k|}
_ZN13sentencepiece17SentencePieceText10add_piecesEv:
  945|  11.5M|inline ::sentencepiece::SentencePieceText_SentencePiece* SentencePieceText::add_pieces() {
  946|       |  // @@protoc_insertion_point(field_add:sentencepiece.SentencePieceText.pieces)
  947|  11.5M|  return _internal_add_pieces();
  948|  11.5M|}
_ZN13sentencepiece17SentencePieceText20_internal_add_piecesEv:
  942|  11.5M|inline ::sentencepiece::SentencePieceText_SentencePiece* SentencePieceText::_internal_add_pieces() {
  943|  11.5M|  return pieces_.Add();
  944|  11.5M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece9set_pieceEPKcm:
  653|  8.38M|    size_t size) {
  654|  8.38M|  _has_bits_[0] |= 0x00000001u;
  655|  8.38M|  piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
  656|  8.38M|      reinterpret_cast<const char*>(value), size), GetArena());
  657|       |  // @@protoc_insertion_point(field_set_pointer:sentencepiece.SentencePieceText.SentencePiece.piece)
  658|  8.38M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece6set_idEj:
  705|  11.5M|inline void SentencePieceText_SentencePiece::set_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  706|  11.5M|  _internal_set_id(value);
  707|       |  // @@protoc_insertion_point(field_set:sentencepiece.SentencePieceText.SentencePiece.id)
  708|  11.5M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece16_internal_set_idEj:
  701|  11.5M|inline void SentencePieceText_SentencePiece::_internal_set_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  702|  11.5M|  _has_bits_[0] |= 0x00000004u;
  703|  11.5M|  id_ = value;
  704|  11.5M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece9set_beginEj:
  806|  11.5M|inline void SentencePieceText_SentencePiece::set_begin(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  807|  11.5M|  _internal_set_begin(value);
  808|       |  // @@protoc_insertion_point(field_set:sentencepiece.SentencePieceText.SentencePiece.begin)
  809|  11.5M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece19_internal_set_beginEj:
  802|  11.5M|inline void SentencePieceText_SentencePiece::_internal_set_begin(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  803|  11.5M|  _has_bits_[0] |= 0x00000008u;
  804|  11.5M|  begin_ = value;
  805|  11.5M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece7set_endEj:
  834|  56.2M|inline void SentencePieceText_SentencePiece::set_end(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  835|  56.2M|  _internal_set_end(value);
  836|       |  // @@protoc_insertion_point(field_set:sentencepiece.SentencePieceText.SentencePiece.end)
  837|  56.2M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece17_internal_set_endEj:
  830|  56.2M|inline void SentencePieceText_SentencePiece::_internal_set_end(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  831|  56.2M|  _has_bits_[0] |= 0x00000010u;
  832|  56.2M|  end_ = value;
  833|  56.2M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece13mutable_pieceEv:
  629|  47.8M|inline std::string* SentencePieceText_SentencePiece::mutable_piece() {
  630|       |  // @@protoc_insertion_point(field_mutable:sentencepiece.SentencePieceText.SentencePiece.piece)
  631|  47.8M|  return _internal_mutable_piece();
  632|  47.8M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece23_internal_mutable_pieceEv:
  659|  47.8M|inline std::string* SentencePieceText_SentencePiece::_internal_mutable_piece() {
  660|  47.8M|  _has_bits_[0] |= 0x00000001u;
  661|  47.8M|  return piece_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
  662|  47.8M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece11set_surfaceEPKcm:
  754|  11.5M|    size_t size) {
  755|  11.5M|  _has_bits_[0] |= 0x00000002u;
  756|  11.5M|  surface_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
  757|  11.5M|      reinterpret_cast<const char*>(value), size), GetArena());
  758|       |  // @@protoc_insertion_point(field_set_pointer:sentencepiece.SentencePieceText.SentencePiece.surface)
  759|  11.5M|}
_ZN13sentencepiece17SentencePieceText14mutable_piecesEi:
  926|  47.8M|inline ::sentencepiece::SentencePieceText_SentencePiece* SentencePieceText::mutable_pieces(int index) {
  927|       |  // @@protoc_insertion_point(field_mutable:sentencepiece.SentencePieceText.pieces)
  928|  47.8M|  return pieces_.Mutable(index);
  929|  47.8M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece15mutable_surfaceEv:
  730|  44.7M|inline std::string* SentencePieceText_SentencePiece::mutable_surface() {
  731|       |  // @@protoc_insertion_point(field_mutable:sentencepiece.SentencePieceText.SentencePiece.surface)
  732|  44.7M|  return _internal_mutable_surface();
  733|  44.7M|}
_ZN13sentencepiece31SentencePieceText_SentencePiece25_internal_mutable_surfaceEv:
  760|  44.7M|inline std::string* SentencePieceText_SentencePiece::_internal_mutable_surface() {
  761|  44.7M|  _has_bits_[0] |= 0x00000002u;
  762|  44.7M|  return surface_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
  763|  44.7M|}
_ZN13sentencepiece17SentencePieceText8set_textEPKcm:
  887|  9.75k|    size_t size) {
  888|  9.75k|  _has_bits_[0] |= 0x00000001u;
  889|  9.75k|  text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
  890|  9.75k|      reinterpret_cast<const char*>(value), size), GetArena());
  891|       |  // @@protoc_insertion_point(field_set_pointer:sentencepiece.SentencePieceText.text)
  892|  9.75k|}
_ZN13sentencepiece22NBestSentencePieceText10add_nbestsEv:
 1016|  2.14k|inline ::sentencepiece::SentencePieceText* NBestSentencePieceText::add_nbests() {
 1017|       |  // @@protoc_insertion_point(field_add:sentencepiece.NBestSentencePieceText.nbests)
 1018|  2.14k|  return _internal_add_nbests();
 1019|  2.14k|}
_ZN13sentencepiece22NBestSentencePieceText20_internal_add_nbestsEv:
 1013|  2.14k|inline ::sentencepiece::SentencePieceText* NBestSentencePieceText::_internal_add_nbests() {
 1014|  2.14k|  return nbests_.Add();
 1015|  2.14k|}
_ZN13sentencepiece17SentencePieceText9set_scoreEf:
  978|  2.14k|inline void SentencePieceText::set_score(float value) {
  979|  2.14k|  _internal_set_score(value);
  980|       |  // @@protoc_insertion_point(field_set:sentencepiece.SentencePieceText.score)
  981|  2.14k|}
_ZN13sentencepiece17SentencePieceText19_internal_set_scoreEf:
  974|  2.14k|inline void SentencePieceText::_internal_set_score(float value) {
  975|  2.14k|  _has_bits_[0] |= 0x00000002u;
  976|  2.14k|  score_ = value;
  977|  2.14k|}
_ZN13sentencepiece17SentencePieceText14mutable_piecesEv:
  931|  3.88k|SentencePieceText::mutable_pieces() {
  932|       |  // @@protoc_insertion_point(field_mutable_list:sentencepiece.SentencePieceText.pieces)
  933|  3.88k|  return &pieces_;
  934|  3.88k|}
_ZN13sentencepiece17SentencePieceTextC2Ev:
  286|  14.4k|  inline SentencePieceText() : SentencePieceText(nullptr) {}
_ZN13sentencepiece22NBestSentencePieceTextC2Ev:
  466|  2.03k|  inline NBestSentencePieceText() : NBestSentencePieceText(nullptr) {}
_ZN13sentencepiece31SentencePieceText_SentencePieceC2Ev:
   76|  11.5M|  inline SentencePieceText_SentencePiece() : SentencePieceText_SentencePiece(nullptr) {}
_ZNK13sentencepiece31SentencePieceText_SentencePiece13GetCachedSizeEv:
  152|  3.10M|  int GetCachedSize() const final { return _cached_size_.Get(); }
_ZN13sentencepiece17SentencePieceText25internal_default_instanceEv:
  317|  4.06k|  static inline const SentencePieceText* internal_default_instance() {
  318|  4.06k|    return reinterpret_cast<const SentencePieceText*>(
  319|  4.06k|               &_SentencePieceText_default_instance_);
  320|  4.06k|  }

_ZN13sentencepiece29TrainerSpec_ModelType_IsValidEi:
  129|  3.95k|bool TrainerSpec_ModelType_IsValid(int value) {
  130|  3.95k|  switch (value) {
  131|     14|    case 1:
  ------------------
  |  Branch (131:5): [True: 14, False: 3.94k]
  ------------------
  132|    309|    case 2:
  ------------------
  |  Branch (132:5): [True: 295, False: 3.66k]
  ------------------
  133|    644|    case 3:
  ------------------
  |  Branch (133:5): [True: 335, False: 3.62k]
  ------------------
  134|    797|    case 4:
  ------------------
  |  Branch (134:5): [True: 153, False: 3.80k]
  ------------------
  135|    797|      return true;
  136|  3.16k|    default:
  ------------------
  |  Branch (136:5): [True: 3.16k, False: 797]
  ------------------
  137|  3.16k|      return false;
  138|  3.95k|  }
  139|  3.95k|}
_ZN13sentencepiece37ModelProto_SentencePiece_Type_IsValidEi:
  197|  29.0k|bool ModelProto_SentencePiece_Type_IsValid(int value) {
  198|  29.0k|  switch (value) {
  199|      2|    case 1:
  ------------------
  |  Branch (199:5): [True: 2, False: 29.0k]
  ------------------
  200|  3.07k|    case 2:
  ------------------
  |  Branch (200:5): [True: 3.06k, False: 25.9k]
  ------------------
  201|  6.15k|    case 3:
  ------------------
  |  Branch (201:5): [True: 3.08k, False: 25.9k]
  ------------------
  202|  6.79k|    case 4:
  ------------------
  |  Branch (202:5): [True: 646, False: 28.3k]
  ------------------
  203|  6.84k|    case 5:
  ------------------
  |  Branch (203:5): [True: 50, False: 28.9k]
  ------------------
  204|  26.8k|    case 6:
  ------------------
  |  Branch (204:5): [True: 19.9k, False: 9.04k]
  ------------------
  205|  26.8k|      return true;
  206|  2.19k|    default:
  ------------------
  |  Branch (206:5): [True: 2.19k, False: 26.8k]
  ------------------
  207|  2.19k|      return false;
  208|  29.0k|  }
  209|  29.0k|}
_ZN13sentencepiece11TrainerSpecC2EPN6google8protobuf5ArenaE:
  415|  2.90k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  416|  2.90k|  _extensions_(arena),
  417|  2.90k|  input_(arena),
  418|  2.90k|  accept_language_(arena),
  419|  2.90k|  control_symbols_(arena),
  420|  2.90k|  user_defined_symbols_(arena) {
  421|  2.90k|  SharedCtor();
  422|  2.90k|  RegisterArenaDtor(arena);
  423|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.TrainerSpec)
  424|  2.90k|}
_ZN13sentencepiece11TrainerSpecD2Ev:
  526|  2.89k|TrainerSpec::~TrainerSpec() {
  527|       |  // @@protoc_insertion_point(destructor:sentencepiece.TrainerSpec)
  528|  2.89k|  SharedDtor();
  529|  2.89k|  _internal_metadata_.Delete<std::string>();
  530|  2.89k|}
_ZNK13sentencepiece11TrainerSpec13SetCachedSizeEi:
  552|    556|void TrainerSpec::SetCachedSize(int size) const {
  553|    556|  _cached_size_.Set(size);
  554|    556|}
_ZN13sentencepiece11TrainerSpec14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE:
  646|  3.16k|const char* TrainerSpec::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
  647|  3.16k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  648|  43.3k|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (648:10): [True: 41.2k, False: 2.03k]
  ------------------
  649|  41.2k|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  650|  41.2k|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
  651|  41.2k|    CHK_(ptr);
  ------------------
  |  |  647|  41.2k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  41.2k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 80, False: 41.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  652|  41.1k|    switch (tag >> 3) {
  653|       |      // repeated string input = 1;
  654|  1.90k|      case 1:
  ------------------
  |  Branch (654:7): [True: 1.90k, False: 39.2k]
  ------------------
  655|  1.90k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
  ------------------
  |  |  236|  1.90k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1.32k, False: 579]
  |  |  ------------------
  ------------------
  656|  1.32k|          ptr -= 1;
  657|  14.7k|          do {
  658|  14.7k|            ptr += 1;
  659|  14.7k|            auto str = _internal_add_input();
  660|  14.7k|            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  661|  14.7k|            CHK_(ptr);
  ------------------
  |  |  647|  14.7k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  14.7k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 34, False: 14.7k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  662|  14.7k|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (662:17): [True: 65, False: 14.6k]
  ------------------
  663|  14.7k|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
  ------------------
  |  Branch (663:20): [True: 13.4k, False: 1.22k]
  ------------------
  664|  1.32k|        } else goto handle_unusual;
  665|  1.28k|        continue;
  666|       |      // optional string model_prefix = 2;
  667|  2.05k|      case 2:
  ------------------
  |  Branch (667:7): [True: 2.05k, False: 39.1k]
  ------------------
  668|  2.05k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
  ------------------
  |  |  236|  2.05k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 349, False: 1.70k]
  |  |  ------------------
  ------------------
  669|    349|          auto str = _internal_mutable_model_prefix();
  670|    349|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  671|    349|          CHK_(ptr);
  ------------------
  |  |  647|    349|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    349|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 50, False: 299]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  672|  1.70k|        } else goto handle_unusual;
  673|    299|        continue;
  674|       |      // optional .sentencepiece.TrainerSpec.ModelType model_type = 3 [default = UNIGRAM];
  675|  4.10k|      case 3:
  ------------------
  |  Branch (675:7): [True: 4.10k, False: 37.0k]
  ------------------
  676|  4.10k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
  ------------------
  |  |  236|  4.10k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 3.96k, False: 143]
  |  |  ------------------
  ------------------
  677|  3.96k|          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  678|  3.96k|          CHK_(ptr);
  ------------------
  |  |  647|  3.96k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  3.96k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 3, False: 3.95k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  679|  3.95k|          if (PROTOBUF_PREDICT_TRUE(::sentencepiece::TrainerSpec_ModelType_IsValid(val))) {
  ------------------
  |  |  236|  3.95k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 797, False: 3.16k]
  |  |  ------------------
  ------------------
  680|    797|            _internal_set_model_type(static_cast<::sentencepiece::TrainerSpec_ModelType>(val));
  681|  3.16k|          } else {
  682|  3.16k|            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
  683|  3.16k|          }
  684|  3.95k|        } else goto handle_unusual;
  685|  3.95k|        continue;
  686|       |      // optional int32 vocab_size = 4 [default = 8000];
  687|  5.28k|      case 4:
  ------------------
  |  Branch (687:7): [True: 5.28k, False: 35.9k]
  ------------------
  688|  5.28k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
  ------------------
  |  |  236|  5.28k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 4.88k, False: 403]
  |  |  ------------------
  ------------------
  689|  4.88k|          _Internal::set_has_vocab_size(&_has_bits_);
  690|  4.88k|          vocab_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  691|  4.88k|          CHK_(ptr);
  ------------------
  |  |  647|  4.88k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  4.88k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 2, False: 4.88k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  692|  4.88k|        } else goto handle_unusual;
  693|  4.88k|        continue;
  694|       |      // repeated string accept_language = 5;
  695|  4.88k|      case 5:
  ------------------
  |  Branch (695:7): [True: 2.47k, False: 38.7k]
  ------------------
  696|  2.47k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
  ------------------
  |  |  236|  2.47k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 210, False: 2.26k]
  |  |  ------------------
  ------------------
  697|    210|          ptr -= 1;
  698|    907|          do {
  699|    907|            ptr += 1;
  700|    907|            auto str = _internal_add_accept_language();
  701|    907|            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  702|    907|            CHK_(ptr);
  ------------------
  |  |  647|    907|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    907|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 15, False: 892]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  703|    892|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (703:17): [True: 54, False: 838]
  ------------------
  704|    892|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
  ------------------
  |  Branch (704:20): [True: 697, False: 141]
  ------------------
  705|  2.26k|        } else goto handle_unusual;
  706|    195|        continue;
  707|       |      // optional int32 self_test_sample_size = 6 [default = 0];
  708|  1.16k|      case 6:
  ------------------
  |  Branch (708:7): [True: 1.16k, False: 40.0k]
  ------------------
  709|  1.16k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
  ------------------
  |  |  236|  1.16k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 821, False: 348]
  |  |  ------------------
  ------------------
  710|    821|          _Internal::set_has_self_test_sample_size(&_has_bits_);
  711|    821|          self_test_sample_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  712|    821|          CHK_(ptr);
  ------------------
  |  |  647|    821|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    821|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 820]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  713|    821|        } else goto handle_unusual;
  714|    820|        continue;
  715|       |      // optional string input_format = 7;
  716|    820|      case 7:
  ------------------
  |  Branch (716:7): [True: 491, False: 40.7k]
  ------------------
  717|    491|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
  ------------------
  |  |  236|    491|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 131, False: 360]
  |  |  ------------------
  ------------------
  718|    131|          auto str = _internal_mutable_input_format();
  719|    131|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  720|    131|          CHK_(ptr);
  ------------------
  |  |  647|    131|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    131|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 23, False: 108]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  721|    360|        } else goto handle_unusual;
  722|    108|        continue;
  723|       |      // optional float character_coverage = 10 [default = 0.9995];
  724|    576|      case 10:
  ------------------
  |  Branch (724:7): [True: 576, False: 40.6k]
  ------------------
  725|    576|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 85)) {
  ------------------
  |  |  236|    576|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 92, False: 484]
  |  |  ------------------
  ------------------
  726|     92|          _Internal::set_has_character_coverage(&_has_bits_);
  727|     92|          character_coverage_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
  728|     92|          ptr += sizeof(float);
  729|    484|        } else goto handle_unusual;
  730|     92|        continue;
  731|       |      // optional uint64 input_sentence_size = 11 [default = 0];
  732|  1.45k|      case 11:
  ------------------
  |  Branch (732:7): [True: 1.45k, False: 39.7k]
  ------------------
  733|  1.45k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
  ------------------
  |  |  236|  1.45k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1.00k, False: 453]
  |  |  ------------------
  ------------------
  734|  1.00k|          _Internal::set_has_input_sentence_size(&_has_bits_);
  735|  1.00k|          input_sentence_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  736|  1.00k|          CHK_(ptr);
  ------------------
  |  |  647|  1.00k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  1.00k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 1.00k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  737|  1.00k|        } else goto handle_unusual;
  738|  1.00k|        continue;
  739|       |      // optional int32 mining_sentence_size = 12 [deprecated = true];
  740|  1.00k|      case 12:
  ------------------
  |  Branch (740:7): [True: 556, False: 40.6k]
  ------------------
  741|    556|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) {
  ------------------
  |  |  236|    556|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 239, False: 317]
  |  |  ------------------
  ------------------
  742|    239|          _Internal::set_has_mining_sentence_size(&_has_bits_);
  743|    239|          mining_sentence_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  744|    239|          CHK_(ptr);
  ------------------
  |  |  647|    239|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    239|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 2, False: 237]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  745|    317|        } else goto handle_unusual;
  746|    237|        continue;
  747|       |      // optional int32 training_sentence_size = 13 [deprecated = true];
  748|  1.50k|      case 13:
  ------------------
  |  Branch (748:7): [True: 1.50k, False: 39.6k]
  ------------------
  749|  1.50k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 104)) {
  ------------------
  |  |  236|  1.50k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 806, False: 696]
  |  |  ------------------
  ------------------
  750|    806|          _Internal::set_has_training_sentence_size(&_has_bits_);
  751|    806|          training_sentence_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  752|    806|          CHK_(ptr);
  ------------------
  |  |  647|    806|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    806|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 805]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  753|    806|        } else goto handle_unusual;
  754|    805|        continue;
  755|       |      // optional int32 seed_sentencepiece_size = 14 [default = 1000000];
  756|  8.48k|      case 14:
  ------------------
  |  Branch (756:7): [True: 8.48k, False: 32.7k]
  ------------------
  757|  8.48k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) {
  ------------------
  |  |  236|  8.48k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 8.36k, False: 125]
  |  |  ------------------
  ------------------
  758|  8.36k|          _Internal::set_has_seed_sentencepiece_size(&_has_bits_);
  759|  8.36k|          seed_sentencepiece_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  760|  8.36k|          CHK_(ptr);
  ------------------
  |  |  647|  8.36k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  8.36k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 8.36k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  761|  8.36k|        } else goto handle_unusual;
  762|  8.36k|        continue;
  763|       |      // optional float shrinking_factor = 15 [default = 0.75];
  764|  8.36k|      case 15:
  ------------------
  |  Branch (764:7): [True: 1.03k, False: 40.1k]
  ------------------
  765|  1.03k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 125)) {
  ------------------
  |  |  236|  1.03k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 709, False: 323]
  |  |  ------------------
  ------------------
  766|    709|          _Internal::set_has_shrinking_factor(&_has_bits_);
  767|    709|          shrinking_factor_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
  768|    709|          ptr += sizeof(float);
  769|    709|        } else goto handle_unusual;
  770|    709|        continue;
  771|       |      // optional int32 num_threads = 16 [default = 16];
  772|    709|      case 16:
  ------------------
  |  Branch (772:7): [True: 127, False: 41.0k]
  ------------------
  773|    127|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 128)) {
  ------------------
  |  |  236|    127|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 119, False: 8]
  |  |  ------------------
  ------------------
  774|    119|          _Internal::set_has_num_threads(&_has_bits_);
  775|    119|          num_threads_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  776|    119|          CHK_(ptr);
  ------------------
  |  |  647|    119|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    119|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 118]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  777|    119|        } else goto handle_unusual;
  778|    118|        continue;
  779|       |      // optional int32 num_sub_iterations = 17 [default = 2];
  780|    142|      case 17:
  ------------------
  |  Branch (780:7): [True: 142, False: 41.0k]
  ------------------
  781|    142|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) {
  ------------------
  |  |  236|    142|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 133, False: 9]
  |  |  ------------------
  ------------------
  782|    133|          _Internal::set_has_num_sub_iterations(&_has_bits_);
  783|    133|          num_sub_iterations_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  784|    133|          CHK_(ptr);
  ------------------
  |  |  647|    133|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    133|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 2, False: 131]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  785|    133|        } else goto handle_unusual;
  786|    131|        continue;
  787|       |      // optional int32 max_sentence_length = 18 [default = 4192];
  788|    131|      case 18:
  ------------------
  |  Branch (788:7): [True: 53, False: 41.1k]
  ------------------
  789|     53|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) {
  ------------------
  |  |  236|     53|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 39, False: 14]
  |  |  ------------------
  ------------------
  790|     39|          _Internal::set_has_max_sentence_length(&_has_bits_);
  791|     39|          max_sentence_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  792|     39|          CHK_(ptr);
  ------------------
  |  |  647|     39|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     39|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 38]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  793|     39|        } else goto handle_unusual;
  794|     38|        continue;
  795|       |      // optional bool shuffle_input_sentence = 19 [default = true];
  796|  2.18k|      case 19:
  ------------------
  |  Branch (796:7): [True: 2.18k, False: 39.0k]
  ------------------
  797|  2.18k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 152)) {
  ------------------
  |  |  236|  2.18k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 2.16k, False: 21]
  |  |  ------------------
  ------------------
  798|  2.16k|          _Internal::set_has_shuffle_input_sentence(&_has_bits_);
  799|  2.16k|          shuffle_input_sentence_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  800|  2.16k|          CHK_(ptr);
  ------------------
  |  |  647|  2.16k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  2.16k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 8, False: 2.15k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  801|  2.16k|        } else goto handle_unusual;
  802|  2.15k|        continue;
  803|       |      // optional int32 max_sentencepiece_length = 20 [default = 16];
  804|  2.15k|      case 20:
  ------------------
  |  Branch (804:7): [True: 249, False: 40.9k]
  ------------------
  805|    249|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 160)) {
  ------------------
  |  |  236|    249|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 244, False: 5]
  |  |  ------------------
  ------------------
  806|    244|          _Internal::set_has_max_sentencepiece_length(&_has_bits_);
  807|    244|          max_sentencepiece_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  808|    244|          CHK_(ptr);
  ------------------
  |  |  647|    244|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    244|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 243]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  809|    244|        } else goto handle_unusual;
  810|    243|        continue;
  811|       |      // optional bool split_by_unicode_script = 21 [default = true];
  812|    445|      case 21:
  ------------------
  |  Branch (812:7): [True: 445, False: 40.7k]
  ------------------
  813|    445|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 168)) {
  ------------------
  |  |  236|    445|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 437, False: 8]
  |  |  ------------------
  ------------------
  814|    437|          _Internal::set_has_split_by_unicode_script(&_has_bits_);
  815|    437|          split_by_unicode_script_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  816|    437|          CHK_(ptr);
  ------------------
  |  |  647|    437|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    437|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 2, False: 435]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  817|    437|        } else goto handle_unusual;
  818|    435|        continue;
  819|       |      // optional bool split_by_whitespace = 22 [default = true];
  820|    435|      case 22:
  ------------------
  |  Branch (820:7): [True: 327, False: 40.8k]
  ------------------
  821|    327|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 176)) {
  ------------------
  |  |  236|    327|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 303, False: 24]
  |  |  ------------------
  ------------------
  822|    303|          _Internal::set_has_split_by_whitespace(&_has_bits_);
  823|    303|          split_by_whitespace_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  824|    303|          CHK_(ptr);
  ------------------
  |  |  647|    303|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    303|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 302]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  825|    303|        } else goto handle_unusual;
  826|    302|        continue;
  827|       |      // optional bool split_by_number = 23 [default = true];
  828|    432|      case 23:
  ------------------
  |  Branch (828:7): [True: 432, False: 40.7k]
  ------------------
  829|    432|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 184)) {
  ------------------
  |  |  236|    432|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 427, False: 5]
  |  |  ------------------
  ------------------
  830|    427|          _Internal::set_has_split_by_number(&_has_bits_);
  831|    427|          split_by_number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  832|    427|          CHK_(ptr);
  ------------------
  |  |  647|    427|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    427|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 2, False: 425]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  833|    427|        } else goto handle_unusual;
  834|    425|        continue;
  835|       |      // optional bool treat_whitespace_as_suffix = 24 [default = false];
  836|    425|      case 24:
  ------------------
  |  Branch (836:7): [True: 214, False: 40.9k]
  ------------------
  837|    214|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 192)) {
  ------------------
  |  |  236|    214|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 210, False: 4]
  |  |  ------------------
  ------------------
  838|    210|          _Internal::set_has_treat_whitespace_as_suffix(&_has_bits_);
  839|    210|          treat_whitespace_as_suffix_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  840|    210|          CHK_(ptr);
  ------------------
  |  |  647|    210|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    210|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 209]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  841|    210|        } else goto handle_unusual;
  842|    209|        continue;
  843|       |      // optional bool split_digits = 25 [default = false];
  844|    209|      case 25:
  ------------------
  |  Branch (844:7): [True: 52, False: 41.1k]
  ------------------
  845|     52|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 200)) {
  ------------------
  |  |  236|     52|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 50, False: 2]
  |  |  ------------------
  ------------------
  846|     50|          _Internal::set_has_split_digits(&_has_bits_);
  847|     50|          split_digits_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  848|     50|          CHK_(ptr);
  ------------------
  |  |  647|     50|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     50|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 2, False: 48]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  849|     50|        } else goto handle_unusual;
  850|     48|        continue;
  851|       |      // optional bool allow_whitespace_only_pieces = 26 [default = false];
  852|    113|      case 26:
  ------------------
  |  Branch (852:7): [True: 113, False: 41.0k]
  ------------------
  853|    113|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 208)) {
  ------------------
  |  |  236|    113|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 110, False: 3]
  |  |  ------------------
  ------------------
  854|    110|          _Internal::set_has_allow_whitespace_only_pieces(&_has_bits_);
  855|    110|          allow_whitespace_only_pieces_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  856|    110|          CHK_(ptr);
  ------------------
  |  |  647|    110|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    110|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 3, False: 107]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  857|    110|        } else goto handle_unusual;
  858|    107|        continue;
  859|       |      // repeated string control_symbols = 30;
  860|    107|      case 30:
  ------------------
  |  Branch (860:7): [True: 66, False: 41.1k]
  ------------------
  861|     66|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 242)) {
  ------------------
  |  |  236|     66|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 50, False: 16]
  |  |  ------------------
  ------------------
  862|     50|          ptr -= 2;
  863|    107|          do {
  864|    107|            ptr += 2;
  865|    107|            auto str = _internal_add_control_symbols();
  866|    107|            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  867|    107|            CHK_(ptr);
  ------------------
  |  |  647|    107|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    107|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 106]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  868|    106|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (868:17): [True: 15, False: 91]
  ------------------
  869|    106|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<242>(ptr));
  ------------------
  |  Branch (869:20): [True: 57, False: 34]
  ------------------
  870|     50|        } else goto handle_unusual;
  871|     49|        continue;
  872|       |      // repeated string user_defined_symbols = 31;
  873|     49|      case 31:
  ------------------
  |  Branch (873:7): [True: 44, False: 41.1k]
  ------------------
  874|     44|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) {
  ------------------
  |  |  236|     44|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 36, False: 8]
  |  |  ------------------
  ------------------
  875|     36|          ptr -= 2;
  876|     52|          do {
  877|     52|            ptr += 2;
  878|     52|            auto str = _internal_add_user_defined_symbols();
  879|     52|            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  880|     52|            CHK_(ptr);
  ------------------
  |  |  647|     52|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     52|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 5, False: 47]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  881|     47|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (881:17): [True: 7, False: 40]
  ------------------
  882|     47|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<250>(ptr));
  ------------------
  |  Branch (882:20): [True: 16, False: 24]
  ------------------
  883|     36|        } else goto handle_unusual;
  884|     31|        continue;
  885|       |      // optional bool vocabulary_output_piece_score = 32 [default = true];
  886|    128|      case 32:
  ------------------
  |  Branch (886:7): [True: 128, False: 41.0k]
  ------------------
  887|    128|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 0)) {
  ------------------
  |  |  236|    128|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 116, False: 12]
  |  |  ------------------
  ------------------
  888|    116|          _Internal::set_has_vocabulary_output_piece_score(&_has_bits_);
  889|    116|          vocabulary_output_piece_score_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  890|    116|          CHK_(ptr);
  ------------------
  |  |  647|    116|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    116|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 115]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  891|    116|        } else goto handle_unusual;
  892|    115|        continue;
  893|       |      // optional bool hard_vocab_limit = 33 [default = true];
  894|    115|      case 33:
  ------------------
  |  Branch (894:7): [True: 40, False: 41.1k]
  ------------------
  895|     40|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
  ------------------
  |  |  236|     40|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 37, False: 3]
  |  |  ------------------
  ------------------
  896|     37|          _Internal::set_has_hard_vocab_limit(&_has_bits_);
  897|     37|          hard_vocab_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  898|     37|          CHK_(ptr);
  ------------------
  |  |  647|     37|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     37|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 36]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  899|     37|        } else goto handle_unusual;
  900|     36|        continue;
  901|       |      // optional bool use_all_vocab = 34 [default = false];
  902|    266|      case 34:
  ------------------
  |  Branch (902:7): [True: 266, False: 40.9k]
  ------------------
  903|    266|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
  ------------------
  |  |  236|    266|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 265, False: 1]
  |  |  ------------------
  ------------------
  904|    265|          _Internal::set_has_use_all_vocab(&_has_bits_);
  905|    265|          use_all_vocab_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  906|    265|          CHK_(ptr);
  ------------------
  |  |  647|    265|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    265|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 264]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  907|    265|        } else goto handle_unusual;
  908|    264|        continue;
  909|       |      // optional bool byte_fallback = 35 [default = false];
  910|    264|      case 35:
  ------------------
  |  Branch (910:7): [True: 150, False: 41.0k]
  ------------------
  911|    150|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
  ------------------
  |  |  236|    150|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 146, False: 4]
  |  |  ------------------
  ------------------
  912|    146|          _Internal::set_has_byte_fallback(&_has_bits_);
  913|    146|          byte_fallback_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  914|    146|          CHK_(ptr);
  ------------------
  |  |  647|    146|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    146|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 145]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  915|    146|        } else goto handle_unusual;
  916|    145|        continue;
  917|       |      // optional string required_chars = 36;
  918|    145|      case 36:
  ------------------
  |  Branch (918:7): [True: 30, False: 41.1k]
  ------------------
  919|     30|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
  ------------------
  |  |  236|     30|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 14, False: 16]
  |  |  ------------------
  ------------------
  920|     14|          auto str = _internal_mutable_required_chars();
  921|     14|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  922|     14|          CHK_(ptr);
  ------------------
  |  |  647|     14|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     14|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 4, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  923|     16|        } else goto handle_unusual;
  924|     10|        continue;
  925|       |      // optional int32 unk_id = 40 [default = 0];
  926|     40|      case 40:
  ------------------
  |  Branch (926:7): [True: 40, False: 41.1k]
  ------------------
  927|     40|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
  ------------------
  |  |  236|     40|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 37, False: 3]
  |  |  ------------------
  ------------------
  928|     37|          _Internal::set_has_unk_id(&_has_bits_);
  929|     37|          unk_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  930|     37|          CHK_(ptr);
  ------------------
  |  |  647|     37|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     37|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 36]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  931|     37|        } else goto handle_unusual;
  932|     36|        continue;
  933|       |      // optional int32 bos_id = 41 [default = 1];
  934|     70|      case 41:
  ------------------
  |  Branch (934:7): [True: 70, False: 41.1k]
  ------------------
  935|     70|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
  ------------------
  |  |  236|     70|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 65, False: 5]
  |  |  ------------------
  ------------------
  936|     65|          _Internal::set_has_bos_id(&_has_bits_);
  937|     65|          bos_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  938|     65|          CHK_(ptr);
  ------------------
  |  |  647|     65|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     65|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 64]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  939|     65|        } else goto handle_unusual;
  940|     64|        continue;
  941|       |      // optional int32 eos_id = 42 [default = 2];
  942|    151|      case 42:
  ------------------
  |  Branch (942:7): [True: 151, False: 41.0k]
  ------------------
  943|    151|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
  ------------------
  |  |  236|    151|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 144, False: 7]
  |  |  ------------------
  ------------------
  944|    144|          _Internal::set_has_eos_id(&_has_bits_);
  945|    144|          eos_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  946|    144|          CHK_(ptr);
  ------------------
  |  |  647|    144|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    144|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 143]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  947|    144|        } else goto handle_unusual;
  948|    143|        continue;
  949|       |      // optional int32 pad_id = 43 [default = -1];
  950|    143|      case 43:
  ------------------
  |  Branch (950:7): [True: 35, False: 41.1k]
  ------------------
  951|     35|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
  ------------------
  |  |  236|     35|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 32, False: 3]
  |  |  ------------------
  ------------------
  952|     32|          _Internal::set_has_pad_id(&_has_bits_);
  953|     32|          pad_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  954|     32|          CHK_(ptr);
  ------------------
  |  |  647|     32|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     32|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 31]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  955|     32|        } else goto handle_unusual;
  956|     31|        continue;
  957|       |      // optional string unk_surface = 44 [default = " \342\201\207 "];
  958|     70|      case 44:
  ------------------
  |  Branch (958:7): [True: 70, False: 41.1k]
  ------------------
  959|     70|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
  ------------------
  |  |  236|     70|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 55, False: 15]
  |  |  ------------------
  ------------------
  960|     55|          auto str = _internal_mutable_unk_surface();
  961|     55|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  962|     55|          CHK_(ptr);
  ------------------
  |  |  647|     55|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     55|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 7, False: 48]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  963|     55|        } else goto handle_unusual;
  964|     48|        continue;
  965|       |      // optional string unk_piece = 45 [default = "<unk>"];
  966|     48|      case 45:
  ------------------
  |  Branch (966:7): [True: 35, False: 41.1k]
  ------------------
  967|     35|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
  ------------------
  |  |  236|     35|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 21, False: 14]
  |  |  ------------------
  ------------------
  968|     21|          auto str = _internal_mutable_unk_piece();
  969|     21|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  970|     21|          CHK_(ptr);
  ------------------
  |  |  647|     21|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     21|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 3, False: 18]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  971|     21|        } else goto handle_unusual;
  972|     18|        continue;
  973|       |      // optional string bos_piece = 46 [default = "<s>"];
  974|     44|      case 46:
  ------------------
  |  Branch (974:7): [True: 44, False: 41.1k]
  ------------------
  975|     44|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
  ------------------
  |  |  236|     44|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 33, False: 11]
  |  |  ------------------
  ------------------
  976|     33|          auto str = _internal_mutable_bos_piece();
  977|     33|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  978|     33|          CHK_(ptr);
  ------------------
  |  |  647|     33|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     33|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 2, False: 31]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  979|     33|        } else goto handle_unusual;
  980|     31|        continue;
  981|       |      // optional string eos_piece = 47 [default = "</s>"];
  982|     40|      case 47:
  ------------------
  |  Branch (982:7): [True: 40, False: 41.1k]
  ------------------
  983|     40|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
  ------------------
  |  |  236|     40|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 30, False: 10]
  |  |  ------------------
  ------------------
  984|     30|          auto str = _internal_mutable_eos_piece();
  985|     30|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  986|     30|          CHK_(ptr);
  ------------------
  |  |  647|     30|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     30|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 7, False: 23]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  987|     30|        } else goto handle_unusual;
  988|     23|        continue;
  989|       |      // optional string pad_piece = 48 [default = "<pad>"];
  990|     33|      case 48:
  ------------------
  |  Branch (990:7): [True: 33, False: 41.1k]
  ------------------
  991|     33|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
  ------------------
  |  |  236|     33|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 28, False: 5]
  |  |  ------------------
  ------------------
  992|     28|          auto str = _internal_mutable_pad_piece();
  993|     28|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  994|     28|          CHK_(ptr);
  ------------------
  |  |  647|     28|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     28|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 6, False: 22]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  995|     28|        } else goto handle_unusual;
  996|     22|        continue;
  997|       |      // optional bool train_extremely_large_corpus = 49 [default = false];
  998|     51|      case 49:
  ------------------
  |  Branch (998:7): [True: 51, False: 41.1k]
  ------------------
  999|     51|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) {
  ------------------
  |  |  236|     51|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 49, False: 2]
  |  |  ------------------
  ------------------
 1000|     49|          _Internal::set_has_train_extremely_large_corpus(&_has_bits_);
 1001|     49|          train_extremely_large_corpus_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 1002|     49|          CHK_(ptr);
  ------------------
  |  |  647|     49|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|     49|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 2, False: 47]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1003|     49|        } else goto handle_unusual;
 1004|     47|        continue;
 1005|       |      // optional bool enable_differential_privacy = 50 [default = false];
 1006|    114|      case 50:
  ------------------
  |  Branch (1006:7): [True: 114, False: 41.0k]
  ------------------
 1007|    114|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) {
  ------------------
  |  |  236|    114|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 111, False: 3]
  |  |  ------------------
  ------------------
 1008|    111|          _Internal::set_has_enable_differential_privacy(&_has_bits_);
 1009|    111|          enable_differential_privacy_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 1010|    111|          CHK_(ptr);
  ------------------
  |  |  647|    111|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    111|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 3, False: 108]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1011|    111|        } else goto handle_unusual;
 1012|    108|        continue;
 1013|       |      // optional float differential_privacy_noise_level = 51 [default = 0];
 1014|    108|      case 51:
  ------------------
  |  Branch (1014:7): [True: 27, False: 41.1k]
  ------------------
 1015|     27|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 157)) {
  ------------------
  |  |  236|     27|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 8, False: 19]
  |  |  ------------------
  ------------------
 1016|      8|          _Internal::set_has_differential_privacy_noise_level(&_has_bits_);
 1017|      8|          differential_privacy_noise_level_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
 1018|      8|          ptr += sizeof(float);
 1019|     19|        } else goto handle_unusual;
 1020|      8|        continue;
 1021|       |      // optional uint64 differential_privacy_clipping_threshold = 52 [default = 0];
 1022|    159|      case 52:
  ------------------
  |  Branch (1022:7): [True: 159, False: 41.0k]
  ------------------
 1023|    159|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 160)) {
  ------------------
  |  |  236|    159|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 156, False: 3]
  |  |  ------------------
  ------------------
 1024|    156|          _Internal::set_has_differential_privacy_clipping_threshold(&_has_bits_);
 1025|    156|          differential_privacy_clipping_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 1026|    156|          CHK_(ptr);
  ------------------
  |  |  647|    156|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    156|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 155]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1027|    156|        } else goto handle_unusual;
 1028|    155|        continue;
 1029|       |      // optional string pretokenization_delimiter = 53 [default = ""];
 1030|    155|      case 53:
  ------------------
  |  Branch (1030:7): [True: 15, False: 41.1k]
  ------------------
 1031|     15|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
  ------------------
  |  |  236|     15|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 9, False: 6]
  |  |  ------------------
  ------------------
 1032|      9|          auto str = _internal_mutable_pretokenization_delimiter();
 1033|      9|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 1034|      9|          CHK_(ptr);
  ------------------
  |  |  647|      9|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      9|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 3, False: 6]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1035|      9|        } else goto handle_unusual;
 1036|      6|        continue;
 1037|       |      // optional string seed_sentencepieces_file = 54 [default = ""];
 1038|     12|      case 54:
  ------------------
  |  Branch (1038:7): [True: 12, False: 41.1k]
  ------------------
 1039|     12|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
  ------------------
  |  |  236|     12|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 5, False: 7]
  |  |  ------------------
  ------------------
 1040|      5|          auto str = _internal_mutable_seed_sentencepieces_file();
 1041|      5|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 1042|      5|          CHK_(ptr);
  ------------------
  |  |  647|      5|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      5|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 3, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1043|      7|        } else goto handle_unusual;
 1044|      2|        continue;
 1045|  4.14k|      default: {
  ------------------
  |  Branch (1045:7): [True: 4.14k, False: 37.0k]
  ------------------
 1046|  12.6k|      handle_unusual:
 1047|  12.6k|        if ((tag & 7) == 4 || tag == 0) {
  ------------------
  |  Branch (1047:13): [True: 115, False: 12.5k]
  |  Branch (1047:31): [True: 164, False: 12.3k]
  ------------------
 1048|    279|          ctx->SetLastTag(tag);
 1049|    279|          goto success;
 1050|    279|        }
 1051|  12.3k|      if ((1600u <= tag)) {
  ------------------
  |  Branch (1051:11): [True: 2.99k, False: 9.35k]
  ------------------
 1052|  2.99k|        ptr = _extensions_.ParseField(tag, ptr,
 1053|  2.99k|            internal_default_instance(), &_internal_metadata_, ctx);
 1054|  2.99k|        CHK_(ptr != nullptr);
  ------------------
  |  |  647|  2.99k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  2.99k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 189, False: 2.80k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1055|  2.80k|        continue;
 1056|  2.99k|      }
 1057|  9.35k|        ptr = UnknownFieldParse(tag,
 1058|  9.35k|            _internal_metadata_.mutable_unknown_fields<std::string>(),
 1059|  9.35k|            ptr, ctx);
 1060|  9.35k|        CHK_(ptr != nullptr);
  ------------------
  |  |  647|  9.35k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  9.35k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 375, False: 8.97k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1061|  8.97k|        continue;
 1062|  9.35k|      }
 1063|  41.1k|    }  // switch
 1064|  41.1k|  }  // while
 1065|  3.16k|success:
 1066|  3.16k|  return ptr;
 1067|    856|failure:
 1068|    856|  ptr = nullptr;
 1069|    856|  goto success;
 1070|  3.16k|#undef CHK_
 1071|  3.16k|}
_ZNK13sentencepiece11TrainerSpec18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 1074|    556|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 1075|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.TrainerSpec)
 1076|    556|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 1077|    556|  (void) cached_has_bits;
 1078|       |
 1079|       |  // repeated string input = 1;
 1080|  1.16k|  for (int i = 0, n = this->_internal_input_size(); i < n; i++) {
  ------------------
  |  Branch (1080:53): [True: 608, False: 556]
  ------------------
 1081|    608|    const auto& s = this->_internal_input(i);
 1082|    608|    target = stream->WriteString(1, s, target);
 1083|    608|  }
 1084|       |
 1085|    556|  cached_has_bits = _has_bits_[0];
 1086|       |  // optional string model_prefix = 2;
 1087|    556|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1087:7): [True: 4, False: 552]
  ------------------
 1088|      4|    target = stream->WriteStringMaybeAliased(
 1089|      4|        2, this->_internal_model_prefix(), target);
 1090|      4|  }
 1091|       |
 1092|       |  // optional .sentencepiece.TrainerSpec.ModelType model_type = 3 [default = UNIGRAM];
 1093|    556|  if (cached_has_bits & 0x01000000u) {
  ------------------
  |  Branch (1093:7): [True: 452, False: 104]
  ------------------
 1094|    452|    target = stream->EnsureSpace(target);
 1095|    452|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
 1096|    452|      3, this->_internal_model_type(), target);
 1097|    452|  }
 1098|       |
 1099|       |  // optional int32 vocab_size = 4 [default = 8000];
 1100|    556|  if (cached_has_bits & 0x02000000u) {
  ------------------
  |  Branch (1100:7): [True: 54, False: 502]
  ------------------
 1101|     54|    target = stream->EnsureSpace(target);
 1102|     54|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_vocab_size(), target);
 1103|     54|  }
 1104|       |
 1105|       |  // repeated string accept_language = 5;
 1106|    594|  for (int i = 0, n = this->_internal_accept_language_size(); i < n; i++) {
  ------------------
  |  Branch (1106:63): [True: 38, False: 556]
  ------------------
 1107|     38|    const auto& s = this->_internal_accept_language(i);
 1108|     38|    target = stream->WriteString(5, s, target);
 1109|     38|  }
 1110|       |
 1111|       |  // optional int32 self_test_sample_size = 6 [default = 0];
 1112|    556|  if (cached_has_bits & 0x00000400u) {
  ------------------
  |  Branch (1112:7): [True: 21, False: 535]
  ------------------
 1113|     21|    target = stream->EnsureSpace(target);
 1114|     21|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_self_test_sample_size(), target);
 1115|     21|  }
 1116|       |
 1117|       |  // optional string input_format = 7;
 1118|    556|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1118:7): [True: 18, False: 538]
  ------------------
 1119|     18|    target = stream->WriteStringMaybeAliased(
 1120|     18|        7, this->_internal_input_format(), target);
 1121|     18|  }
 1122|       |
 1123|       |  // optional float character_coverage = 10 [default = 0.9995];
 1124|    556|  if (cached_has_bits & 0x04000000u) {
  ------------------
  |  Branch (1124:7): [True: 2, False: 554]
  ------------------
 1125|      2|    target = stream->EnsureSpace(target);
 1126|      2|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_character_coverage(), target);
 1127|      2|  }
 1128|       |
 1129|       |  // optional uint64 input_sentence_size = 11 [default = 0];
 1130|    556|  if (cached_has_bits & 0x00001000u) {
  ------------------
  |  Branch (1130:7): [True: 2, False: 554]
  ------------------
 1131|      2|    target = stream->EnsureSpace(target);
 1132|      2|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(11, this->_internal_input_sentence_size(), target);
 1133|      2|  }
 1134|       |
 1135|       |  // optional int32 mining_sentence_size = 12 [deprecated = true];
 1136|    556|  if (cached_has_bits & 0x00000800u) {
  ------------------
  |  Branch (1136:7): [True: 19, False: 537]
  ------------------
 1137|     19|    target = stream->EnsureSpace(target);
 1138|     19|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(12, this->_internal_mining_sentence_size(), target);
 1139|     19|  }
 1140|       |
 1141|       |  // optional int32 training_sentence_size = 13 [deprecated = true];
 1142|    556|  if (cached_has_bits & 0x00002000u) {
  ------------------
  |  Branch (1142:7): [True: 1, False: 555]
  ------------------
 1143|      1|    target = stream->EnsureSpace(target);
 1144|      1|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(13, this->_internal_training_sentence_size(), target);
 1145|      1|  }
 1146|       |
 1147|       |  // optional int32 seed_sentencepiece_size = 14 [default = 1000000];
 1148|    556|  if (cached_has_bits & 0x08000000u) {
  ------------------
  |  Branch (1148:7): [True: 7, False: 549]
  ------------------
 1149|      7|    target = stream->EnsureSpace(target);
 1150|      7|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(14, this->_internal_seed_sentencepiece_size(), target);
 1151|      7|  }
 1152|       |
 1153|       |  // optional float shrinking_factor = 15 [default = 0.75];
 1154|    556|  if (cached_has_bits & 0x10000000u) {
  ------------------
  |  Branch (1154:7): [True: 2, False: 554]
  ------------------
 1155|      2|    target = stream->EnsureSpace(target);
 1156|      2|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(15, this->_internal_shrinking_factor(), target);
 1157|      2|  }
 1158|       |
 1159|       |  // optional int32 num_threads = 16 [default = 16];
 1160|    556|  if (cached_has_bits & 0x20000000u) {
  ------------------
  |  Branch (1160:7): [True: 7, False: 549]
  ------------------
 1161|      7|    target = stream->EnsureSpace(target);
 1162|      7|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(16, this->_internal_num_threads(), target);
 1163|      7|  }
 1164|       |
 1165|       |  // optional int32 num_sub_iterations = 17 [default = 2];
 1166|    556|  if (cached_has_bits & 0x40000000u) {
  ------------------
  |  Branch (1166:7): [True: 6, False: 550]
  ------------------
 1167|      6|    target = stream->EnsureSpace(target);
 1168|      6|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(17, this->_internal_num_sub_iterations(), target);
 1169|      6|  }
 1170|       |
 1171|       |  // optional int32 max_sentence_length = 18 [default = 4192];
 1172|    556|  if (cached_has_bits & 0x80000000u) {
  ------------------
  |  Branch (1172:7): [True: 5, False: 551]
  ------------------
 1173|      5|    target = stream->EnsureSpace(target);
 1174|      5|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(18, this->_internal_max_sentence_length(), target);
 1175|      5|  }
 1176|       |
 1177|    556|  cached_has_bits = _has_bits_[1];
 1178|       |  // optional bool shuffle_input_sentence = 19 [default = true];
 1179|    556|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1179:7): [True: 2, False: 554]
  ------------------
 1180|      2|    target = stream->EnsureSpace(target);
 1181|      2|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(19, this->_internal_shuffle_input_sentence(), target);
 1182|      2|  }
 1183|       |
 1184|       |  // optional int32 max_sentencepiece_length = 20 [default = 16];
 1185|    556|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1185:7): [True: 4, False: 552]
  ------------------
 1186|      4|    target = stream->EnsureSpace(target);
 1187|      4|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(20, this->_internal_max_sentencepiece_length(), target);
 1188|      4|  }
 1189|       |
 1190|       |  // optional bool split_by_unicode_script = 21 [default = true];
 1191|    556|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1191:7): [True: 3, False: 553]
  ------------------
 1192|      3|    target = stream->EnsureSpace(target);
 1193|      3|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(21, this->_internal_split_by_unicode_script(), target);
 1194|      3|  }
 1195|       |
 1196|       |  // optional bool split_by_whitespace = 22 [default = true];
 1197|    556|  if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1197:7): [True: 9, False: 547]
  ------------------
 1198|      9|    target = stream->EnsureSpace(target);
 1199|      9|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(22, this->_internal_split_by_whitespace(), target);
 1200|      9|  }
 1201|       |
 1202|       |  // optional bool split_by_number = 23 [default = true];
 1203|    556|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1203:7): [True: 1, False: 555]
  ------------------
 1204|      1|    target = stream->EnsureSpace(target);
 1205|      1|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(23, this->_internal_split_by_number(), target);
 1206|      1|  }
 1207|       |
 1208|    556|  cached_has_bits = _has_bits_[0];
 1209|       |  // optional bool treat_whitespace_as_suffix = 24 [default = false];
 1210|    556|  if (cached_has_bits & 0x00008000u) {
  ------------------
  |  Branch (1210:7): [True: 1, False: 555]
  ------------------
 1211|      1|    target = stream->EnsureSpace(target);
 1212|      1|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(24, this->_internal_treat_whitespace_as_suffix(), target);
 1213|      1|  }
 1214|       |
 1215|       |  // optional bool split_digits = 25 [default = false];
 1216|    556|  if (cached_has_bits & 0x00020000u) {
  ------------------
  |  Branch (1216:7): [True: 1, False: 555]
  ------------------
 1217|      1|    target = stream->EnsureSpace(target);
 1218|      1|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(25, this->_internal_split_digits(), target);
 1219|      1|  }
 1220|       |
 1221|       |  // optional bool allow_whitespace_only_pieces = 26 [default = false];
 1222|    556|  if (cached_has_bits & 0x00010000u) {
  ------------------
  |  Branch (1222:7): [True: 1, False: 555]
  ------------------
 1223|      1|    target = stream->EnsureSpace(target);
 1224|      1|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(26, this->_internal_allow_whitespace_only_pieces(), target);
 1225|      1|  }
 1226|       |
 1227|       |  // repeated string control_symbols = 30;
 1228|    557|  for (int i = 0, n = this->_internal_control_symbols_size(); i < n; i++) {
  ------------------
  |  Branch (1228:63): [True: 1, False: 556]
  ------------------
 1229|      1|    const auto& s = this->_internal_control_symbols(i);
 1230|      1|    target = stream->WriteString(30, s, target);
 1231|      1|  }
 1232|       |
 1233|       |  // repeated string user_defined_symbols = 31;
 1234|    564|  for (int i = 0, n = this->_internal_user_defined_symbols_size(); i < n; i++) {
  ------------------
  |  Branch (1234:68): [True: 8, False: 556]
  ------------------
 1235|      8|    const auto& s = this->_internal_user_defined_symbols(i);
 1236|      8|    target = stream->WriteString(31, s, target);
 1237|      8|  }
 1238|       |
 1239|    556|  cached_has_bits = _has_bits_[1];
 1240|       |  // optional bool vocabulary_output_piece_score = 32 [default = true];
 1241|    556|  if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1241:7): [True: 1, False: 555]
  ------------------
 1242|      1|    target = stream->EnsureSpace(target);
 1243|      1|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(32, this->_internal_vocabulary_output_piece_score(), target);
 1244|      1|  }
 1245|       |
 1246|       |  // optional bool hard_vocab_limit = 33 [default = true];
 1247|    556|  if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1247:7): [True: 1, False: 555]
  ------------------
 1248|      1|    target = stream->EnsureSpace(target);
 1249|      1|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(33, this->_internal_hard_vocab_limit(), target);
 1250|      1|  }
 1251|       |
 1252|    556|  cached_has_bits = _has_bits_[0];
 1253|       |  // optional bool use_all_vocab = 34 [default = false];
 1254|    556|  if (cached_has_bits & 0x00080000u) {
  ------------------
  |  Branch (1254:7): [True: 1, False: 555]
  ------------------
 1255|      1|    target = stream->EnsureSpace(target);
 1256|      1|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(34, this->_internal_use_all_vocab(), target);
 1257|      1|  }
 1258|       |
 1259|       |  // optional bool byte_fallback = 35 [default = false];
 1260|    556|  if (cached_has_bits & 0x00040000u) {
  ------------------
  |  Branch (1260:7): [True: 28, False: 528]
  ------------------
 1261|     28|    target = stream->EnsureSpace(target);
 1262|     28|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(35, this->_internal_byte_fallback(), target);
 1263|     28|  }
 1264|       |
 1265|       |  // optional string required_chars = 36;
 1266|    556|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1266:7): [True: 1, False: 555]
  ------------------
 1267|      1|    target = stream->WriteStringMaybeAliased(
 1268|      1|        36, this->_internal_required_chars(), target);
 1269|      1|  }
 1270|       |
 1271|       |  // optional int32 unk_id = 40 [default = 0];
 1272|    556|  if (cached_has_bits & 0x00200000u) {
  ------------------
  |  Branch (1272:7): [True: 4, False: 552]
  ------------------
 1273|      4|    target = stream->EnsureSpace(target);
 1274|      4|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(40, this->_internal_unk_id(), target);
 1275|      4|  }
 1276|       |
 1277|    556|  cached_has_bits = _has_bits_[1];
 1278|       |  // optional int32 bos_id = 41 [default = 1];
 1279|    556|  if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1279:7): [True: 2, False: 554]
  ------------------
 1280|      2|    target = stream->EnsureSpace(target);
 1281|      2|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(41, this->_internal_bos_id(), target);
 1282|      2|  }
 1283|       |
 1284|       |  // optional int32 eos_id = 42 [default = 2];
 1285|    556|  if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1285:7): [True: 5, False: 551]
  ------------------
 1286|      5|    target = stream->EnsureSpace(target);
 1287|      5|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(42, this->_internal_eos_id(), target);
 1288|      5|  }
 1289|       |
 1290|       |  // optional int32 pad_id = 43 [default = -1];
 1291|    556|  if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1291:7): [True: 5, False: 551]
  ------------------
 1292|      5|    target = stream->EnsureSpace(target);
 1293|      5|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(43, this->_internal_pad_id(), target);
 1294|      5|  }
 1295|       |
 1296|    556|  cached_has_bits = _has_bits_[0];
 1297|       |  // optional string unk_surface = 44 [default = " \342\201\207 "];
 1298|    556|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1298:7): [True: 23, False: 533]
  ------------------
 1299|     23|    target = stream->WriteStringMaybeAliased(
 1300|     23|        44, this->_internal_unk_surface(), target);
 1301|     23|  }
 1302|       |
 1303|       |  // optional string unk_piece = 45 [default = "<unk>"];
 1304|    556|  if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1304:7): [True: 2, False: 554]
  ------------------
 1305|      2|    target = stream->WriteStringMaybeAliased(
 1306|      2|        45, this->_internal_unk_piece(), target);
 1307|      2|  }
 1308|       |
 1309|       |  // optional string bos_piece = 46 [default = "<s>"];
 1310|    556|  if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1310:7): [True: 10, False: 546]
  ------------------
 1311|     10|    target = stream->WriteStringMaybeAliased(
 1312|     10|        46, this->_internal_bos_piece(), target);
 1313|     10|  }
 1314|       |
 1315|       |  // optional string eos_piece = 47 [default = "</s>"];
 1316|    556|  if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1316:7): [True: 2, False: 554]
  ------------------
 1317|      2|    target = stream->WriteStringMaybeAliased(
 1318|      2|        47, this->_internal_eos_piece(), target);
 1319|      2|  }
 1320|       |
 1321|       |  // optional string pad_piece = 48 [default = "<pad>"];
 1322|    556|  if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1322:7): [True: 2, False: 554]
  ------------------
 1323|      2|    target = stream->WriteStringMaybeAliased(
 1324|      2|        48, this->_internal_pad_piece(), target);
 1325|      2|  }
 1326|       |
 1327|       |  // optional bool train_extremely_large_corpus = 49 [default = false];
 1328|    556|  if (cached_has_bits & 0x00100000u) {
  ------------------
  |  Branch (1328:7): [True: 1, False: 555]
  ------------------
 1329|      1|    target = stream->EnsureSpace(target);
 1330|      1|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(49, this->_internal_train_extremely_large_corpus(), target);
 1331|      1|  }
 1332|       |
 1333|       |  // optional bool enable_differential_privacy = 50 [default = false];
 1334|    556|  if (cached_has_bits & 0x00004000u) {
  ------------------
  |  Branch (1334:7): [True: 1, False: 555]
  ------------------
 1335|      1|    target = stream->EnsureSpace(target);
 1336|      1|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(50, this->_internal_enable_differential_privacy(), target);
 1337|      1|  }
 1338|       |
 1339|       |  // optional float differential_privacy_noise_level = 51 [default = 0];
 1340|    556|  if (cached_has_bits & 0x00400000u) {
  ------------------
  |  Branch (1340:7): [True: 2, False: 554]
  ------------------
 1341|      2|    target = stream->EnsureSpace(target);
 1342|      2|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(51, this->_internal_differential_privacy_noise_level(), target);
 1343|      2|  }
 1344|       |
 1345|       |  // optional uint64 differential_privacy_clipping_threshold = 52 [default = 0];
 1346|    556|  if (cached_has_bits & 0x00800000u) {
  ------------------
  |  Branch (1346:7): [True: 0, False: 556]
  ------------------
 1347|      0|    target = stream->EnsureSpace(target);
 1348|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(52, this->_internal_differential_privacy_clipping_threshold(), target);
 1349|      0|  }
 1350|       |
 1351|       |  // optional string pretokenization_delimiter = 53 [default = ""];
 1352|    556|  if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1352:7): [True: 0, False: 556]
  ------------------
 1353|      0|    target = stream->WriteStringMaybeAliased(
 1354|      0|        53, this->_internal_pretokenization_delimiter(), target);
 1355|      0|  }
 1356|       |
 1357|       |  // optional string seed_sentencepieces_file = 54 [default = ""];
 1358|    556|  if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1358:7): [True: 1, False: 555]
  ------------------
 1359|      1|    target = stream->WriteStringMaybeAliased(
 1360|      1|        54, this->_internal_seed_sentencepieces_file(), target);
 1361|      1|  }
 1362|       |
 1363|       |  // Extension range [200, 536870912)
 1364|    556|  target = _extensions_._InternalSerialize(
 1365|    556|      200, 536870912, target, stream);
 1366|       |
 1367|    556|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|    556|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 470, False: 86]
  |  |  ------------------
  ------------------
 1368|    470|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
 1369|    470|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
 1370|    470|  }
 1371|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.TrainerSpec)
 1372|    556|  return target;
 1373|    556|}
_ZNK13sentencepiece11TrainerSpec12ByteSizeLongEv:
 1375|    556|size_t TrainerSpec::ByteSizeLong() const {
 1376|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.TrainerSpec)
 1377|    556|  size_t total_size = 0;
 1378|       |
 1379|    556|  total_size += _extensions_.ByteSize();
 1380|       |
 1381|    556|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 1382|       |  // Prevent compiler warnings about cached_has_bits being unused
 1383|    556|  (void) cached_has_bits;
 1384|       |
 1385|       |  // repeated string input = 1;
 1386|    556|  total_size += 1 *
 1387|    556|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(input_.size());
 1388|  1.16k|  for (int i = 0, n = input_.size(); i < n; i++) {
  ------------------
  |  Branch (1388:38): [True: 608, False: 556]
  ------------------
 1389|    608|    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1390|    608|      input_.Get(i));
 1391|    608|  }
 1392|       |
 1393|       |  // repeated string accept_language = 5;
 1394|    556|  total_size += 1 *
 1395|    556|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(accept_language_.size());
 1396|    594|  for (int i = 0, n = accept_language_.size(); i < n; i++) {
  ------------------
  |  Branch (1396:48): [True: 38, False: 556]
  ------------------
 1397|     38|    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1398|     38|      accept_language_.Get(i));
 1399|     38|  }
 1400|       |
 1401|       |  // repeated string control_symbols = 30;
 1402|    556|  total_size += 2 *
 1403|    556|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(control_symbols_.size());
 1404|    557|  for (int i = 0, n = control_symbols_.size(); i < n; i++) {
  ------------------
  |  Branch (1404:48): [True: 1, False: 556]
  ------------------
 1405|      1|    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1406|      1|      control_symbols_.Get(i));
 1407|      1|  }
 1408|       |
 1409|       |  // repeated string user_defined_symbols = 31;
 1410|    556|  total_size += 2 *
 1411|    556|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(user_defined_symbols_.size());
 1412|    564|  for (int i = 0, n = user_defined_symbols_.size(); i < n; i++) {
  ------------------
  |  Branch (1412:53): [True: 8, False: 556]
  ------------------
 1413|      8|    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1414|      8|      user_defined_symbols_.Get(i));
 1415|      8|  }
 1416|       |
 1417|    556|  cached_has_bits = _has_bits_[0];
 1418|    556|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (1418:7): [True: 62, False: 494]
  ------------------
 1419|       |    // optional string model_prefix = 2;
 1420|     62|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1420:9): [True: 4, False: 58]
  ------------------
 1421|      4|      total_size += 1 +
 1422|      4|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1423|      4|          this->_internal_model_prefix());
 1424|      4|    }
 1425|       |
 1426|       |    // optional string input_format = 7;
 1427|     62|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1427:9): [True: 18, False: 44]
  ------------------
 1428|     18|      total_size += 1 +
 1429|     18|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1430|     18|          this->_internal_input_format());
 1431|     18|    }
 1432|       |
 1433|       |    // optional string required_chars = 36;
 1434|     62|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1434:9): [True: 1, False: 61]
  ------------------
 1435|      1|      total_size += 2 +
 1436|      1|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1437|      1|          this->_internal_required_chars());
 1438|      1|    }
 1439|       |
 1440|       |    // optional string unk_surface = 44 [default = " \342\201\207 "];
 1441|     62|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1441:9): [True: 23, False: 39]
  ------------------
 1442|     23|      total_size += 2 +
 1443|     23|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1444|     23|          this->_internal_unk_surface());
 1445|     23|    }
 1446|       |
 1447|       |    // optional string unk_piece = 45 [default = "<unk>"];
 1448|     62|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1448:9): [True: 2, False: 60]
  ------------------
 1449|      2|      total_size += 2 +
 1450|      2|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1451|      2|          this->_internal_unk_piece());
 1452|      2|    }
 1453|       |
 1454|       |    // optional string bos_piece = 46 [default = "<s>"];
 1455|     62|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1455:9): [True: 10, False: 52]
  ------------------
 1456|     10|      total_size += 2 +
 1457|     10|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1458|     10|          this->_internal_bos_piece());
 1459|     10|    }
 1460|       |
 1461|       |    // optional string eos_piece = 47 [default = "</s>"];
 1462|     62|    if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1462:9): [True: 2, False: 60]
  ------------------
 1463|      2|      total_size += 2 +
 1464|      2|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1465|      2|          this->_internal_eos_piece());
 1466|      2|    }
 1467|       |
 1468|       |    // optional string pad_piece = 48 [default = "<pad>"];
 1469|     62|    if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1469:9): [True: 2, False: 60]
  ------------------
 1470|      2|      total_size += 2 +
 1471|      2|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1472|      2|          this->_internal_pad_piece());
 1473|      2|    }
 1474|       |
 1475|     62|  }
 1476|    556|  if (cached_has_bits & 0x0000ff00u) {
  ------------------
  |  Branch (1476:7): [True: 46, False: 510]
  ------------------
 1477|       |    // optional string pretokenization_delimiter = 53 [default = ""];
 1478|     46|    if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1478:9): [True: 0, False: 46]
  ------------------
 1479|      0|      total_size += 2 +
 1480|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1481|      0|          this->_internal_pretokenization_delimiter());
 1482|      0|    }
 1483|       |
 1484|       |    // optional string seed_sentencepieces_file = 54 [default = ""];
 1485|     46|    if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1485:9): [True: 1, False: 45]
  ------------------
 1486|      1|      total_size += 2 +
 1487|      1|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1488|      1|          this->_internal_seed_sentencepieces_file());
 1489|      1|    }
 1490|       |
 1491|       |    // optional int32 self_test_sample_size = 6 [default = 0];
 1492|     46|    if (cached_has_bits & 0x00000400u) {
  ------------------
  |  Branch (1492:9): [True: 21, False: 25]
  ------------------
 1493|     21|      total_size += 1 +
 1494|     21|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1495|     21|          this->_internal_self_test_sample_size());
 1496|     21|    }
 1497|       |
 1498|       |    // optional int32 mining_sentence_size = 12 [deprecated = true];
 1499|     46|    if (cached_has_bits & 0x00000800u) {
  ------------------
  |  Branch (1499:9): [True: 19, False: 27]
  ------------------
 1500|     19|      total_size += 1 +
 1501|     19|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1502|     19|          this->_internal_mining_sentence_size());
 1503|     19|    }
 1504|       |
 1505|       |    // optional uint64 input_sentence_size = 11 [default = 0];
 1506|     46|    if (cached_has_bits & 0x00001000u) {
  ------------------
  |  Branch (1506:9): [True: 2, False: 44]
  ------------------
 1507|      2|      total_size += 1 +
 1508|      2|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
 1509|      2|          this->_internal_input_sentence_size());
 1510|      2|    }
 1511|       |
 1512|       |    // optional int32 training_sentence_size = 13 [deprecated = true];
 1513|     46|    if (cached_has_bits & 0x00002000u) {
  ------------------
  |  Branch (1513:9): [True: 1, False: 45]
  ------------------
 1514|      1|      total_size += 1 +
 1515|      1|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1516|      1|          this->_internal_training_sentence_size());
 1517|      1|    }
 1518|       |
 1519|       |    // optional bool enable_differential_privacy = 50 [default = false];
 1520|     46|    if (cached_has_bits & 0x00004000u) {
  ------------------
  |  Branch (1520:9): [True: 1, False: 45]
  ------------------
 1521|      1|      total_size += 2 + 1;
 1522|      1|    }
 1523|       |
 1524|       |    // optional bool treat_whitespace_as_suffix = 24 [default = false];
 1525|     46|    if (cached_has_bits & 0x00008000u) {
  ------------------
  |  Branch (1525:9): [True: 1, False: 45]
  ------------------
 1526|      1|      total_size += 2 + 1;
 1527|      1|    }
 1528|       |
 1529|     46|  }
 1530|    556|  if (cached_has_bits & 0x00ff0000u) {
  ------------------
  |  Branch (1530:7): [True: 38, False: 518]
  ------------------
 1531|       |    // optional bool allow_whitespace_only_pieces = 26 [default = false];
 1532|     38|    if (cached_has_bits & 0x00010000u) {
  ------------------
  |  Branch (1532:9): [True: 1, False: 37]
  ------------------
 1533|      1|      total_size += 2 + 1;
 1534|      1|    }
 1535|       |
 1536|       |    // optional bool split_digits = 25 [default = false];
 1537|     38|    if (cached_has_bits & 0x00020000u) {
  ------------------
  |  Branch (1537:9): [True: 1, False: 37]
  ------------------
 1538|      1|      total_size += 2 + 1;
 1539|      1|    }
 1540|       |
 1541|       |    // optional bool byte_fallback = 35 [default = false];
 1542|     38|    if (cached_has_bits & 0x00040000u) {
  ------------------
  |  Branch (1542:9): [True: 28, False: 10]
  ------------------
 1543|     28|      total_size += 2 + 1;
 1544|     28|    }
 1545|       |
 1546|       |    // optional bool use_all_vocab = 34 [default = false];
 1547|     38|    if (cached_has_bits & 0x00080000u) {
  ------------------
  |  Branch (1547:9): [True: 1, False: 37]
  ------------------
 1548|      1|      total_size += 2 + 1;
 1549|      1|    }
 1550|       |
 1551|       |    // optional bool train_extremely_large_corpus = 49 [default = false];
 1552|     38|    if (cached_has_bits & 0x00100000u) {
  ------------------
  |  Branch (1552:9): [True: 1, False: 37]
  ------------------
 1553|      1|      total_size += 2 + 1;
 1554|      1|    }
 1555|       |
 1556|       |    // optional int32 unk_id = 40 [default = 0];
 1557|     38|    if (cached_has_bits & 0x00200000u) {
  ------------------
  |  Branch (1557:9): [True: 4, False: 34]
  ------------------
 1558|      4|      total_size += 2 +
 1559|      4|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1560|      4|          this->_internal_unk_id());
 1561|      4|    }
 1562|       |
 1563|       |    // optional float differential_privacy_noise_level = 51 [default = 0];
 1564|     38|    if (cached_has_bits & 0x00400000u) {
  ------------------
  |  Branch (1564:9): [True: 2, False: 36]
  ------------------
 1565|      2|      total_size += 2 + 4;
 1566|      2|    }
 1567|       |
 1568|       |    // optional uint64 differential_privacy_clipping_threshold = 52 [default = 0];
 1569|     38|    if (cached_has_bits & 0x00800000u) {
  ------------------
  |  Branch (1569:9): [True: 0, False: 38]
  ------------------
 1570|      0|      total_size += 2 +
 1571|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
 1572|      0|          this->_internal_differential_privacy_clipping_threshold());
 1573|      0|    }
 1574|       |
 1575|     38|  }
 1576|    556|  if (cached_has_bits & 0xff000000u) {
  ------------------
  |  Branch (1576:7): [True: 498, False: 58]
  ------------------
 1577|       |    // optional .sentencepiece.TrainerSpec.ModelType model_type = 3 [default = UNIGRAM];
 1578|    498|    if (cached_has_bits & 0x01000000u) {
  ------------------
  |  Branch (1578:9): [True: 452, False: 46]
  ------------------
 1579|    452|      total_size += 1 +
 1580|    452|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_model_type());
 1581|    452|    }
 1582|       |
 1583|       |    // optional int32 vocab_size = 4 [default = 8000];
 1584|    498|    if (cached_has_bits & 0x02000000u) {
  ------------------
  |  Branch (1584:9): [True: 54, False: 444]
  ------------------
 1585|     54|      total_size += 1 +
 1586|     54|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1587|     54|          this->_internal_vocab_size());
 1588|     54|    }
 1589|       |
 1590|       |    // optional float character_coverage = 10 [default = 0.9995];
 1591|    498|    if (cached_has_bits & 0x04000000u) {
  ------------------
  |  Branch (1591:9): [True: 2, False: 496]
  ------------------
 1592|      2|      total_size += 1 + 4;
 1593|      2|    }
 1594|       |
 1595|       |    // optional int32 seed_sentencepiece_size = 14 [default = 1000000];
 1596|    498|    if (cached_has_bits & 0x08000000u) {
  ------------------
  |  Branch (1596:9): [True: 7, False: 491]
  ------------------
 1597|      7|      total_size += 1 +
 1598|      7|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1599|      7|          this->_internal_seed_sentencepiece_size());
 1600|      7|    }
 1601|       |
 1602|       |    // optional float shrinking_factor = 15 [default = 0.75];
 1603|    498|    if (cached_has_bits & 0x10000000u) {
  ------------------
  |  Branch (1603:9): [True: 2, False: 496]
  ------------------
 1604|      2|      total_size += 1 + 4;
 1605|      2|    }
 1606|       |
 1607|       |    // optional int32 num_threads = 16 [default = 16];
 1608|    498|    if (cached_has_bits & 0x20000000u) {
  ------------------
  |  Branch (1608:9): [True: 7, False: 491]
  ------------------
 1609|      7|      total_size += 2 +
 1610|      7|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1611|      7|          this->_internal_num_threads());
 1612|      7|    }
 1613|       |
 1614|       |    // optional int32 num_sub_iterations = 17 [default = 2];
 1615|    498|    if (cached_has_bits & 0x40000000u) {
  ------------------
  |  Branch (1615:9): [True: 6, False: 492]
  ------------------
 1616|      6|      total_size += 2 +
 1617|      6|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1618|      6|          this->_internal_num_sub_iterations());
 1619|      6|    }
 1620|       |
 1621|       |    // optional int32 max_sentence_length = 18 [default = 4192];
 1622|    498|    if (cached_has_bits & 0x80000000u) {
  ------------------
  |  Branch (1622:9): [True: 5, False: 493]
  ------------------
 1623|      5|      total_size += 2 +
 1624|      5|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1625|      5|          this->_internal_max_sentence_length());
 1626|      5|    }
 1627|       |
 1628|    498|  }
 1629|    556|  cached_has_bits = _has_bits_[1];
 1630|    556|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (1630:7): [True: 23, False: 533]
  ------------------
 1631|       |    // optional int32 max_sentencepiece_length = 20 [default = 16];
 1632|     23|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1632:9): [True: 4, False: 19]
  ------------------
 1633|      4|      total_size += 2 +
 1634|      4|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1635|      4|          this->_internal_max_sentencepiece_length());
 1636|      4|    }
 1637|       |
 1638|       |    // optional bool shuffle_input_sentence = 19 [default = true];
 1639|     23|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1639:9): [True: 2, False: 21]
  ------------------
 1640|      2|      total_size += 2 + 1;
 1641|      2|    }
 1642|       |
 1643|       |    // optional bool split_by_unicode_script = 21 [default = true];
 1644|     23|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1644:9): [True: 3, False: 20]
  ------------------
 1645|      3|      total_size += 2 + 1;
 1646|      3|    }
 1647|       |
 1648|       |    // optional bool split_by_number = 23 [default = true];
 1649|     23|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1649:9): [True: 1, False: 22]
  ------------------
 1650|      1|      total_size += 2 + 1;
 1651|      1|    }
 1652|       |
 1653|       |    // optional bool split_by_whitespace = 22 [default = true];
 1654|     23|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1654:9): [True: 9, False: 14]
  ------------------
 1655|      9|      total_size += 2 + 1;
 1656|      9|    }
 1657|       |
 1658|       |    // optional bool vocabulary_output_piece_score = 32 [default = true];
 1659|     23|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1659:9): [True: 1, False: 22]
  ------------------
 1660|      1|      total_size += 2 + 1;
 1661|      1|    }
 1662|       |
 1663|       |    // optional bool hard_vocab_limit = 33 [default = true];
 1664|     23|    if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1664:9): [True: 1, False: 22]
  ------------------
 1665|      1|      total_size += 2 + 1;
 1666|      1|    }
 1667|       |
 1668|       |    // optional int32 bos_id = 41 [default = 1];
 1669|     23|    if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1669:9): [True: 2, False: 21]
  ------------------
 1670|      2|      total_size += 2 +
 1671|      2|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1672|      2|          this->_internal_bos_id());
 1673|      2|    }
 1674|       |
 1675|     23|  }
 1676|    556|  if (cached_has_bits & 0x00000300u) {
  ------------------
  |  Branch (1676:7): [True: 10, False: 546]
  ------------------
 1677|       |    // optional int32 eos_id = 42 [default = 2];
 1678|     10|    if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1678:9): [True: 5, False: 5]
  ------------------
 1679|      5|      total_size += 2 +
 1680|      5|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1681|      5|          this->_internal_eos_id());
 1682|      5|    }
 1683|       |
 1684|       |    // optional int32 pad_id = 43 [default = -1];
 1685|     10|    if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1685:9): [True: 5, False: 5]
  ------------------
 1686|      5|      total_size += 2 +
 1687|      5|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1688|      5|          this->_internal_pad_id());
 1689|      5|    }
 1690|       |
 1691|     10|  }
 1692|    556|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|    556|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 470, False: 86]
  |  |  ------------------
  ------------------
 1693|    470|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 1694|    470|  }
 1695|    556|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 1696|    556|  SetCachedSize(cached_size);
 1697|    556|  return total_size;
 1698|    556|}
_ZNK13sentencepiece11TrainerSpec13IsInitializedEv:
 1872|    896|bool TrainerSpec::IsInitialized() const {
 1873|    896|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (1873:7): [True: 0, False: 896]
  ------------------
 1874|      0|    return false;
 1875|      0|  }
 1876|       |
 1877|    896|  return true;
 1878|    896|}
_ZN13sentencepiece14NormalizerSpecC2EPN6google8protobuf5ArenaE:
 1957|  1.27k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 1958|  1.27k|  _extensions_(arena) {
 1959|  1.27k|  SharedCtor();
 1960|  1.27k|  RegisterArenaDtor(arena);
 1961|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.NormalizerSpec)
 1962|  1.27k|}
_ZN13sentencepiece14NormalizerSpecD2Ev:
 1999|  1.27k|NormalizerSpec::~NormalizerSpec() {
 2000|       |  // @@protoc_insertion_point(destructor:sentencepiece.NormalizerSpec)
 2001|  1.27k|  SharedDtor();
 2002|  1.27k|  _internal_metadata_.Delete<std::string>();
 2003|  1.27k|}
_ZNK13sentencepiece14NormalizerSpec13SetCachedSizeEi:
 2018|    222|void NormalizerSpec::SetCachedSize(int size) const {
 2019|    222|  _cached_size_.Set(size);
 2020|    222|}
_ZN13sentencepiece14NormalizerSpec14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE:
 2053|  1.95k|const char* NormalizerSpec::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 2054|  1.95k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 2055|  1.95k|  _Internal::HasBits has_bits{};
 2056|  37.9k|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (2056:10): [True: 36.4k, False: 1.48k]
  ------------------
 2057|  36.4k|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 2058|  36.4k|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 2059|  36.4k|    CHK_(ptr);
  ------------------
  |  | 2054|  36.4k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  36.4k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 18, False: 36.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2060|  36.4k|    switch (tag >> 3) {
 2061|       |      // optional string name = 1;
 2062|  1.17k|      case 1:
  ------------------
  |  Branch (2062:7): [True: 1.17k, False: 35.2k]
  ------------------
 2063|  1.17k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
  ------------------
  |  |  236|  1.17k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 841, False: 333]
  |  |  ------------------
  ------------------
 2064|    841|          auto str = _internal_mutable_name();
 2065|    841|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2066|    841|          CHK_(ptr);
  ------------------
  |  | 2054|    841|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    841|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 24, False: 817]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2067|    841|        } else goto handle_unusual;
 2068|    817|        continue;
 2069|       |      // optional bytes precompiled_charsmap = 2;
 2070|  1.19k|      case 2:
  ------------------
  |  Branch (2070:7): [True: 1.19k, False: 35.2k]
  ------------------
 2071|  1.19k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
  ------------------
  |  |  236|  1.19k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 217, False: 974]
  |  |  ------------------
  ------------------
 2072|    217|          auto str = _internal_mutable_precompiled_charsmap();
 2073|    217|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2074|    217|          CHK_(ptr);
  ------------------
  |  | 2054|    217|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    217|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 30, False: 187]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2075|    974|        } else goto handle_unusual;
 2076|    187|        continue;
 2077|       |      // optional bool add_dummy_prefix = 3 [default = true];
 2078|  1.14k|      case 3:
  ------------------
  |  Branch (2078:7): [True: 1.14k, False: 35.3k]
  ------------------
 2079|  1.14k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
  ------------------
  |  |  236|  1.14k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 980, False: 167]
  |  |  ------------------
  ------------------
 2080|    980|          _Internal::set_has_add_dummy_prefix(&has_bits);
 2081|    980|          add_dummy_prefix_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2082|    980|          CHK_(ptr);
  ------------------
  |  | 2054|    980|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    980|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 2, False: 978]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2083|    980|        } else goto handle_unusual;
 2084|    978|        continue;
 2085|       |      // optional bool remove_extra_whitespaces = 4 [default = true];
 2086|  24.2k|      case 4:
  ------------------
  |  Branch (2086:7): [True: 24.2k, False: 12.2k]
  ------------------
 2087|  24.2k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
  ------------------
  |  |  236|  24.2k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 24.0k, False: 182]
  |  |  ------------------
  ------------------
 2088|  24.0k|          _Internal::set_has_remove_extra_whitespaces(&has_bits);
 2089|  24.0k|          remove_extra_whitespaces_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2090|  24.0k|          CHK_(ptr);
  ------------------
  |  | 2054|  24.0k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  24.0k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 24.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2091|  24.0k|        } else goto handle_unusual;
 2092|  24.0k|        continue;
 2093|       |      // optional bool escape_whitespaces = 5 [default = true];
 2094|  24.0k|      case 5:
  ------------------
  |  Branch (2094:7): [True: 1.67k, False: 34.7k]
  ------------------
 2095|  1.67k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
  ------------------
  |  |  236|  1.67k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1.22k, False: 459]
  |  |  ------------------
  ------------------
 2096|  1.22k|          _Internal::set_has_escape_whitespaces(&has_bits);
 2097|  1.22k|          escape_whitespaces_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2098|  1.22k|          CHK_(ptr);
  ------------------
  |  | 2054|  1.22k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  1.22k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 5, False: 1.21k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2099|  1.22k|        } else goto handle_unusual;
 2100|  1.21k|        continue;
 2101|       |      // optional string normalization_rule_tsv = 6;
 2102|  1.21k|      case 6:
  ------------------
  |  Branch (2102:7): [True: 511, False: 35.9k]
  ------------------
 2103|    511|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
  ------------------
  |  |  236|    511|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 228, False: 283]
  |  |  ------------------
  ------------------
 2104|    228|          auto str = _internal_mutable_normalization_rule_tsv();
 2105|    228|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2106|    228|          CHK_(ptr);
  ------------------
  |  | 2054|    228|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    228|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 25, False: 203]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2107|    283|        } else goto handle_unusual;
 2108|    203|        continue;
 2109|  6.56k|      default: {
  ------------------
  |  Branch (2109:7): [True: 6.56k, False: 29.9k]
  ------------------
 2110|  8.96k|      handle_unusual:
 2111|  8.96k|        if ((tag & 7) == 4 || tag == 0) {
  ------------------
  |  Branch (2111:13): [True: 89, False: 8.87k]
  |  Branch (2111:31): [True: 55, False: 8.82k]
  ------------------
 2112|    144|          ctx->SetLastTag(tag);
 2113|    144|          goto success;
 2114|    144|        }
 2115|  8.82k|      if ((1600u <= tag)) {
  ------------------
  |  Branch (2115:11): [True: 2.38k, False: 6.43k]
  ------------------
 2116|  2.38k|        ptr = _extensions_.ParseField(tag, ptr,
 2117|  2.38k|            internal_default_instance(), &_internal_metadata_, ctx);
 2118|  2.38k|        CHK_(ptr != nullptr);
  ------------------
  |  | 2054|  2.38k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  2.38k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 119, False: 2.26k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2119|  2.26k|        continue;
 2120|  2.38k|      }
 2121|  6.43k|        ptr = UnknownFieldParse(tag,
 2122|  6.43k|            _internal_metadata_.mutable_unknown_fields<std::string>(),
 2123|  6.43k|            ptr, ctx);
 2124|  6.43k|        CHK_(ptr != nullptr);
  ------------------
  |  | 2054|  6.43k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  6.43k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 104, False: 6.33k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2125|  6.33k|        continue;
 2126|  6.43k|      }
 2127|  36.4k|    }  // switch
 2128|  36.4k|  }  // while
 2129|  1.95k|success:
 2130|  1.95k|  _has_bits_.Or(has_bits);
 2131|  1.95k|  return ptr;
 2132|    328|failure:
 2133|    328|  ptr = nullptr;
 2134|    328|  goto success;
 2135|  1.95k|#undef CHK_
 2136|  1.95k|}
_ZNK13sentencepiece14NormalizerSpec18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 2139|    222|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 2140|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.NormalizerSpec)
 2141|    222|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2142|    222|  (void) cached_has_bits;
 2143|       |
 2144|    222|  cached_has_bits = _has_bits_[0];
 2145|       |  // optional string name = 1;
 2146|    222|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2146:7): [True: 157, False: 65]
  ------------------
 2147|    157|    target = stream->WriteStringMaybeAliased(
 2148|    157|        1, this->_internal_name(), target);
 2149|    157|  }
 2150|       |
 2151|       |  // optional bytes precompiled_charsmap = 2;
 2152|    222|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2152:7): [True: 9, False: 213]
  ------------------
 2153|      9|    target = stream->WriteBytesMaybeAliased(
 2154|      9|        2, this->_internal_precompiled_charsmap(), target);
 2155|      9|  }
 2156|       |
 2157|       |  // optional bool add_dummy_prefix = 3 [default = true];
 2158|    222|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (2158:7): [True: 129, False: 93]
  ------------------
 2159|    129|    target = stream->EnsureSpace(target);
 2160|    129|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_add_dummy_prefix(), target);
 2161|    129|  }
 2162|       |
 2163|       |  // optional bool remove_extra_whitespaces = 4 [default = true];
 2164|    222|  if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (2164:7): [True: 34, False: 188]
  ------------------
 2165|     34|    target = stream->EnsureSpace(target);
 2166|     34|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_remove_extra_whitespaces(), target);
 2167|     34|  }
 2168|       |
 2169|       |  // optional bool escape_whitespaces = 5 [default = true];
 2170|    222|  if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (2170:7): [True: 52, False: 170]
  ------------------
 2171|     52|    target = stream->EnsureSpace(target);
 2172|     52|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_escape_whitespaces(), target);
 2173|     52|  }
 2174|       |
 2175|       |  // optional string normalization_rule_tsv = 6;
 2176|    222|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2176:7): [True: 16, False: 206]
  ------------------
 2177|     16|    target = stream->WriteStringMaybeAliased(
 2178|     16|        6, this->_internal_normalization_rule_tsv(), target);
 2179|     16|  }
 2180|       |
 2181|       |  // Extension range [200, 536870912)
 2182|    222|  target = _extensions_._InternalSerialize(
 2183|    222|      200, 536870912, target, stream);
 2184|       |
 2185|    222|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|    222|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 165, False: 57]
  |  |  ------------------
  ------------------
 2186|    165|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
 2187|    165|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
 2188|    165|  }
 2189|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.NormalizerSpec)
 2190|    222|  return target;
 2191|    222|}
_ZNK13sentencepiece14NormalizerSpec12ByteSizeLongEv:
 2193|    222|size_t NormalizerSpec::ByteSizeLong() const {
 2194|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.NormalizerSpec)
 2195|    222|  size_t total_size = 0;
 2196|       |
 2197|    222|  total_size += _extensions_.ByteSize();
 2198|       |
 2199|    222|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2200|       |  // Prevent compiler warnings about cached_has_bits being unused
 2201|    222|  (void) cached_has_bits;
 2202|       |
 2203|    222|  cached_has_bits = _has_bits_[0];
 2204|    222|  if (cached_has_bits & 0x0000003fu) {
  ------------------
  |  Branch (2204:7): [True: 206, False: 16]
  ------------------
 2205|       |    // optional string name = 1;
 2206|    206|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2206:9): [True: 157, False: 49]
  ------------------
 2207|    157|      total_size += 1 +
 2208|    157|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 2209|    157|          this->_internal_name());
 2210|    157|    }
 2211|       |
 2212|       |    // optional bytes precompiled_charsmap = 2;
 2213|    206|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2213:9): [True: 9, False: 197]
  ------------------
 2214|      9|      total_size += 1 +
 2215|      9|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
 2216|      9|          this->_internal_precompiled_charsmap());
 2217|      9|    }
 2218|       |
 2219|       |    // optional string normalization_rule_tsv = 6;
 2220|    206|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2220:9): [True: 16, False: 190]
  ------------------
 2221|     16|      total_size += 1 +
 2222|     16|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 2223|     16|          this->_internal_normalization_rule_tsv());
 2224|     16|    }
 2225|       |
 2226|       |    // optional bool add_dummy_prefix = 3 [default = true];
 2227|    206|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (2227:9): [True: 129, False: 77]
  ------------------
 2228|    129|      total_size += 1 + 1;
 2229|    129|    }
 2230|       |
 2231|       |    // optional bool remove_extra_whitespaces = 4 [default = true];
 2232|    206|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (2232:9): [True: 34, False: 172]
  ------------------
 2233|     34|      total_size += 1 + 1;
 2234|     34|    }
 2235|       |
 2236|       |    // optional bool escape_whitespaces = 5 [default = true];
 2237|    206|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (2237:9): [True: 52, False: 154]
  ------------------
 2238|     52|      total_size += 1 + 1;
 2239|     52|    }
 2240|       |
 2241|    206|  }
 2242|    222|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|    222|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 165, False: 57]
  |  |  ------------------
  ------------------
 2243|    165|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 2244|    165|  }
 2245|    222|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 2246|    222|  SetCachedSize(cached_size);
 2247|    222|  return total_size;
 2248|    222|}
_ZNK13sentencepiece14NormalizerSpec13IsInitializedEv:
 2295|    393|bool NormalizerSpec::IsInitialized() const {
 2296|    393|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (2296:7): [True: 0, False: 393]
  ------------------
 2297|      0|    return false;
 2298|      0|  }
 2299|       |
 2300|    393|  return true;
 2301|    393|}
_ZN13sentencepiece19SelfTestData_SampleC2EPN6google8protobuf5ArenaE:
 2335|  1.58k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
 2336|  1.58k|  SharedCtor();
 2337|  1.58k|  RegisterArenaDtor(arena);
 2338|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.SelfTestData.Sample)
 2339|  1.58k|}
_ZN13sentencepiece19SelfTestData_SampleD2Ev:
 2363|  1.58k|SelfTestData_Sample::~SelfTestData_Sample() {
 2364|       |  // @@protoc_insertion_point(destructor:sentencepiece.SelfTestData.Sample)
 2365|  1.58k|  SharedDtor();
 2366|  1.58k|  _internal_metadata_.Delete<std::string>();
 2367|  1.58k|}
_ZNK13sentencepiece19SelfTestData_Sample13SetCachedSizeEi:
 2381|     91|void SelfTestData_Sample::SetCachedSize(int size) const {
 2382|     91|  _cached_size_.Set(size);
 2383|     91|}
_ZN13sentencepiece19SelfTestData_Sample14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE:
 2409|  1.58k|const char* SelfTestData_Sample::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 2410|  1.58k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 2411|  1.58k|  _Internal::HasBits has_bits{};
 2412|  5.91k|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (2412:10): [True: 4.47k, False: 1.44k]
  ------------------
 2413|  4.47k|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 2414|  4.47k|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 2415|  4.47k|    CHK_(ptr);
  ------------------
  |  | 2410|  4.47k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  4.47k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 5, False: 4.46k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2416|  4.46k|    switch (tag >> 3) {
 2417|       |      // optional string input = 1;
 2418|  1.52k|      case 1:
  ------------------
  |  Branch (2418:7): [True: 1.52k, False: 2.94k]
  ------------------
 2419|  1.52k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
  ------------------
  |  |  236|  1.52k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1.27k, False: 253]
  |  |  ------------------
  ------------------
 2420|  1.27k|          auto str = _internal_mutable_input();
 2421|  1.27k|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2422|  1.27k|          CHK_(ptr);
  ------------------
  |  | 2410|  1.27k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  1.27k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 15, False: 1.25k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2423|  1.27k|        } else goto handle_unusual;
 2424|  1.25k|        continue;
 2425|       |      // optional string expected = 2;
 2426|  1.54k|      case 2:
  ------------------
  |  Branch (2426:7): [True: 1.54k, False: 2.91k]
  ------------------
 2427|  1.54k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
  ------------------
  |  |  236|  1.54k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 185, False: 1.36k]
  |  |  ------------------
  ------------------
 2428|    185|          auto str = _internal_mutable_expected();
 2429|    185|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2430|    185|          CHK_(ptr);
  ------------------
  |  | 2410|    185|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    185|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 11, False: 174]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2431|  1.36k|        } else goto handle_unusual;
 2432|    174|        continue;
 2433|  1.39k|      default: {
  ------------------
  |  Branch (2433:7): [True: 1.39k, False: 3.07k]
  ------------------
 2434|  3.00k|      handle_unusual:
 2435|  3.00k|        if ((tag & 7) == 4 || tag == 0) {
  ------------------
  |  Branch (2435:13): [True: 25, False: 2.98k]
  |  Branch (2435:31): [True: 10, False: 2.97k]
  ------------------
 2436|     35|          ctx->SetLastTag(tag);
 2437|     35|          goto success;
 2438|     35|        }
 2439|  2.97k|        ptr = UnknownFieldParse(tag,
 2440|  2.97k|            _internal_metadata_.mutable_unknown_fields<std::string>(),
 2441|  2.97k|            ptr, ctx);
 2442|  2.97k|        CHK_(ptr != nullptr);
  ------------------
  |  | 2410|  2.97k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  2.97k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 68, False: 2.90k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2443|  2.90k|        continue;
 2444|  2.97k|      }
 2445|  4.46k|    }  // switch
 2446|  4.46k|  }  // while
 2447|  1.58k|success:
 2448|  1.58k|  _has_bits_.Or(has_bits);
 2449|  1.58k|  return ptr;
 2450|     99|failure:
 2451|     99|  ptr = nullptr;
 2452|     99|  goto success;
 2453|  1.58k|#undef CHK_
 2454|  1.58k|}
_ZNK13sentencepiece19SelfTestData_Sample18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 2457|     91|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 2458|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.SelfTestData.Sample)
 2459|     91|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2460|     91|  (void) cached_has_bits;
 2461|       |
 2462|     91|  cached_has_bits = _has_bits_[0];
 2463|       |  // optional string input = 1;
 2464|     91|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2464:7): [True: 69, False: 22]
  ------------------
 2465|     69|    target = stream->WriteStringMaybeAliased(
 2466|     69|        1, this->_internal_input(), target);
 2467|     69|  }
 2468|       |
 2469|       |  // optional string expected = 2;
 2470|     91|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2470:7): [True: 3, False: 88]
  ------------------
 2471|      3|    target = stream->WriteStringMaybeAliased(
 2472|      3|        2, this->_internal_expected(), target);
 2473|      3|  }
 2474|       |
 2475|     91|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|     91|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 90, False: 1]
  |  |  ------------------
  ------------------
 2476|     90|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
 2477|     90|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
 2478|     90|  }
 2479|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.SelfTestData.Sample)
 2480|     91|  return target;
 2481|     91|}
_ZNK13sentencepiece19SelfTestData_Sample12ByteSizeLongEv:
 2483|     91|size_t SelfTestData_Sample::ByteSizeLong() const {
 2484|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.SelfTestData.Sample)
 2485|     91|  size_t total_size = 0;
 2486|       |
 2487|     91|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2488|       |  // Prevent compiler warnings about cached_has_bits being unused
 2489|     91|  (void) cached_has_bits;
 2490|       |
 2491|     91|  cached_has_bits = _has_bits_[0];
 2492|     91|  if (cached_has_bits & 0x00000003u) {
  ------------------
  |  Branch (2492:7): [True: 69, False: 22]
  ------------------
 2493|       |    // optional string input = 1;
 2494|     69|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2494:9): [True: 69, False: 0]
  ------------------
 2495|     69|      total_size += 1 +
 2496|     69|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 2497|     69|          this->_internal_input());
 2498|     69|    }
 2499|       |
 2500|       |    // optional string expected = 2;
 2501|     69|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2501:9): [True: 3, False: 66]
  ------------------
 2502|      3|      total_size += 1 +
 2503|      3|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 2504|      3|          this->_internal_expected());
 2505|      3|    }
 2506|       |
 2507|     69|  }
 2508|     91|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|     91|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 90, False: 1]
  |  |  ------------------
  ------------------
 2509|     90|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 2510|     90|  }
 2511|     91|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 2512|     91|  SetCachedSize(cached_size);
 2513|     91|  return total_size;
 2514|     91|}
_ZN13sentencepiece12SelfTestDataC2EPN6google8protobuf5ArenaE:
 2571|    626|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 2572|    626|  _extensions_(arena),
 2573|    626|  samples_(arena) {
 2574|    626|  SharedCtor();
 2575|    626|  RegisterArenaDtor(arena);
 2576|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.SelfTestData)
 2577|    626|}
_ZN13sentencepiece12SelfTestDataD2Ev:
 2590|    625|SelfTestData::~SelfTestData() {
 2591|       |  // @@protoc_insertion_point(destructor:sentencepiece.SelfTestData)
 2592|    625|  SharedDtor();
 2593|    625|  _internal_metadata_.Delete<std::string>();
 2594|    625|}
_ZNK13sentencepiece12SelfTestData13SetCachedSizeEi:
 2606|     32|void SelfTestData::SetCachedSize(int size) const {
 2607|     32|  _cached_size_.Set(size);
 2608|     32|}
_ZN13sentencepiece12SelfTestData14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE:
 2626|    742|const char* SelfTestData::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 2627|    742|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 2628|  2.67k|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (2628:10): [True: 2.32k, False: 346]
  ------------------
 2629|  2.32k|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 2630|  2.32k|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 2631|  2.32k|    CHK_(ptr);
  ------------------
  |  | 2627|  2.32k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  2.32k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 4, False: 2.32k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2632|  2.32k|    switch (tag >> 3) {
 2633|       |      // repeated .sentencepiece.SelfTestData.Sample samples = 1;
 2634|    621|      case 1:
  ------------------
  |  Branch (2634:7): [True: 621, False: 1.70k]
  ------------------
 2635|    621|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
  ------------------
  |  |  236|    621|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 495, False: 126]
  |  |  ------------------
  ------------------
 2636|    495|          ptr -= 1;
 2637|  1.58k|          do {
 2638|  1.58k|            ptr += 1;
 2639|  1.58k|            ptr = ctx->ParseMessage(_internal_add_samples(), ptr);
 2640|  1.58k|            CHK_(ptr);
  ------------------
  |  | 2627|  1.58k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  1.58k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 214, False: 1.37k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2641|  1.37k|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (2641:17): [True: 115, False: 1.25k]
  ------------------
 2642|  1.37k|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
  ------------------
  |  Branch (2642:20): [True: 1.09k, False: 166]
  ------------------
 2643|    495|        } else goto handle_unusual;
 2644|    281|        continue;
 2645|  1.70k|      default: {
  ------------------
  |  Branch (2645:7): [True: 1.70k, False: 621]
  ------------------
 2646|  1.82k|      handle_unusual:
 2647|  1.82k|        if ((tag & 7) == 4 || tag == 0) {
  ------------------
  |  Branch (2647:13): [True: 45, False: 1.78k]
  |  Branch (2647:31): [True: 21, False: 1.76k]
  ------------------
 2648|     66|          ctx->SetLastTag(tag);
 2649|     66|          goto success;
 2650|     66|        }
 2651|  1.76k|      if ((1600u <= tag)) {
  ------------------
  |  Branch (2651:11): [True: 411, False: 1.35k]
  ------------------
 2652|    411|        ptr = _extensions_.ParseField(tag, ptr,
 2653|    411|            internal_default_instance(), &_internal_metadata_, ctx);
 2654|    411|        CHK_(ptr != nullptr);
  ------------------
  |  | 2627|    411|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    411|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 61, False: 350]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2655|    350|        continue;
 2656|    411|      }
 2657|  1.35k|        ptr = UnknownFieldParse(tag,
 2658|  1.35k|            _internal_metadata_.mutable_unknown_fields<std::string>(),
 2659|  1.35k|            ptr, ctx);
 2660|  1.35k|        CHK_(ptr != nullptr);
  ------------------
  |  | 2627|  1.35k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  1.35k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 51, False: 1.30k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2661|  1.30k|        continue;
 2662|  1.35k|      }
 2663|  2.32k|    }  // switch
 2664|  2.32k|  }  // while
 2665|    742|success:
 2666|    742|  return ptr;
 2667|    330|failure:
 2668|    330|  ptr = nullptr;
 2669|    330|  goto success;
 2670|    742|#undef CHK_
 2671|    742|}
_ZNK13sentencepiece12SelfTestData18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 2674|     32|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 2675|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.SelfTestData)
 2676|     32|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2677|     32|  (void) cached_has_bits;
 2678|       |
 2679|       |  // repeated .sentencepiece.SelfTestData.Sample samples = 1;
 2680|     32|  for (unsigned int i = 0,
 2681|    123|      n = static_cast<unsigned int>(this->_internal_samples_size()); i < n; i++) {
  ------------------
  |  Branch (2681:70): [True: 91, False: 32]
  ------------------
 2682|     91|    target = stream->EnsureSpace(target);
 2683|     91|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 2684|     91|      InternalWriteMessage(1, this->_internal_samples(i), target, stream);
 2685|     91|  }
 2686|       |
 2687|       |  // Extension range [200, 536870912)
 2688|     32|  target = _extensions_._InternalSerialize(
 2689|     32|      200, 536870912, target, stream);
 2690|       |
 2691|     32|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|     32|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 29, False: 3]
  |  |  ------------------
  ------------------
 2692|     29|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
 2693|     29|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
 2694|     29|  }
 2695|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.SelfTestData)
 2696|     32|  return target;
 2697|     32|}
_ZNK13sentencepiece12SelfTestData12ByteSizeLongEv:
 2699|     32|size_t SelfTestData::ByteSizeLong() const {
 2700|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.SelfTestData)
 2701|     32|  size_t total_size = 0;
 2702|       |
 2703|     32|  total_size += _extensions_.ByteSize();
 2704|       |
 2705|     32|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2706|       |  // Prevent compiler warnings about cached_has_bits being unused
 2707|     32|  (void) cached_has_bits;
 2708|       |
 2709|       |  // repeated .sentencepiece.SelfTestData.Sample samples = 1;
 2710|     32|  total_size += 1UL * this->_internal_samples_size();
 2711|     91|  for (const auto& msg : this->samples_) {
  ------------------
  |  Branch (2711:24): [True: 91, False: 32]
  ------------------
 2712|     91|    total_size +=
 2713|     91|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
 2714|     91|  }
 2715|       |
 2716|     32|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|     32|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 29, False: 3]
  |  |  ------------------
  ------------------
 2717|     29|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 2718|     29|  }
 2719|     32|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 2720|     32|  SetCachedSize(cached_size);
 2721|     32|  return total_size;
 2722|     32|}
_ZNK13sentencepiece12SelfTestData13IsInitializedEv:
 2748|     96|bool SelfTestData::IsInitialized() const {
 2749|     96|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (2749:7): [True: 0, False: 96]
  ------------------
 2750|      0|    return false;
 2751|      0|  }
 2752|       |
 2753|     96|  return true;
 2754|     96|}
_ZN13sentencepiece24ModelProto_SentencePieceC2EPN6google8protobuf5ArenaE:
 2785|  1.48M|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 2786|  1.48M|  _extensions_(arena) {
 2787|  1.48M|  SharedCtor();
 2788|  1.48M|  RegisterArenaDtor(arena);
 2789|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.ModelProto.SentencePiece)
 2790|  1.48M|}
_ZN13sentencepiece24ModelProto_SentencePieceD2Ev:
 2814|  1.48M|ModelProto_SentencePiece::~ModelProto_SentencePiece() {
 2815|       |  // @@protoc_insertion_point(destructor:sentencepiece.ModelProto.SentencePiece)
 2816|  1.48M|  SharedDtor();
 2817|  1.48M|  _internal_metadata_.Delete<std::string>();
 2818|  1.48M|}
_ZNK13sentencepiece24ModelProto_SentencePiece13SetCachedSizeEi:
 2831|  27.3k|void ModelProto_SentencePiece::SetCachedSize(int size) const {
 2832|  27.3k|  _cached_size_.Set(size);
 2833|  27.3k|}
_ZN13sentencepiece24ModelProto_SentencePiece14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE:
 2859|  1.48M|const char* ModelProto_SentencePiece::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 2860|  1.48M|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 2861|  1.48M|  _Internal::HasBits has_bits{};
 2862|  1.67M|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (2862:10): [True: 180k, False: 1.48M]
  ------------------
 2863|   180k|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 2864|   180k|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 2865|   180k|    CHK_(ptr);
  ------------------
  |  | 2860|   180k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|   180k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 5, False: 180k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2866|   180k|    switch (tag >> 3) {
 2867|       |      // optional string piece = 1;
 2868|  92.9k|      case 1:
  ------------------
  |  Branch (2868:7): [True: 92.9k, False: 88.0k]
  ------------------
 2869|  92.9k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
  ------------------
  |  |  236|  92.9k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 92.4k, False: 459]
  |  |  ------------------
  ------------------
 2870|  92.4k|          auto str = _internal_mutable_piece();
 2871|  92.4k|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2872|  92.4k|          CHK_(ptr);
  ------------------
  |  | 2860|  92.4k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  92.4k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 66, False: 92.3k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2873|  92.4k|        } else goto handle_unusual;
 2874|  92.3k|        continue;
 2875|       |      // optional float score = 2;
 2876|  92.3k|      case 2:
  ------------------
  |  Branch (2876:7): [True: 55.3k, False: 125k]
  ------------------
 2877|  55.3k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
  ------------------
  |  |  236|  55.3k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 54.6k, False: 715]
  |  |  ------------------
  ------------------
 2878|  54.6k|          _Internal::set_has_score(&has_bits);
 2879|  54.6k|          score_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
 2880|  54.6k|          ptr += sizeof(float);
 2881|  54.6k|        } else goto handle_unusual;
 2882|  54.6k|        continue;
 2883|       |      // optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
 2884|  54.6k|      case 3:
  ------------------
  |  Branch (2884:7): [True: 29.2k, False: 151k]
  ------------------
 2885|  29.2k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
  ------------------
  |  |  236|  29.2k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 29.0k, False: 245]
  |  |  ------------------
  ------------------
 2886|  29.0k|          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2887|  29.0k|          CHK_(ptr);
  ------------------
  |  | 2860|  29.0k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  29.0k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1, False: 29.0k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2888|  29.0k|          if (PROTOBUF_PREDICT_TRUE(::sentencepiece::ModelProto_SentencePiece_Type_IsValid(val))) {
  ------------------
  |  |  236|  29.0k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 26.8k, False: 2.19k]
  |  |  ------------------
  ------------------
 2889|  26.8k|            _internal_set_type(static_cast<::sentencepiece::ModelProto_SentencePiece_Type>(val));
 2890|  26.8k|          } else {
 2891|  2.19k|            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
 2892|  2.19k|          }
 2893|  29.0k|        } else goto handle_unusual;
 2894|  29.0k|        continue;
 2895|  29.0k|      default: {
  ------------------
  |  Branch (2895:7): [True: 3.45k, False: 177k]
  ------------------
 2896|  4.87k|      handle_unusual:
 2897|  4.87k|        if ((tag & 7) == 4 || tag == 0) {
  ------------------
  |  Branch (2897:13): [True: 23, False: 4.85k]
  |  Branch (2897:31): [True: 41, False: 4.81k]
  ------------------
 2898|     64|          ctx->SetLastTag(tag);
 2899|     64|          goto success;
 2900|     64|        }
 2901|  4.81k|      if ((1600u <= tag)) {
  ------------------
  |  Branch (2901:11): [True: 602, False: 4.21k]
  ------------------
 2902|    602|        ptr = _extensions_.ParseField(tag, ptr,
 2903|    602|            internal_default_instance(), &_internal_metadata_, ctx);
 2904|    602|        CHK_(ptr != nullptr);
  ------------------
  |  | 2860|    602|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    602|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 64, False: 538]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2905|    538|        continue;
 2906|    602|      }
 2907|  4.21k|        ptr = UnknownFieldParse(tag,
 2908|  4.21k|            _internal_metadata_.mutable_unknown_fields<std::string>(),
 2909|  4.21k|            ptr, ctx);
 2910|  4.21k|        CHK_(ptr != nullptr);
  ------------------
  |  | 2860|  4.21k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  4.21k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 85, False: 4.12k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2911|  4.12k|        continue;
 2912|  4.21k|      }
 2913|   180k|    }  // switch
 2914|   180k|  }  // while
 2915|  1.48M|success:
 2916|  1.48M|  _has_bits_.Or(has_bits);
 2917|  1.48M|  return ptr;
 2918|    221|failure:
 2919|    221|  ptr = nullptr;
 2920|    221|  goto success;
 2921|  1.48M|#undef CHK_
 2922|  1.48M|}
_ZNK13sentencepiece24ModelProto_SentencePiece18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 2925|  27.3k|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 2926|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.ModelProto.SentencePiece)
 2927|  27.3k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2928|  27.3k|  (void) cached_has_bits;
 2929|       |
 2930|  27.3k|  cached_has_bits = _has_bits_[0];
 2931|       |  // optional string piece = 1;
 2932|  27.3k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2932:7): [True: 27.3k, False: 0]
  ------------------
 2933|  27.3k|    target = stream->WriteStringMaybeAliased(
 2934|  27.3k|        1, this->_internal_piece(), target);
 2935|  27.3k|  }
 2936|       |
 2937|       |  // optional float score = 2;
 2938|  27.3k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2938:7): [True: 27.1k, False: 235]
  ------------------
 2939|  27.1k|    target = stream->EnsureSpace(target);
 2940|  27.1k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_score(), target);
 2941|  27.1k|  }
 2942|       |
 2943|       |  // optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
 2944|  27.3k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2944:7): [True: 11.6k, False: 15.7k]
  ------------------
 2945|  11.6k|    target = stream->EnsureSpace(target);
 2946|  11.6k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
 2947|  11.6k|      3, this->_internal_type(), target);
 2948|  11.6k|  }
 2949|       |
 2950|       |  // Extension range [200, 536870912)
 2951|  27.3k|  target = _extensions_._InternalSerialize(
 2952|  27.3k|      200, 536870912, target, stream);
 2953|       |
 2954|  27.3k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  27.3k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 612, False: 26.7k]
  |  |  ------------------
  ------------------
 2955|    612|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
 2956|    612|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
 2957|    612|  }
 2958|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.ModelProto.SentencePiece)
 2959|  27.3k|  return target;
 2960|  27.3k|}
_ZNK13sentencepiece24ModelProto_SentencePiece12ByteSizeLongEv:
 2962|  27.3k|size_t ModelProto_SentencePiece::ByteSizeLong() const {
 2963|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.ModelProto.SentencePiece)
 2964|  27.3k|  size_t total_size = 0;
 2965|       |
 2966|  27.3k|  total_size += _extensions_.ByteSize();
 2967|       |
 2968|  27.3k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2969|       |  // Prevent compiler warnings about cached_has_bits being unused
 2970|  27.3k|  (void) cached_has_bits;
 2971|       |
 2972|  27.3k|  cached_has_bits = _has_bits_[0];
 2973|  27.3k|  if (cached_has_bits & 0x00000007u) {
  ------------------
  |  Branch (2973:7): [True: 27.3k, False: 0]
  ------------------
 2974|       |    // optional string piece = 1;
 2975|  27.3k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2975:9): [True: 27.3k, False: 0]
  ------------------
 2976|  27.3k|      total_size += 1 +
 2977|  27.3k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 2978|  27.3k|          this->_internal_piece());
 2979|  27.3k|    }
 2980|       |
 2981|       |    // optional float score = 2;
 2982|  27.3k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2982:9): [True: 27.1k, False: 235]
  ------------------
 2983|  27.1k|      total_size += 1 + 4;
 2984|  27.1k|    }
 2985|       |
 2986|       |    // optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
 2987|  27.3k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2987:9): [True: 11.6k, False: 15.7k]
  ------------------
 2988|  11.6k|      total_size += 1 +
 2989|  11.6k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
 2990|  11.6k|    }
 2991|       |
 2992|  27.3k|  }
 2993|  27.3k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  27.3k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 612, False: 26.7k]
  |  |  ------------------
  ------------------
 2994|    612|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 2995|    612|  }
 2996|  27.3k|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 2997|  27.3k|  SetCachedSize(cached_size);
 2998|  27.3k|  return total_size;
 2999|  27.3k|}
_ZNK13sentencepiece24ModelProto_SentencePiece13IsInitializedEv:
 3037|  1.31M|bool ModelProto_SentencePiece::IsInitialized() const {
 3038|  1.31M|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (3038:7): [True: 0, False: 1.31M]
  ------------------
 3039|      0|    return false;
 3040|      0|  }
 3041|       |
 3042|  1.31M|  return true;
 3043|  1.31M|}
_ZN13sentencepiece10ModelProto9_Internal12trainer_specEPKS0_:
 3084|    556|ModelProto::_Internal::trainer_spec(const ModelProto* msg) {
 3085|    556|  return *msg->trainer_spec_;
 3086|    556|}
_ZN13sentencepiece10ModelProto9_Internal15normalizer_specEPKS0_:
 3088|    167|ModelProto::_Internal::normalizer_spec(const ModelProto* msg) {
 3089|    167|  return *msg->normalizer_spec_;
 3090|    167|}
_ZN13sentencepiece10ModelProto9_Internal14self_test_dataEPKS0_:
 3092|     32|ModelProto::_Internal::self_test_data(const ModelProto* msg) {
 3093|     32|  return *msg->self_test_data_;
 3094|     32|}
_ZN13sentencepiece10ModelProto9_Internal17denormalizer_specEPKS0_:
 3096|     55|ModelProto::_Internal::denormalizer_spec(const ModelProto* msg) {
 3097|     55|  return *msg->denormalizer_spec_;
 3098|     55|}
_ZN13sentencepiece10ModelProtoC2EPN6google8protobuf5ArenaE:
 3100|  7.70k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 3101|  7.70k|  _extensions_(arena),
 3102|  7.70k|  pieces_(arena) {
 3103|  7.70k|  SharedCtor();
 3104|  7.70k|  RegisterArenaDtor(arena);
 3105|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.ModelProto)
 3106|  7.70k|}
_ZN13sentencepiece10ModelProtoD2Ev:
 3144|  7.70k|ModelProto::~ModelProto() {
 3145|       |  // @@protoc_insertion_point(destructor:sentencepiece.ModelProto)
 3146|  7.70k|  SharedDtor();
 3147|  7.70k|  _internal_metadata_.Delete<std::string>();
 3148|  7.70k|}
_ZNK13sentencepiece10ModelProto13SetCachedSizeEi:
 3164|  2.03k|void ModelProto::SetCachedSize(int size) const {
 3165|  2.03k|  _cached_size_.Set(size);
 3166|  2.03k|}
_ZN13sentencepiece10ModelProto5ClearEv:
 3173|  7.70k|void ModelProto::Clear() {
 3174|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.ModelProto)
 3175|  7.70k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 3176|       |  // Prevent compiler warnings about cached_has_bits being unused
 3177|  7.70k|  (void) cached_has_bits;
 3178|       |
 3179|  7.70k|  _extensions_.Clear();
 3180|  7.70k|  pieces_.Clear();
 3181|  7.70k|  cached_has_bits = _has_bits_[0];
 3182|  7.70k|  if (cached_has_bits & 0x0000000fu) {
  ------------------
  |  Branch (3182:7): [True: 0, False: 7.70k]
  ------------------
 3183|      0|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (3183:9): [True: 0, False: 0]
  ------------------
 3184|      0|      GOOGLE_DCHECK(trainer_spec_ != nullptr);
  ------------------
  |  |  181|      0|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3185|      0|      trainer_spec_->Clear();
 3186|      0|    }
 3187|      0|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (3187:9): [True: 0, False: 0]
  ------------------
 3188|      0|      GOOGLE_DCHECK(normalizer_spec_ != nullptr);
  ------------------
  |  |  181|      0|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3189|      0|      normalizer_spec_->Clear();
 3190|      0|    }
 3191|      0|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (3191:9): [True: 0, False: 0]
  ------------------
 3192|      0|      GOOGLE_DCHECK(self_test_data_ != nullptr);
  ------------------
  |  |  181|      0|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3193|      0|      self_test_data_->Clear();
 3194|      0|    }
 3195|      0|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (3195:9): [True: 0, False: 0]
  ------------------
 3196|      0|      GOOGLE_DCHECK(denormalizer_spec_ != nullptr);
  ------------------
  |  |  181|      0|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3197|      0|      denormalizer_spec_->Clear();
 3198|      0|    }
 3199|      0|  }
 3200|  7.70k|  _has_bits_.Clear();
 3201|  7.70k|  _internal_metadata_.Clear<std::string>();
 3202|  7.70k|}
_ZN13sentencepiece10ModelProto14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE:
 3204|  7.70k|const char* ModelProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 3205|  7.70k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 3206|  7.70k|  _Internal::HasBits has_bits{};
 3207|   166k|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (3207:10): [True: 163k, False: 3.39k]
  ------------------
 3208|   163k|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 3209|   163k|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 3210|   163k|    CHK_(ptr);
  ------------------
  |  | 3205|   163k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|   163k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 9, False: 163k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3211|   163k|    switch (tag >> 3) {
 3212|       |      // repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
 3213|  18.6k|      case 1:
  ------------------
  |  Branch (3213:7): [True: 18.6k, False: 144k]
  ------------------
 3214|  18.6k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
  ------------------
  |  |  236|  18.6k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 17.0k, False: 1.52k]
  |  |  ------------------
  ------------------
 3215|  17.0k|          ptr -= 1;
 3216|  1.48M|          do {
 3217|  1.48M|            ptr += 1;
 3218|  1.48M|            ptr = ctx->ParseMessage(_internal_add_pieces(), ptr);
 3219|  1.48M|            CHK_(ptr);
  ------------------
  |  | 3205|  1.48M|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  1.48M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 514, False: 1.48M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3220|  1.48M|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (3220:17): [True: 3.57k, False: 1.48M]
  ------------------
 3221|  1.48M|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
  ------------------
  |  Branch (3221:20): [True: 1.47M, False: 13.0k]
  ------------------
 3222|  17.0k|        } else goto handle_unusual;
 3223|  16.5k|        continue;
 3224|       |      // optional .sentencepiece.TrainerSpec trainer_spec = 2;
 3225|  16.5k|      case 2:
  ------------------
  |  Branch (3225:7): [True: 5.89k, False: 157k]
  ------------------
 3226|  5.89k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
  ------------------
  |  |  236|  5.89k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 3.16k, False: 2.72k]
  |  |  ------------------
  ------------------
 3227|  3.16k|          ptr = ctx->ParseMessage(_internal_mutable_trainer_spec(), ptr);
 3228|  3.16k|          CHK_(ptr);
  ------------------
  |  | 3205|  3.16k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  3.16k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 1.95k, False: 1.21k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3229|  3.16k|        } else goto handle_unusual;
 3230|  1.21k|        continue;
 3231|       |      // optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
 3232|  2.08k|      case 3:
  ------------------
  |  Branch (3232:7): [True: 2.08k, False: 161k]
  ------------------
 3233|  2.08k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
  ------------------
  |  |  236|  2.08k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 672, False: 1.40k]
  |  |  ------------------
  ------------------
 3234|    672|          ptr = ctx->ParseMessage(_internal_mutable_normalizer_spec(), ptr);
 3235|    672|          CHK_(ptr);
  ------------------
  |  | 3205|    672|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    672|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 343, False: 329]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3236|  1.40k|        } else goto handle_unusual;
 3237|    329|        continue;
 3238|       |      // optional .sentencepiece.SelfTestData self_test_data = 4;
 3239|   109k|      case 4:
  ------------------
  |  Branch (3239:7): [True: 109k, False: 54.1k]
  ------------------
 3240|   109k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
  ------------------
  |  |  236|   109k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 744, False: 108k]
  |  |  ------------------
  ------------------
 3241|    744|          ptr = ctx->ParseMessage(_internal_mutable_self_test_data(), ptr);
 3242|    744|          CHK_(ptr);
  ------------------
  |  | 3205|    744|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    744|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 505, False: 239]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3243|   108k|        } else goto handle_unusual;
 3244|    239|        continue;
 3245|       |      // optional .sentencepiece.NormalizerSpec denormalizer_spec = 5;
 3246|  2.18k|      case 5:
  ------------------
  |  Branch (3246:7): [True: 2.18k, False: 161k]
  ------------------
 3247|  2.18k|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
  ------------------
  |  |  236|  2.18k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1.28k, False: 896]
  |  |  ------------------
  ------------------
 3248|  1.28k|          ptr = ctx->ParseMessage(_internal_mutable_denormalizer_spec(), ptr);
 3249|  1.28k|          CHK_(ptr);
  ------------------
  |  | 3205|  1.28k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  1.28k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 452, False: 836]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3250|  1.28k|        } else goto handle_unusual;
 3251|    836|        continue;
 3252|  25.4k|      default: {
  ------------------
  |  Branch (3252:7): [True: 25.4k, False: 137k]
  ------------------
 3253|   140k|      handle_unusual:
 3254|   140k|        if ((tag & 7) == 4 || tag == 0) {
  ------------------
  |  Branch (3254:13): [True: 66, False: 140k]
  |  Branch (3254:31): [True: 42, False: 140k]
  ------------------
 3255|    108|          ctx->SetLastTag(tag);
 3256|    108|          goto success;
 3257|    108|        }
 3258|   140k|      if ((1600u <= tag)) {
  ------------------
  |  Branch (3258:11): [True: 3.00k, False: 137k]
  ------------------
 3259|  3.00k|        ptr = _extensions_.ParseField(tag, ptr,
 3260|  3.00k|            internal_default_instance(), &_internal_metadata_, ctx);
 3261|  3.00k|        CHK_(ptr != nullptr);
  ------------------
  |  | 3205|  3.00k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|  3.00k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 166, False: 2.84k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3262|  2.84k|        continue;
 3263|  3.00k|      }
 3264|   137k|        ptr = UnknownFieldParse(tag,
 3265|   137k|            _internal_metadata_.mutable_unknown_fields<std::string>(),
 3266|   137k|            ptr, ctx);
 3267|   137k|        CHK_(ptr != nullptr);
  ------------------
  |  | 3205|   137k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|   137k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 250, False: 137k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3268|   137k|        continue;
 3269|   137k|      }
 3270|   163k|    }  // switch
 3271|   163k|  }  // while
 3272|  7.70k|success:
 3273|  7.70k|  _has_bits_.Or(has_bits);
 3274|  7.70k|  return ptr;
 3275|  4.19k|failure:
 3276|  4.19k|  ptr = nullptr;
 3277|  4.19k|  goto success;
 3278|  7.70k|#undef CHK_
 3279|  7.70k|}
_ZNK13sentencepiece10ModelProto18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 3282|  2.03k|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 3283|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.ModelProto)
 3284|  2.03k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 3285|  2.03k|  (void) cached_has_bits;
 3286|       |
 3287|       |  // repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
 3288|  2.03k|  for (unsigned int i = 0,
 3289|  29.4k|      n = static_cast<unsigned int>(this->_internal_pieces_size()); i < n; i++) {
  ------------------
  |  Branch (3289:69): [True: 27.3k, False: 2.03k]
  ------------------
 3290|  27.3k|    target = stream->EnsureSpace(target);
 3291|  27.3k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3292|  27.3k|      InternalWriteMessage(1, this->_internal_pieces(i), target, stream);
 3293|  27.3k|  }
 3294|       |
 3295|  2.03k|  cached_has_bits = _has_bits_[0];
 3296|       |  // optional .sentencepiece.TrainerSpec trainer_spec = 2;
 3297|  2.03k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (3297:7): [True: 556, False: 1.47k]
  ------------------
 3298|    556|    target = stream->EnsureSpace(target);
 3299|    556|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3300|    556|      InternalWriteMessage(
 3301|    556|        2, _Internal::trainer_spec(this), target, stream);
 3302|    556|  }
 3303|       |
 3304|       |  // optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
 3305|  2.03k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (3305:7): [True: 167, False: 1.86k]
  ------------------
 3306|    167|    target = stream->EnsureSpace(target);
 3307|    167|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3308|    167|      InternalWriteMessage(
 3309|    167|        3, _Internal::normalizer_spec(this), target, stream);
 3310|    167|  }
 3311|       |
 3312|       |  // optional .sentencepiece.SelfTestData self_test_data = 4;
 3313|  2.03k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (3313:7): [True: 32, False: 2.00k]
  ------------------
 3314|     32|    target = stream->EnsureSpace(target);
 3315|     32|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3316|     32|      InternalWriteMessage(
 3317|     32|        4, _Internal::self_test_data(this), target, stream);
 3318|     32|  }
 3319|       |
 3320|       |  // optional .sentencepiece.NormalizerSpec denormalizer_spec = 5;
 3321|  2.03k|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (3321:7): [True: 55, False: 1.97k]
  ------------------
 3322|     55|    target = stream->EnsureSpace(target);
 3323|     55|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3324|     55|      InternalWriteMessage(
 3325|     55|        5, _Internal::denormalizer_spec(this), target, stream);
 3326|     55|  }
 3327|       |
 3328|       |  // Extension range [200, 536870912)
 3329|  2.03k|  target = _extensions_._InternalSerialize(
 3330|  2.03k|      200, 536870912, target, stream);
 3331|       |
 3332|  2.03k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  2.03k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 672, False: 1.36k]
  |  |  ------------------
  ------------------
 3333|    672|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
 3334|    672|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
 3335|    672|  }
 3336|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.ModelProto)
 3337|  2.03k|  return target;
 3338|  2.03k|}
_ZNK13sentencepiece10ModelProto12ByteSizeLongEv:
 3340|  2.03k|size_t ModelProto::ByteSizeLong() const {
 3341|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.ModelProto)
 3342|  2.03k|  size_t total_size = 0;
 3343|       |
 3344|  2.03k|  total_size += _extensions_.ByteSize();
 3345|       |
 3346|  2.03k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 3347|       |  // Prevent compiler warnings about cached_has_bits being unused
 3348|  2.03k|  (void) cached_has_bits;
 3349|       |
 3350|       |  // repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
 3351|  2.03k|  total_size += 1UL * this->_internal_pieces_size();
 3352|  27.3k|  for (const auto& msg : this->pieces_) {
  ------------------
  |  Branch (3352:24): [True: 27.3k, False: 2.03k]
  ------------------
 3353|  27.3k|    total_size +=
 3354|  27.3k|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
 3355|  27.3k|  }
 3356|       |
 3357|  2.03k|  cached_has_bits = _has_bits_[0];
 3358|  2.03k|  if (cached_has_bits & 0x0000000fu) {
  ------------------
  |  Branch (3358:7): [True: 669, False: 1.36k]
  ------------------
 3359|       |    // optional .sentencepiece.TrainerSpec trainer_spec = 2;
 3360|    669|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (3360:9): [True: 556, False: 113]
  ------------------
 3361|    556|      total_size += 1 +
 3362|    556|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 3363|    556|          *trainer_spec_);
 3364|    556|    }
 3365|       |
 3366|       |    // optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
 3367|    669|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (3367:9): [True: 167, False: 502]
  ------------------
 3368|    167|      total_size += 1 +
 3369|    167|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 3370|    167|          *normalizer_spec_);
 3371|    167|    }
 3372|       |
 3373|       |    // optional .sentencepiece.SelfTestData self_test_data = 4;
 3374|    669|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (3374:9): [True: 32, False: 637]
  ------------------
 3375|     32|      total_size += 1 +
 3376|     32|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 3377|     32|          *self_test_data_);
 3378|     32|    }
 3379|       |
 3380|       |    // optional .sentencepiece.NormalizerSpec denormalizer_spec = 5;
 3381|    669|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (3381:9): [True: 55, False: 614]
  ------------------
 3382|     55|      total_size += 1 +
 3383|     55|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 3384|     55|          *denormalizer_spec_);
 3385|     55|    }
 3386|       |
 3387|    669|  }
 3388|  2.03k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  2.03k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 672, False: 1.36k]
  |  |  ------------------
  ------------------
 3389|    672|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 3390|    672|  }
 3391|  2.03k|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 3392|  2.03k|  SetCachedSize(cached_size);
 3393|  2.03k|  return total_size;
 3394|  2.03k|}
_ZNK13sentencepiece10ModelProto13IsInitializedEv:
 3435|  3.17k|bool ModelProto::IsInitialized() const {
 3436|  3.17k|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (3436:7): [True: 0, False: 3.17k]
  ------------------
 3437|      0|    return false;
 3438|      0|  }
 3439|       |
 3440|  3.17k|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(pieces_)) return false;
  ------------------
  |  Branch (3440:7): [True: 0, False: 3.17k]
  ------------------
 3441|  3.17k|  if (_internal_has_trainer_spec()) {
  ------------------
  |  Branch (3441:7): [True: 896, False: 2.28k]
  ------------------
 3442|    896|    if (!trainer_spec_->IsInitialized()) return false;
  ------------------
  |  Branch (3442:9): [True: 0, False: 896]
  ------------------
 3443|    896|  }
 3444|  3.17k|  if (_internal_has_normalizer_spec()) {
  ------------------
  |  Branch (3444:7): [True: 267, False: 2.91k]
  ------------------
 3445|    267|    if (!normalizer_spec_->IsInitialized()) return false;
  ------------------
  |  Branch (3445:9): [True: 0, False: 267]
  ------------------
 3446|    267|  }
 3447|  3.17k|  if (_internal_has_self_test_data()) {
  ------------------
  |  Branch (3447:7): [True: 96, False: 3.08k]
  ------------------
 3448|     96|    if (!self_test_data_->IsInitialized()) return false;
  ------------------
  |  Branch (3448:9): [True: 0, False: 96]
  ------------------
 3449|     96|  }
 3450|  3.17k|  if (_internal_has_denormalizer_spec()) {
  ------------------
  |  Branch (3450:7): [True: 126, False: 3.05k]
  ------------------
 3451|    126|    if (!denormalizer_spec_->IsInitialized()) return false;
  ------------------
  |  Branch (3451:9): [True: 0, False: 126]
  ------------------
 3452|    126|  }
 3453|  3.17k|  return true;
 3454|  3.17k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece11TrainerSpecEJEEEPT_PS1_DpOT0_:
 3478|  2.89k|template<> PROTOBUF_NOINLINE ::sentencepiece::TrainerSpec* Arena::CreateMaybeMessage< ::sentencepiece::TrainerSpec >(Arena* arena) {
 3479|  2.89k|  return Arena::CreateMessageInternal< ::sentencepiece::TrainerSpec >(arena);
 3480|  2.89k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece14NormalizerSpecEJEEEPT_PS1_DpOT0_:
 3481|  1.27k|template<> PROTOBUF_NOINLINE ::sentencepiece::NormalizerSpec* Arena::CreateMaybeMessage< ::sentencepiece::NormalizerSpec >(Arena* arena) {
 3482|  1.27k|  return Arena::CreateMessageInternal< ::sentencepiece::NormalizerSpec >(arena);
 3483|  1.27k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece19SelfTestData_SampleEJEEEPT_PS1_DpOT0_:
 3484|  1.58k|template<> PROTOBUF_NOINLINE ::sentencepiece::SelfTestData_Sample* Arena::CreateMaybeMessage< ::sentencepiece::SelfTestData_Sample >(Arena* arena) {
 3485|  1.58k|  return Arena::CreateMessageInternal< ::sentencepiece::SelfTestData_Sample >(arena);
 3486|  1.58k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece12SelfTestDataEJEEEPT_PS1_DpOT0_:
 3487|    625|template<> PROTOBUF_NOINLINE ::sentencepiece::SelfTestData* Arena::CreateMaybeMessage< ::sentencepiece::SelfTestData >(Arena* arena) {
 3488|    625|  return Arena::CreateMessageInternal< ::sentencepiece::SelfTestData >(arena);
 3489|    625|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece24ModelProto_SentencePieceEJEEEPT_PS1_DpOT0_:
 3490|  1.48M|template<> PROTOBUF_NOINLINE ::sentencepiece::ModelProto_SentencePiece* Arena::CreateMaybeMessage< ::sentencepiece::ModelProto_SentencePiece >(Arena* arena) {
 3491|  1.48M|  return Arena::CreateMessageInternal< ::sentencepiece::ModelProto_SentencePiece >(arena);
 3492|  1.48M|}
sentencepiece_model.pb.cc:_ZL61InitDefaultsscc_info_ModelProto_sentencepiece_5fmodel_2eprotov:
   45|      1|static void InitDefaultsscc_info_ModelProto_sentencepiece_5fmodel_2eproto() {
   46|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   47|       |
   48|      1|  {
   49|      1|    void* ptr = &::sentencepiece::_ModelProto_default_instance_;
   50|      1|    new (ptr) ::sentencepiece::ModelProto();
   51|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   52|      1|  }
   53|      1|}
sentencepiece_model.pb.cc:_ZL75InitDefaultsscc_info_ModelProto_SentencePiece_sentencepiece_5fmodel_2eprotov:
   62|      1|static void InitDefaultsscc_info_ModelProto_SentencePiece_sentencepiece_5fmodel_2eproto() {
   63|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   64|       |
   65|      1|  {
   66|      1|    void* ptr = &::sentencepiece::_ModelProto_SentencePiece_default_instance_;
   67|      1|    new (ptr) ::sentencepiece::ModelProto_SentencePiece();
   68|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   69|      1|  }
   70|      1|}
sentencepiece_model.pb.cc:_ZL65InitDefaultsscc_info_NormalizerSpec_sentencepiece_5fmodel_2eprotov:
   75|      1|static void InitDefaultsscc_info_NormalizerSpec_sentencepiece_5fmodel_2eproto() {
   76|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   77|       |
   78|      1|  {
   79|      1|    void* ptr = &::sentencepiece::_NormalizerSpec_default_instance_;
   80|      1|    new (ptr) ::sentencepiece::NormalizerSpec();
   81|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   82|      1|  }
   83|      1|}
sentencepiece_model.pb.cc:_ZL63InitDefaultsscc_info_SelfTestData_sentencepiece_5fmodel_2eprotov:
   88|      1|static void InitDefaultsscc_info_SelfTestData_sentencepiece_5fmodel_2eproto() {
   89|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   90|       |
   91|      1|  {
   92|      1|    void* ptr = &::sentencepiece::_SelfTestData_default_instance_;
   93|      1|    new (ptr) ::sentencepiece::SelfTestData();
   94|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   95|      1|  }
   96|      1|}
sentencepiece_model.pb.cc:_ZL70InitDefaultsscc_info_SelfTestData_Sample_sentencepiece_5fmodel_2eprotov:
  102|      1|static void InitDefaultsscc_info_SelfTestData_Sample_sentencepiece_5fmodel_2eproto() {
  103|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
  104|       |
  105|      1|  {
  106|      1|    void* ptr = &::sentencepiece::_SelfTestData_Sample_default_instance_;
  107|      1|    new (ptr) ::sentencepiece::SelfTestData_Sample();
  108|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  109|      1|  }
  110|      1|}
sentencepiece_model.pb.cc:_ZL62InitDefaultsscc_info_TrainerSpec_sentencepiece_5fmodel_2eprotov:
  115|      1|static void InitDefaultsscc_info_TrainerSpec_sentencepiece_5fmodel_2eproto() {
  116|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
  117|       |
  118|      1|  {
  119|      1|    void* ptr = &::sentencepiece::_TrainerSpec_default_instance_;
  120|      1|    new (ptr) ::sentencepiece::TrainerSpec();
  121|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  122|      1|  }
  123|      1|}
_ZN13sentencepiece11TrainerSpec10SharedCtorEv:
  490|  2.90k|void TrainerSpec::SharedCtor() {
  491|  2.90k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TrainerSpec_sentencepiece_5fmodel_2eproto.base);
  492|  2.90k|  model_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  493|  2.90k|  input_format_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  494|  2.90k|  required_chars_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  495|  2.90k|  unk_surface_.UnsafeSetDefault(nullptr);
  496|  2.90k|  unk_piece_.UnsafeSetDefault(nullptr);
  497|  2.90k|  bos_piece_.UnsafeSetDefault(nullptr);
  498|  2.90k|  eos_piece_.UnsafeSetDefault(nullptr);
  499|  2.90k|  pad_piece_.UnsafeSetDefault(nullptr);
  500|  2.90k|  pretokenization_delimiter_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  501|  2.90k|  seed_sentencepieces_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  502|  2.90k|  ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
  503|  2.90k|      reinterpret_cast<char*>(&self_test_sample_size_) - reinterpret_cast<char*>(this)),
  504|  2.90k|      0, static_cast<size_t>(reinterpret_cast<char*>(&differential_privacy_clipping_threshold_) -
  505|  2.90k|      reinterpret_cast<char*>(&self_test_sample_size_)) + sizeof(differential_privacy_clipping_threshold_));
  506|  2.90k|  model_type_ = 1;
  507|  2.90k|  vocab_size_ = 8000;
  508|  2.90k|  character_coverage_ = 0.9995f;
  509|  2.90k|  seed_sentencepiece_size_ = 1000000;
  510|  2.90k|  shrinking_factor_ = 0.75f;
  511|  2.90k|  num_threads_ = 16;
  512|  2.90k|  num_sub_iterations_ = 2;
  513|  2.90k|  max_sentence_length_ = 4192;
  514|  2.90k|  max_sentencepiece_length_ = 16;
  515|  2.90k|  shuffle_input_sentence_ = true;
  516|  2.90k|  split_by_unicode_script_ = true;
  517|  2.90k|  split_by_number_ = true;
  518|  2.90k|  split_by_whitespace_ = true;
  519|  2.90k|  vocabulary_output_piece_score_ = true;
  520|  2.90k|  hard_vocab_limit_ = true;
  521|  2.90k|  bos_id_ = 1;
  522|  2.90k|  eos_id_ = 2;
  523|  2.90k|  pad_id_ = -1;
  524|  2.90k|}
_ZN13sentencepiece11TrainerSpec10SharedDtorEv:
  532|  2.89k|void TrainerSpec::SharedDtor() {
  533|  2.89k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  2.89k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 2.89k]
  |  |  ------------------
  ------------------
  534|  2.89k|  model_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  535|  2.89k|  input_format_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  536|  2.89k|  required_chars_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  537|  2.89k|  unk_surface_.DestroyNoArena(nullptr);
  538|  2.89k|  unk_piece_.DestroyNoArena(nullptr);
  539|  2.89k|  bos_piece_.DestroyNoArena(nullptr);
  540|  2.89k|  eos_piece_.DestroyNoArena(nullptr);
  541|  2.89k|  pad_piece_.DestroyNoArena(nullptr);
  542|  2.89k|  pretokenization_delimiter_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  543|  2.89k|  seed_sentencepieces_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  544|  2.89k|}
_ZN13sentencepiece11TrainerSpec17RegisterArenaDtorEPN6google8protobuf5ArenaE:
  550|  2.90k|void TrainerSpec::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  551|  2.90k|}
_ZN13sentencepiece11TrainerSpec9_Internal18set_has_vocab_sizeEPN6google8protobuf8internal7HasBitsILm2EEE:
  290|  4.88k|  static void set_has_vocab_size(HasBits* has_bits) {
  291|  4.88k|    (*has_bits)[0] |= 33554432u;
  292|  4.88k|  }
_ZN13sentencepiece11TrainerSpec9_Internal29set_has_self_test_sample_sizeEPN6google8protobuf8internal7HasBitsILm2EEE:
  293|    821|  static void set_has_self_test_sample_size(HasBits* has_bits) {
  294|    821|    (*has_bits)[0] |= 1024u;
  295|    821|  }
_ZN13sentencepiece11TrainerSpec9_Internal26set_has_character_coverageEPN6google8protobuf8internal7HasBitsILm2EEE:
  305|     92|  static void set_has_character_coverage(HasBits* has_bits) {
  306|     92|    (*has_bits)[0] |= 67108864u;
  307|     92|  }
_ZN13sentencepiece11TrainerSpec9_Internal27set_has_input_sentence_sizeEPN6google8protobuf8internal7HasBitsILm2EEE:
  308|  1.00k|  static void set_has_input_sentence_size(HasBits* has_bits) {
  309|  1.00k|    (*has_bits)[0] |= 4096u;
  310|  1.00k|  }
_ZN13sentencepiece11TrainerSpec9_Internal28set_has_mining_sentence_sizeEPN6google8protobuf8internal7HasBitsILm2EEE:
  314|    239|  static void set_has_mining_sentence_size(HasBits* has_bits) {
  315|    239|    (*has_bits)[0] |= 2048u;
  316|    239|  }
_ZN13sentencepiece11TrainerSpec9_Internal30set_has_training_sentence_sizeEPN6google8protobuf8internal7HasBitsILm2EEE:
  317|    806|  static void set_has_training_sentence_size(HasBits* has_bits) {
  318|    806|    (*has_bits)[0] |= 8192u;
  319|    806|  }
_ZN13sentencepiece11TrainerSpec9_Internal31set_has_seed_sentencepiece_sizeEPN6google8protobuf8internal7HasBitsILm2EEE:
  320|  8.36k|  static void set_has_seed_sentencepiece_size(HasBits* has_bits) {
  321|  8.36k|    (*has_bits)[0] |= 134217728u;
  322|  8.36k|  }
_ZN13sentencepiece11TrainerSpec9_Internal24set_has_shrinking_factorEPN6google8protobuf8internal7HasBitsILm2EEE:
  323|    709|  static void set_has_shrinking_factor(HasBits* has_bits) {
  324|    709|    (*has_bits)[0] |= 268435456u;
  325|    709|  }
_ZN13sentencepiece11TrainerSpec9_Internal19set_has_num_threadsEPN6google8protobuf8internal7HasBitsILm2EEE:
  329|    119|  static void set_has_num_threads(HasBits* has_bits) {
  330|    119|    (*has_bits)[0] |= 536870912u;
  331|    119|  }
_ZN13sentencepiece11TrainerSpec9_Internal26set_has_num_sub_iterationsEPN6google8protobuf8internal7HasBitsILm2EEE:
  332|    133|  static void set_has_num_sub_iterations(HasBits* has_bits) {
  333|    133|    (*has_bits)[0] |= 1073741824u;
  334|    133|  }
_ZN13sentencepiece11TrainerSpec9_Internal27set_has_max_sentence_lengthEPN6google8protobuf8internal7HasBitsILm2EEE:
  326|     39|  static void set_has_max_sentence_length(HasBits* has_bits) {
  327|     39|    (*has_bits)[0] |= 2147483648u;
  328|     39|  }
_ZN13sentencepiece11TrainerSpec9_Internal30set_has_shuffle_input_sentenceEPN6google8protobuf8internal7HasBitsILm2EEE:
  311|  2.16k|  static void set_has_shuffle_input_sentence(HasBits* has_bits) {
  312|  2.16k|    (*has_bits)[1] |= 2u;
  313|  2.16k|  }
_ZN13sentencepiece11TrainerSpec9_Internal32set_has_max_sentencepiece_lengthEPN6google8protobuf8internal7HasBitsILm2EEE:
  335|    244|  static void set_has_max_sentencepiece_length(HasBits* has_bits) {
  336|    244|    (*has_bits)[1] |= 1u;
  337|    244|  }
_ZN13sentencepiece11TrainerSpec9_Internal31set_has_split_by_unicode_scriptEPN6google8protobuf8internal7HasBitsILm2EEE:
  338|    437|  static void set_has_split_by_unicode_script(HasBits* has_bits) {
  339|    437|    (*has_bits)[1] |= 4u;
  340|    437|  }
_ZN13sentencepiece11TrainerSpec9_Internal27set_has_split_by_whitespaceEPN6google8protobuf8internal7HasBitsILm2EEE:
  344|    303|  static void set_has_split_by_whitespace(HasBits* has_bits) {
  345|    303|    (*has_bits)[1] |= 16u;
  346|    303|  }
_ZN13sentencepiece11TrainerSpec9_Internal23set_has_split_by_numberEPN6google8protobuf8internal7HasBitsILm2EEE:
  341|    427|  static void set_has_split_by_number(HasBits* has_bits) {
  342|    427|    (*has_bits)[1] |= 8u;
  343|    427|  }
_ZN13sentencepiece11TrainerSpec9_Internal34set_has_treat_whitespace_as_suffixEPN6google8protobuf8internal7HasBitsILm2EEE:
  347|    210|  static void set_has_treat_whitespace_as_suffix(HasBits* has_bits) {
  348|    210|    (*has_bits)[0] |= 32768u;
  349|    210|  }
_ZN13sentencepiece11TrainerSpec9_Internal20set_has_split_digitsEPN6google8protobuf8internal7HasBitsILm2EEE:
  353|     50|  static void set_has_split_digits(HasBits* has_bits) {
  354|     50|    (*has_bits)[0] |= 131072u;
  355|     50|  }
_ZN13sentencepiece11TrainerSpec9_Internal36set_has_allow_whitespace_only_piecesEPN6google8protobuf8internal7HasBitsILm2EEE:
  350|    110|  static void set_has_allow_whitespace_only_pieces(HasBits* has_bits) {
  351|    110|    (*has_bits)[0] |= 65536u;
  352|    110|  }
_ZN13sentencepiece11TrainerSpec9_Internal37set_has_vocabulary_output_piece_scoreEPN6google8protobuf8internal7HasBitsILm2EEE:
  365|    116|  static void set_has_vocabulary_output_piece_score(HasBits* has_bits) {
  366|    116|    (*has_bits)[1] |= 32u;
  367|    116|  }
_ZN13sentencepiece11TrainerSpec9_Internal24set_has_hard_vocab_limitEPN6google8protobuf8internal7HasBitsILm2EEE:
  368|     37|  static void set_has_hard_vocab_limit(HasBits* has_bits) {
  369|     37|    (*has_bits)[1] |= 64u;
  370|     37|  }
_ZN13sentencepiece11TrainerSpec9_Internal21set_has_use_all_vocabEPN6google8protobuf8internal7HasBitsILm2EEE:
  371|    265|  static void set_has_use_all_vocab(HasBits* has_bits) {
  372|    265|    (*has_bits)[0] |= 524288u;
  373|    265|  }
_ZN13sentencepiece11TrainerSpec9_Internal21set_has_byte_fallbackEPN6google8protobuf8internal7HasBitsILm2EEE:
  362|    146|  static void set_has_byte_fallback(HasBits* has_bits) {
  363|    146|    (*has_bits)[0] |= 262144u;
  364|    146|  }
_ZN13sentencepiece11TrainerSpec9_Internal14set_has_unk_idEPN6google8protobuf8internal7HasBitsILm2EEE:
  374|     37|  static void set_has_unk_id(HasBits* has_bits) {
  375|     37|    (*has_bits)[0] |= 2097152u;
  376|     37|  }
_ZN13sentencepiece11TrainerSpec9_Internal14set_has_bos_idEPN6google8protobuf8internal7HasBitsILm2EEE:
  377|     65|  static void set_has_bos_id(HasBits* has_bits) {
  378|     65|    (*has_bits)[1] |= 128u;
  379|     65|  }
_ZN13sentencepiece11TrainerSpec9_Internal14set_has_eos_idEPN6google8protobuf8internal7HasBitsILm2EEE:
  380|    144|  static void set_has_eos_id(HasBits* has_bits) {
  381|    144|    (*has_bits)[1] |= 256u;
  382|    144|  }
_ZN13sentencepiece11TrainerSpec9_Internal14set_has_pad_idEPN6google8protobuf8internal7HasBitsILm2EEE:
  383|     32|  static void set_has_pad_id(HasBits* has_bits) {
  384|     32|    (*has_bits)[1] |= 512u;
  385|     32|  }
_ZN13sentencepiece11TrainerSpec9_Internal36set_has_train_extremely_large_corpusEPN6google8protobuf8internal7HasBitsILm2EEE:
  401|     49|  static void set_has_train_extremely_large_corpus(HasBits* has_bits) {
  402|     49|    (*has_bits)[0] |= 1048576u;
  403|     49|  }
_ZN13sentencepiece11TrainerSpec9_Internal35set_has_enable_differential_privacyEPN6google8protobuf8internal7HasBitsILm2EEE:
  296|    111|  static void set_has_enable_differential_privacy(HasBits* has_bits) {
  297|    111|    (*has_bits)[0] |= 16384u;
  298|    111|  }
_ZN13sentencepiece11TrainerSpec9_Internal40set_has_differential_privacy_noise_levelEPN6google8protobuf8internal7HasBitsILm2EEE:
  299|      8|  static void set_has_differential_privacy_noise_level(HasBits* has_bits) {
  300|      8|    (*has_bits)[0] |= 4194304u;
  301|      8|  }
_ZN13sentencepiece11TrainerSpec9_Internal47set_has_differential_privacy_clipping_thresholdEPN6google8protobuf8internal7HasBitsILm2EEE:
  302|    156|  static void set_has_differential_privacy_clipping_threshold(HasBits* has_bits) {
  303|    156|    (*has_bits)[0] |= 8388608u;
  304|    156|  }
_ZN13sentencepiece14NormalizerSpec10SharedCtorEv:
 1989|  1.27k|void NormalizerSpec::SharedCtor() {
 1990|  1.27k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NormalizerSpec_sentencepiece_5fmodel_2eproto.base);
 1991|  1.27k|  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1992|  1.27k|  precompiled_charsmap_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1993|  1.27k|  normalization_rule_tsv_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1994|  1.27k|  add_dummy_prefix_ = true;
 1995|  1.27k|  remove_extra_whitespaces_ = true;
 1996|  1.27k|  escape_whitespaces_ = true;
 1997|  1.27k|}
_ZN13sentencepiece14NormalizerSpec10SharedDtorEv:
 2005|  1.27k|void NormalizerSpec::SharedDtor() {
 2006|  1.27k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  1.27k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1.27k]
  |  |  ------------------
  ------------------
 2007|  1.27k|  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2008|  1.27k|  precompiled_charsmap_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2009|  1.27k|  normalization_rule_tsv_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2010|  1.27k|}
_ZN13sentencepiece14NormalizerSpec17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2016|  1.27k|void NormalizerSpec::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2017|  1.27k|}
_ZN13sentencepiece14NormalizerSpec9_Internal24set_has_add_dummy_prefixEPN6google8protobuf8internal7HasBitsILm1EEE:
 1942|    980|  static void set_has_add_dummy_prefix(HasBits* has_bits) {
 1943|    980|    (*has_bits)[0] |= 8u;
 1944|    980|  }
_ZN13sentencepiece14NormalizerSpec9_Internal32set_has_remove_extra_whitespacesEPN6google8protobuf8internal7HasBitsILm1EEE:
 1945|  24.0k|  static void set_has_remove_extra_whitespaces(HasBits* has_bits) {
 1946|  24.0k|    (*has_bits)[0] |= 16u;
 1947|  24.0k|  }
_ZN13sentencepiece14NormalizerSpec9_Internal26set_has_escape_whitespacesEPN6google8protobuf8internal7HasBitsILm1EEE:
 1948|  1.22k|  static void set_has_escape_whitespaces(HasBits* has_bits) {
 1949|  1.22k|    (*has_bits)[0] |= 32u;
 1950|  1.22k|  }
_ZN13sentencepiece19SelfTestData_Sample10SharedCtorEv:
 2357|  1.58k|void SelfTestData_Sample::SharedCtor() {
 2358|  1.58k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SelfTestData_Sample_sentencepiece_5fmodel_2eproto.base);
 2359|  1.58k|  input_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2360|  1.58k|  expected_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2361|  1.58k|}
_ZN13sentencepiece19SelfTestData_Sample10SharedDtorEv:
 2369|  1.58k|void SelfTestData_Sample::SharedDtor() {
 2370|  1.58k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  1.58k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1.58k]
  |  |  ------------------
  ------------------
 2371|  1.58k|  input_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2372|  1.58k|  expected_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2373|  1.58k|}
_ZN13sentencepiece19SelfTestData_Sample17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2379|  1.58k|void SelfTestData_Sample::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2380|  1.58k|}
_ZN13sentencepiece12SelfTestData10SharedCtorEv:
 2586|    626|void SelfTestData::SharedCtor() {
 2587|    626|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SelfTestData_sentencepiece_5fmodel_2eproto.base);
 2588|    626|}
_ZN13sentencepiece12SelfTestData10SharedDtorEv:
 2596|    625|void SelfTestData::SharedDtor() {
 2597|    625|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|    625|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 625]
  |  |  ------------------
  ------------------
 2598|    625|}
_ZN13sentencepiece12SelfTestData17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2604|    626|void SelfTestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2605|    626|}
_ZN13sentencepiece24ModelProto_SentencePiece10SharedCtorEv:
 2807|  1.48M|void ModelProto_SentencePiece::SharedCtor() {
 2808|  1.48M|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ModelProto_SentencePiece_sentencepiece_5fmodel_2eproto.base);
 2809|  1.48M|  piece_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2810|  1.48M|  score_ = 0;
 2811|  1.48M|  type_ = 1;
 2812|  1.48M|}
_ZN13sentencepiece24ModelProto_SentencePiece10SharedDtorEv:
 2820|  1.48M|void ModelProto_SentencePiece::SharedDtor() {
 2821|  1.48M|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  1.48M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1.48M]
  |  |  ------------------
  ------------------
 2822|  1.48M|  piece_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2823|  1.48M|}
_ZN13sentencepiece24ModelProto_SentencePiece17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2829|  1.48M|void ModelProto_SentencePiece::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2830|  1.48M|}
_ZN13sentencepiece24ModelProto_SentencePiece9_Internal13set_has_scoreEPN6google8protobuf8internal7HasBitsILm1EEE:
 2776|  54.6k|  static void set_has_score(HasBits* has_bits) {
 2777|  54.6k|    (*has_bits)[0] |= 2u;
 2778|  54.6k|  }
_ZN13sentencepiece10ModelProto10SharedCtorEv:
 3136|  7.70k|void ModelProto::SharedCtor() {
 3137|  7.70k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ModelProto_sentencepiece_5fmodel_2eproto.base);
 3138|  7.70k|  ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 3139|  7.70k|      reinterpret_cast<char*>(&trainer_spec_) - reinterpret_cast<char*>(this)),
 3140|  7.70k|      0, static_cast<size_t>(reinterpret_cast<char*>(&denormalizer_spec_) -
 3141|  7.70k|      reinterpret_cast<char*>(&trainer_spec_)) + sizeof(denormalizer_spec_));
 3142|  7.70k|}
_ZN13sentencepiece10ModelProto10SharedDtorEv:
 3150|  7.70k|void ModelProto::SharedDtor() {
 3151|  7.70k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  7.70k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 7.70k]
  |  |  ------------------
  ------------------
 3152|  7.70k|  if (this != internal_default_instance()) delete trainer_spec_;
  ------------------
  |  Branch (3152:7): [True: 7.70k, False: 0]
  ------------------
 3153|  7.70k|  if (this != internal_default_instance()) delete normalizer_spec_;
  ------------------
  |  Branch (3153:7): [True: 7.70k, False: 0]
  ------------------
 3154|  7.70k|  if (this != internal_default_instance()) delete self_test_data_;
  ------------------
  |  Branch (3154:7): [True: 7.70k, False: 0]
  ------------------
 3155|  7.70k|  if (this != internal_default_instance()) delete denormalizer_spec_;
  ------------------
  |  Branch (3155:7): [True: 7.70k, False: 0]
  ------------------
 3156|  7.70k|}
_ZN13sentencepiece10ModelProto17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 3162|  7.70k|void ModelProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 3163|  7.70k|}

_ZNK13sentencepiece10ModelProto15normalizer_specEv:
 4771|  8.37k|inline const ::sentencepiece::NormalizerSpec& ModelProto::normalizer_spec() const {
 4772|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.normalizer_spec)
 4773|  8.37k|  return _internal_normalizer_spec();
 4774|  8.37k|}
_ZNK13sentencepiece10ModelProto25_internal_normalizer_specEv:
 4766|  8.37k|inline const ::sentencepiece::NormalizerSpec& ModelProto::_internal_normalizer_spec() const {
 4767|  8.37k|  const ::sentencepiece::NormalizerSpec* p = normalizer_spec_;
 4768|  8.37k|  return p != nullptr ? *p : reinterpret_cast<const ::sentencepiece::NormalizerSpec&>(
  ------------------
  |  Branch (4768:10): [True: 919, False: 7.45k]
  ------------------
 4769|  7.45k|      ::sentencepiece::_NormalizerSpec_default_instance_);
 4770|  8.37k|}
_ZNK13sentencepiece10ModelProto12trainer_specEv:
 4688|  46.5M|inline const ::sentencepiece::TrainerSpec& ModelProto::trainer_spec() const {
 4689|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.trainer_spec)
 4690|  46.5M|  return _internal_trainer_spec();
 4691|  46.5M|}
_ZNK13sentencepiece10ModelProto22_internal_trainer_specEv:
 4683|  46.5M|inline const ::sentencepiece::TrainerSpec& ModelProto::_internal_trainer_spec() const {
 4684|  46.5M|  const ::sentencepiece::TrainerSpec* p = trainer_spec_;
 4685|  46.5M|  return p != nullptr ? *p : reinterpret_cast<const ::sentencepiece::TrainerSpec&>(
  ------------------
  |  Branch (4685:10): [True: 3.09M, False: 43.4M]
  ------------------
 4686|  43.4M|      ::sentencepiece::_TrainerSpec_default_instance_);
 4687|  46.5M|}
_ZNK13sentencepiece10ModelProto21has_denormalizer_specEv:
 4925|  3.17k|inline bool ModelProto::has_denormalizer_spec() const {
 4926|  3.17k|  return _internal_has_denormalizer_spec();
 4927|  3.17k|}
_ZNK13sentencepiece10ModelProto31_internal_has_denormalizer_specEv:
 4920|  6.35k|inline bool ModelProto::_internal_has_denormalizer_spec() const {
 4921|  6.35k|  bool value = (_has_bits_[0] & 0x00000008u) != 0;
 4922|  6.35k|  PROTOBUF_ASSUME(!value || denormalizer_spec_ != nullptr);
  ------------------
  |  |  493|  6.35k|  GOOGLE_DCHECK(pred);               \
  |  |  ------------------
  |  |  |  |  181|  6.35k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 6.35k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  494|  6.61k|  __builtin_assume(pred)
  |  |  ------------------
  |  |  |  Branch (494:20): [True: 6.10k, False: 252]
  |  |  |  Branch (494:20): [True: 252, False: 0]
  |  |  ------------------
  ------------------
 4923|  6.35k|  return value;
 4924|  6.35k|}
_ZNK13sentencepiece10ModelProto17denormalizer_specEv:
 4937|    143|inline const ::sentencepiece::NormalizerSpec& ModelProto::denormalizer_spec() const {
 4938|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.denormalizer_spec)
 4939|    143|  return _internal_denormalizer_spec();
 4940|    143|}
_ZNK13sentencepiece10ModelProto27_internal_denormalizer_specEv:
 4932|    143|inline const ::sentencepiece::NormalizerSpec& ModelProto::_internal_denormalizer_spec() const {
 4933|    143|  const ::sentencepiece::NormalizerSpec* p = denormalizer_spec_;
 4934|    143|  return p != nullptr ? *p : reinterpret_cast<const ::sentencepiece::NormalizerSpec&>(
  ------------------
  |  Branch (4934:10): [True: 143, False: 0]
  ------------------
 4935|      0|      ::sentencepiece::_NormalizerSpec_default_instance_);
 4936|    143|}
_ZNK13sentencepiece14NormalizerSpec20precompiled_charsmapEv:
 4082|  3.32k|inline const std::string& NormalizerSpec::precompiled_charsmap() const {
 4083|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.precompiled_charsmap)
 4084|  3.32k|  return _internal_precompiled_charsmap();
 4085|  3.32k|}
_ZNK13sentencepiece14NormalizerSpec30_internal_precompiled_charsmapEv:
 4094|  3.34k|inline const std::string& NormalizerSpec::_internal_precompiled_charsmap() const {
 4095|  3.34k|  return precompiled_charsmap_.Get();
 4096|  3.34k|}
_ZNK13sentencepiece10ModelProto14self_test_dataEv:
 4854|  2.12k|inline const ::sentencepiece::SelfTestData& ModelProto::self_test_data() const {
 4855|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.self_test_data)
 4856|  2.12k|  return _internal_self_test_data();
 4857|  2.12k|}
_ZNK13sentencepiece10ModelProto24_internal_self_test_dataEv:
 4849|  2.12k|inline const ::sentencepiece::SelfTestData& ModelProto::_internal_self_test_data() const {
 4850|  2.12k|  const ::sentencepiece::SelfTestData* p = self_test_data_;
 4851|  2.12k|  return p != nullptr ? *p : reinterpret_cast<const ::sentencepiece::SelfTestData&>(
  ------------------
  |  Branch (4851:10): [True: 128, False: 2.00k]
  ------------------
 4852|  2.00k|      ::sentencepiece::_SelfTestData_default_instance_);
 4853|  2.12k|}
_ZNK13sentencepiece12SelfTestData7samplesEv:
 4488|  2.08k|SelfTestData::samples() const {
 4489|       |  // @@protoc_insertion_point(field_list:sentencepiece.SelfTestData.samples)
 4490|  2.08k|  return samples_;
 4491|  2.08k|}
_ZNK13sentencepiece19SelfTestData_Sample5inputEv:
 4316|    429|inline const std::string& SelfTestData_Sample::input() const {
 4317|       |  // @@protoc_insertion_point(field_get:sentencepiece.SelfTestData.Sample.input)
 4318|    429|  return _internal_input();
 4319|    429|}
_ZNK13sentencepiece19SelfTestData_Sample15_internal_inputEv:
 4328|    567|inline const std::string& SelfTestData_Sample::_internal_input() const {
 4329|    567|  return input_.Get();
 4330|    567|}
_ZNK13sentencepiece19SelfTestData_Sample8expectedEv:
 4389|    429|inline const std::string& SelfTestData_Sample::expected() const {
 4390|       |  // @@protoc_insertion_point(field_get:sentencepiece.SelfTestData.Sample.expected)
 4391|    429|  return _internal_expected();
 4392|    429|}
_ZNK13sentencepiece19SelfTestData_Sample18_internal_expectedEv:
 4401|    435|inline const std::string& SelfTestData_Sample::_internal_expected() const {
 4402|    435|  return expected_.Get();
 4403|    435|}
_ZNK13sentencepiece12SelfTestData12samples_sizeEv:
 4458|     48|inline int SelfTestData::samples_size() const {
 4459|     48|  return _internal_samples_size();
 4460|     48|}
_ZNK13sentencepiece12SelfTestData22_internal_samples_sizeEv:
 4455|    112|inline int SelfTestData::_internal_samples_size() const {
 4456|    112|  return samples_.size();
 4457|    112|}
_ZNK13sentencepiece11TrainerSpec10model_typeEv:
 2300|  3.17k|inline ::sentencepiece::TrainerSpec_ModelType TrainerSpec::model_type() const {
 2301|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.model_type)
 2302|  3.17k|  return _internal_model_type();
 2303|  3.17k|}
_ZNK13sentencepiece11TrainerSpec20_internal_model_typeEv:
 2297|  4.08k|inline ::sentencepiece::TrainerSpec_ModelType TrainerSpec::_internal_model_type() const {
 2298|  4.08k|  return static_cast< ::sentencepiece::TrainerSpec_ModelType >(model_type_);
 2299|  4.08k|}
_ZNK13sentencepiece10ModelProto11pieces_sizeEv:
 4635|  7.48M|inline int ModelProto::pieces_size() const {
 4636|  7.48M|  return _internal_pieces_size();
 4637|  7.48M|}
_ZNK13sentencepiece10ModelProto21_internal_pieces_sizeEv:
 4632|  7.49M|inline int ModelProto::_internal_pieces_size() const {
 4633|  7.49M|  return pieces_.size();
 4634|  7.49M|}
_ZNK13sentencepiece24ModelProto_SentencePiece4typeEv:
 4613|   155M|inline ::sentencepiece::ModelProto_SentencePiece_Type ModelProto_SentencePiece::type() const {
 4614|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.type)
 4615|   155M|  return _internal_type();
 4616|   155M|}
_ZNK13sentencepiece24ModelProto_SentencePiece14_internal_typeEv:
 4610|   155M|inline ::sentencepiece::ModelProto_SentencePiece_Type ModelProto_SentencePiece::_internal_type() const {
 4611|   155M|  return static_cast< ::sentencepiece::ModelProto_SentencePiece_Type >(type_);
 4612|   155M|}
_ZNK13sentencepiece24ModelProto_SentencePiece5pieceEv:
 4509|  2.40M|inline const std::string& ModelProto_SentencePiece::piece() const {
 4510|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.piece)
 4511|  2.40M|  return _internal_piece();
 4512|  2.40M|}
_ZNK13sentencepiece24ModelProto_SentencePiece15_internal_pieceEv:
 4521|  2.45M|inline const std::string& ModelProto_SentencePiece::_internal_piece() const {
 4522|  2.45M|  return piece_.Get();
 4523|  2.45M|}
_ZN13sentencepiece24ModelProto_SentencePiece18_internal_set_typeENS_29ModelProto_SentencePiece_TypeE:
 4617|  26.8k|inline void ModelProto_SentencePiece::_internal_set_type(::sentencepiece::ModelProto_SentencePiece_Type value) {
 4618|       |  assert(::sentencepiece::ModelProto_SentencePiece_Type_IsValid(value));
 4619|  26.8k|  _has_bits_[0] |= 0x00000004u;
 4620|  26.8k|  type_ = value;
 4621|  26.8k|}
_ZNK13sentencepiece11TrainerSpec15has_unk_surfaceEv:
 3823|  3.88k|inline bool TrainerSpec::has_unk_surface() const {
 3824|  3.88k|  return _internal_has_unk_surface();
 3825|  3.88k|}
_ZNK13sentencepiece11TrainerSpec25_internal_has_unk_surfaceEv:
 3819|  3.88k|inline bool TrainerSpec::_internal_has_unk_surface() const {
 3820|  3.88k|  bool value = (_has_bits_[0] & 0x00000008u) != 0;
 3821|  3.88k|  return value;
 3822|  3.88k|}
_ZNK13sentencepiece11TrainerSpec11unk_surfaceEv:
 3830|     46|inline const std::string& TrainerSpec::unk_surface() const {
 3831|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_surface)
 3832|     46|  if (unk_surface_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_unk_surface_.get();
  ------------------
  |  Branch (3832:7): [True: 0, False: 46]
  ------------------
 3833|     46|  return _internal_unk_surface();
 3834|     46|}
_ZNK13sentencepiece11TrainerSpec21_internal_unk_surfaceEv:
 3843|     92|inline const std::string& TrainerSpec::_internal_unk_surface() const {
 3844|     92|  return unk_surface_.Get();
 3845|     92|}
_ZNK13sentencepiece14NormalizerSpec16add_dummy_prefixEv:
 4158|  16.5k|inline bool NormalizerSpec::add_dummy_prefix() const {
 4159|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.add_dummy_prefix)
 4160|  16.5k|  return _internal_add_dummy_prefix();
 4161|  16.5k|}
_ZNK13sentencepiece14NormalizerSpec26_internal_add_dummy_prefixEv:
 4155|  16.6k|inline bool NormalizerSpec::_internal_add_dummy_prefix() const {
 4156|  16.6k|  return add_dummy_prefix_;
 4157|  16.6k|}
_ZNK13sentencepiece14NormalizerSpec24remove_extra_whitespacesEv:
 4186|   121M|inline bool NormalizerSpec::remove_extra_whitespaces() const {
 4187|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.remove_extra_whitespaces)
 4188|   121M|  return _internal_remove_extra_whitespaces();
 4189|   121M|}
_ZNK13sentencepiece14NormalizerSpec34_internal_remove_extra_whitespacesEv:
 4183|   121M|inline bool NormalizerSpec::_internal_remove_extra_whitespaces() const {
 4184|   121M|  return remove_extra_whitespaces_;
 4185|   121M|}
_ZN13sentencepiece10ModelProto33_internal_mutable_normalizer_specEv:
 4804|    672|inline ::sentencepiece::NormalizerSpec* ModelProto::_internal_mutable_normalizer_spec() {
 4805|    672|  _has_bits_[0] |= 0x00000002u;
 4806|    672|  if (normalizer_spec_ == nullptr) {
  ------------------
  |  Branch (4806:7): [True: 642, False: 30]
  ------------------
 4807|    642|    auto* p = CreateMaybeMessage<::sentencepiece::NormalizerSpec>(GetArena());
 4808|    642|    normalizer_spec_ = p;
 4809|    642|  }
 4810|    672|  return normalizer_spec_;
 4811|    672|}
_ZN13sentencepiece10ModelProtoC2Ev:
 1836|  7.70k|  inline ModelProto() : ModelProto(nullptr) {}
_ZN13sentencepiece11TrainerSpecC2Ev:
  133|  2.90k|  inline TrainerSpec() : TrainerSpec(nullptr) {}
_ZN13sentencepiece11TrainerSpec22mutable_unknown_fieldsEv:
  158|  3.16k|  inline std::string* mutable_unknown_fields() {
  159|  3.16k|    return _internal_metadata_.mutable_unknown_fields<std::string>();
  160|  3.16k|  }
_ZN13sentencepiece11TrainerSpec25internal_default_instanceEv:
  164|  2.99k|  static inline const TrainerSpec* internal_default_instance() {
  165|  2.99k|    return reinterpret_cast<const TrainerSpec*>(
  166|  2.99k|               &_TrainerSpec_default_instance_);
  167|  2.99k|  }
_ZNK13sentencepiece11TrainerSpec13GetCachedSizeEv:
  209|    556|  int GetCachedSize() const final { return _cached_size_.Get(); }
_ZN13sentencepiece14NormalizerSpecC2Ev:
 1093|  1.27k|  inline NormalizerSpec() : NormalizerSpec(nullptr) {}
_ZN13sentencepiece14NormalizerSpec25internal_default_instanceEv:
 1124|  2.38k|  static inline const NormalizerSpec* internal_default_instance() {
 1125|  2.38k|    return reinterpret_cast<const NormalizerSpec*>(
 1126|  2.38k|               &_NormalizerSpec_default_instance_);
 1127|  2.38k|  }
_ZNK13sentencepiece14NormalizerSpec13GetCachedSizeEv:
 1169|    222|  int GetCachedSize() const final { return _cached_size_.Get(); }
_ZN13sentencepiece19SelfTestData_SampleC2Ev:
 1325|  1.58k|  inline SelfTestData_Sample() : SelfTestData_Sample(nullptr) {}
_ZNK13sentencepiece19SelfTestData_Sample13GetCachedSizeEv:
 1401|     91|  int GetCachedSize() const final { return _cached_size_.Get(); }
_ZN13sentencepiece12SelfTestDataC2Ev:
 1487|    626|  inline SelfTestData() : SelfTestData(nullptr) {}
_ZN13sentencepiece12SelfTestData25internal_default_instanceEv:
 1518|    411|  static inline const SelfTestData* internal_default_instance() {
 1519|    411|    return reinterpret_cast<const SelfTestData*>(
 1520|    411|               &_SelfTestData_default_instance_);
 1521|    411|  }
_ZNK13sentencepiece12SelfTestData13GetCachedSizeEv:
 1563|     32|  int GetCachedSize() const final { return _cached_size_.Get(); }
_ZN13sentencepiece24ModelProto_SentencePieceC2Ev:
 1629|  1.48M|  inline ModelProto_SentencePiece() : ModelProto_SentencePiece(nullptr) {}
_ZN13sentencepiece24ModelProto_SentencePiece22mutable_unknown_fieldsEv:
 1654|  2.19k|  inline std::string* mutable_unknown_fields() {
 1655|  2.19k|    return _internal_metadata_.mutable_unknown_fields<std::string>();
 1656|  2.19k|  }
_ZN13sentencepiece24ModelProto_SentencePiece25internal_default_instanceEv:
 1660|    602|  static inline const ModelProto_SentencePiece* internal_default_instance() {
 1661|    602|    return reinterpret_cast<const ModelProto_SentencePiece*>(
 1662|    602|               &_ModelProto_SentencePiece_default_instance_);
 1663|    602|  }
_ZNK13sentencepiece24ModelProto_SentencePiece13GetCachedSizeEv:
 1705|  27.3k|  int GetCachedSize() const final { return _cached_size_.Get(); }
_ZN13sentencepiece10ModelProto25internal_default_instanceEv:
 1867|  33.8k|  static inline const ModelProto* internal_default_instance() {
 1868|  33.8k|    return reinterpret_cast<const ModelProto*>(
 1869|  33.8k|               &_ModelProto_default_instance_);
 1870|  33.8k|  }
_ZNK13sentencepiece11TrainerSpec20_internal_input_sizeEv:
 2066|    556|inline int TrainerSpec::_internal_input_size() const {
 2067|    556|  return input_.size();
 2068|    556|}
_ZNK13sentencepiece11TrainerSpec15_internal_inputEi:
 2079|    608|inline const std::string& TrainerSpec::_internal_input(int index) const {
 2080|    608|  return input_.Get(index);
 2081|    608|}
_ZN13sentencepiece11TrainerSpec19_internal_add_inputEv:
 2108|  14.7k|inline std::string* TrainerSpec::_internal_add_input() {
 2109|  14.7k|  return input_.Add();
 2110|  14.7k|}
_ZNK13sentencepiece11TrainerSpec22_internal_input_formatEv:
 2163|     36|inline const std::string& TrainerSpec::_internal_input_format() const {
 2164|     36|  return input_format_.Get();
 2165|     36|}
_ZN13sentencepiece11TrainerSpec30_internal_mutable_input_formatEv:
 2189|    131|inline std::string* TrainerSpec::_internal_mutable_input_format() {
 2190|    131|  _has_bits_[0] |= 0x00000002u;
 2191|    131|  return input_format_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 2192|    131|}
_ZNK13sentencepiece11TrainerSpec22_internal_model_prefixEv:
 2236|      8|inline const std::string& TrainerSpec::_internal_model_prefix() const {
 2237|      8|  return model_prefix_.Get();
 2238|      8|}
_ZN13sentencepiece11TrainerSpec30_internal_mutable_model_prefixEv:
 2262|    349|inline std::string* TrainerSpec::_internal_mutable_model_prefix() {
 2263|    349|  _has_bits_[0] |= 0x00000001u;
 2264|    349|  return model_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 2265|    349|}
_ZN13sentencepiece11TrainerSpec24_internal_set_model_typeENS_21TrainerSpec_ModelTypeE:
 2304|    797|inline void TrainerSpec::_internal_set_model_type(::sentencepiece::TrainerSpec_ModelType value) {
 2305|       |  assert(::sentencepiece::TrainerSpec_ModelType_IsValid(value));
 2306|    797|  _has_bits_[0] |= 0x01000000u;
 2307|    797|  model_type_ = value;
 2308|    797|}
_ZNK13sentencepiece11TrainerSpec20_internal_vocab_sizeEv:
 2326|    108|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_vocab_size() const {
 2327|    108|  return vocab_size_;
 2328|    108|}
_ZNK13sentencepiece11TrainerSpec30_internal_accept_language_sizeEv:
 2343|    556|inline int TrainerSpec::_internal_accept_language_size() const {
 2344|    556|  return accept_language_.size();
 2345|    556|}
_ZNK13sentencepiece11TrainerSpec25_internal_accept_languageEi:
 2356|     38|inline const std::string& TrainerSpec::_internal_accept_language(int index) const {
 2357|     38|  return accept_language_.Get(index);
 2358|     38|}
_ZN13sentencepiece11TrainerSpec29_internal_add_accept_languageEv:
 2385|    907|inline std::string* TrainerSpec::_internal_add_accept_language() {
 2386|    907|  return accept_language_.Add();
 2387|    907|}
_ZNK13sentencepiece11TrainerSpec31_internal_self_test_sample_sizeEv:
 2428|     42|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_self_test_sample_size() const {
 2429|     42|  return self_test_sample_size_;
 2430|     42|}
_ZNK13sentencepiece11TrainerSpec37_internal_enable_differential_privacyEv:
 2456|      1|inline bool TrainerSpec::_internal_enable_differential_privacy() const {
 2457|      1|  return enable_differential_privacy_;
 2458|      1|}
_ZNK13sentencepiece11TrainerSpec42_internal_differential_privacy_noise_levelEv:
 2484|      2|inline float TrainerSpec::_internal_differential_privacy_noise_level() const {
 2485|      2|  return differential_privacy_noise_level_;
 2486|      2|}
_ZNK13sentencepiece11TrainerSpec28_internal_character_coverageEv:
 2540|      2|inline float TrainerSpec::_internal_character_coverage() const {
 2541|      2|  return character_coverage_;
 2542|      2|}
_ZNK13sentencepiece11TrainerSpec29_internal_input_sentence_sizeEv:
 2568|      4|inline ::PROTOBUF_NAMESPACE_ID::uint64 TrainerSpec::_internal_input_sentence_size() const {
 2569|      4|  return input_sentence_size_;
 2570|      4|}
_ZNK13sentencepiece11TrainerSpec32_internal_shuffle_input_sentenceEv:
 2596|      2|inline bool TrainerSpec::_internal_shuffle_input_sentence() const {
 2597|      2|  return shuffle_input_sentence_;
 2598|      2|}
_ZNK13sentencepiece11TrainerSpec30_internal_mining_sentence_sizeEv:
 2624|     38|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_mining_sentence_size() const {
 2625|     38|  return mining_sentence_size_;
 2626|     38|}
_ZNK13sentencepiece11TrainerSpec32_internal_training_sentence_sizeEv:
 2652|      2|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_training_sentence_size() const {
 2653|      2|  return training_sentence_size_;
 2654|      2|}
_ZNK13sentencepiece11TrainerSpec33_internal_seed_sentencepiece_sizeEv:
 2680|     14|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_seed_sentencepiece_size() const {
 2681|     14|  return seed_sentencepiece_size_;
 2682|     14|}
_ZNK13sentencepiece11TrainerSpec26_internal_shrinking_factorEv:
 2708|      2|inline float TrainerSpec::_internal_shrinking_factor() const {
 2709|      2|  return shrinking_factor_;
 2710|      2|}
_ZNK13sentencepiece11TrainerSpec29_internal_max_sentence_lengthEv:
 2736|     10|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_max_sentence_length() const {
 2737|     10|  return max_sentence_length_;
 2738|     10|}
_ZNK13sentencepiece11TrainerSpec21_internal_num_threadsEv:
 2764|     14|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_num_threads() const {
 2765|     14|  return num_threads_;
 2766|     14|}
_ZNK13sentencepiece11TrainerSpec28_internal_num_sub_iterationsEv:
 2792|     12|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_num_sub_iterations() const {
 2793|     12|  return num_sub_iterations_;
 2794|     12|}
_ZNK13sentencepiece11TrainerSpec34_internal_max_sentencepiece_lengthEv:
 2820|      8|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_max_sentencepiece_length() const {
 2821|      8|  return max_sentencepiece_length_;
 2822|      8|}
_ZNK13sentencepiece11TrainerSpec33_internal_split_by_unicode_scriptEv:
 2848|      3|inline bool TrainerSpec::_internal_split_by_unicode_script() const {
 2849|      3|  return split_by_unicode_script_;
 2850|      3|}
_ZNK13sentencepiece11TrainerSpec25_internal_split_by_numberEv:
 2876|      1|inline bool TrainerSpec::_internal_split_by_number() const {
 2877|      1|  return split_by_number_;
 2878|      1|}
_ZNK13sentencepiece11TrainerSpec29_internal_split_by_whitespaceEv:
 2904|      9|inline bool TrainerSpec::_internal_split_by_whitespace() const {
 2905|      9|  return split_by_whitespace_;
 2906|      9|}
_ZNK13sentencepiece11TrainerSpec36_internal_treat_whitespace_as_suffixEv:
 2932|  3.18k|inline bool TrainerSpec::_internal_treat_whitespace_as_suffix() const {
 2933|  3.18k|  return treat_whitespace_as_suffix_;
 2934|  3.18k|}
_ZNK13sentencepiece11TrainerSpec26treat_whitespace_as_suffixEv:
 2935|  3.17k|inline bool TrainerSpec::treat_whitespace_as_suffix() const {
 2936|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.treat_whitespace_as_suffix)
 2937|  3.17k|  return _internal_treat_whitespace_as_suffix();
 2938|  3.17k|}
_ZNK13sentencepiece11TrainerSpec38_internal_allow_whitespace_only_piecesEv:
 2960|      1|inline bool TrainerSpec::_internal_allow_whitespace_only_pieces() const {
 2961|      1|  return allow_whitespace_only_pieces_;
 2962|      1|}
_ZNK13sentencepiece11TrainerSpec22_internal_split_digitsEv:
 2988|      1|inline bool TrainerSpec::_internal_split_digits() const {
 2989|      1|  return split_digits_;
 2990|      1|}
_ZN13sentencepiece11TrainerSpec43_internal_mutable_pretokenization_delimiterEv:
 3054|      9|inline std::string* TrainerSpec::_internal_mutable_pretokenization_delimiter() {
 3055|      9|  _has_bits_[0] |= 0x00000100u;
 3056|      9|  return pretokenization_delimiter_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 3057|      9|}
_ZNK13sentencepiece11TrainerSpec30_internal_control_symbols_sizeEv:
 3078|    556|inline int TrainerSpec::_internal_control_symbols_size() const {
 3079|    556|  return control_symbols_.size();
 3080|    556|}
_ZNK13sentencepiece11TrainerSpec25_internal_control_symbolsEi:
 3091|      1|inline const std::string& TrainerSpec::_internal_control_symbols(int index) const {
 3092|      1|  return control_symbols_.Get(index);
 3093|      1|}
_ZN13sentencepiece11TrainerSpec29_internal_add_control_symbolsEv:
 3120|    107|inline std::string* TrainerSpec::_internal_add_control_symbols() {
 3121|    107|  return control_symbols_.Add();
 3122|    107|}
_ZNK13sentencepiece11TrainerSpec35_internal_user_defined_symbols_sizeEv:
 3152|    556|inline int TrainerSpec::_internal_user_defined_symbols_size() const {
 3153|    556|  return user_defined_symbols_.size();
 3154|    556|}
_ZNK13sentencepiece11TrainerSpec30_internal_user_defined_symbolsEi:
 3165|      8|inline const std::string& TrainerSpec::_internal_user_defined_symbols(int index) const {
 3166|      8|  return user_defined_symbols_.Get(index);
 3167|      8|}
_ZN13sentencepiece11TrainerSpec34_internal_add_user_defined_symbolsEv:
 3194|     52|inline std::string* TrainerSpec::_internal_add_user_defined_symbols() {
 3195|     52|  return user_defined_symbols_.Add();
 3196|     52|}
_ZNK13sentencepiece11TrainerSpec24_internal_required_charsEv:
 3249|      2|inline const std::string& TrainerSpec::_internal_required_chars() const {
 3250|      2|  return required_chars_.Get();
 3251|      2|}
_ZN13sentencepiece11TrainerSpec32_internal_mutable_required_charsEv:
 3275|     14|inline std::string* TrainerSpec::_internal_mutable_required_chars() {
 3276|     14|  _has_bits_[0] |= 0x00000004u;
 3277|     14|  return required_chars_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 3278|     14|}
_ZNK13sentencepiece11TrainerSpec23_internal_byte_fallbackEv:
 3310|  46.4M|inline bool TrainerSpec::_internal_byte_fallback() const {
 3311|  46.4M|  return byte_fallback_;
 3312|  46.4M|}
_ZNK13sentencepiece11TrainerSpec13byte_fallbackEv:
 3313|  46.4M|inline bool TrainerSpec::byte_fallback() const {
 3314|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.byte_fallback)
 3315|  46.4M|  return _internal_byte_fallback();
 3316|  46.4M|}
_ZNK13sentencepiece11TrainerSpec39_internal_vocabulary_output_piece_scoreEv:
 3338|      1|inline bool TrainerSpec::_internal_vocabulary_output_piece_score() const {
 3339|      1|  return vocabulary_output_piece_score_;
 3340|      1|}
_ZNK13sentencepiece11TrainerSpec26_internal_hard_vocab_limitEv:
 3366|      1|inline bool TrainerSpec::_internal_hard_vocab_limit() const {
 3367|      1|  return hard_vocab_limit_;
 3368|      1|}
_ZNK13sentencepiece11TrainerSpec23_internal_use_all_vocabEv:
 3394|      1|inline bool TrainerSpec::_internal_use_all_vocab() const {
 3395|      1|  return use_all_vocab_;
 3396|      1|}
_ZNK13sentencepiece11TrainerSpec16_internal_unk_idEv:
 3422|      8|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_unk_id() const {
 3423|      8|  return unk_id_;
 3424|      8|}
_ZNK13sentencepiece11TrainerSpec16_internal_bos_idEv:
 3450|      4|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_bos_id() const {
 3451|      4|  return bos_id_;
 3452|      4|}
_ZNK13sentencepiece11TrainerSpec16_internal_eos_idEv:
 3478|     10|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_eos_id() const {
 3479|     10|  return eos_id_;
 3480|     10|}
_ZNK13sentencepiece11TrainerSpec16_internal_pad_idEv:
 3506|     10|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_pad_id() const {
 3507|     10|  return pad_id_;
 3508|     10|}
_ZNK13sentencepiece11TrainerSpec9unk_pieceEv:
 3534|  4.06k|inline const std::string& TrainerSpec::unk_piece() const {
 3535|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_piece)
 3536|  4.06k|  if (unk_piece_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_unk_piece_.get();
  ------------------
  |  Branch (3536:7): [True: 4.06k, False: 3]
  ------------------
 3537|      3|  return _internal_unk_piece();
 3538|  4.06k|}
_ZNK13sentencepiece11TrainerSpec19_internal_unk_pieceEv:
 3547|      7|inline const std::string& TrainerSpec::_internal_unk_piece() const {
 3548|      7|  return unk_piece_.Get();
 3549|      7|}
_ZN13sentencepiece11TrainerSpec27_internal_mutable_unk_pieceEv:
 3573|     21|inline std::string* TrainerSpec::_internal_mutable_unk_piece() {
 3574|     21|  _has_bits_[0] |= 0x00000010u;
 3575|     21|  return unk_piece_.Mutable(::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_piece_, GetArena());
 3576|     21|}
_ZNK13sentencepiece11TrainerSpec9bos_pieceEv:
 3608|  4.05k|inline const std::string& TrainerSpec::bos_piece() const {
 3609|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.bos_piece)
 3610|  4.05k|  if (bos_piece_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_bos_piece_.get();
  ------------------
  |  Branch (3610:7): [True: 4.04k, False: 10]
  ------------------
 3611|     10|  return _internal_bos_piece();
 3612|  4.05k|}
_ZNK13sentencepiece11TrainerSpec19_internal_bos_pieceEv:
 3621|     30|inline const std::string& TrainerSpec::_internal_bos_piece() const {
 3622|     30|  return bos_piece_.Get();
 3623|     30|}
_ZN13sentencepiece11TrainerSpec27_internal_mutable_bos_pieceEv:
 3647|     33|inline std::string* TrainerSpec::_internal_mutable_bos_piece() {
 3648|     33|  _has_bits_[0] |= 0x00000020u;
 3649|     33|  return bos_piece_.Mutable(::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_bos_piece_, GetArena());
 3650|     33|}
_ZNK13sentencepiece11TrainerSpec9eos_pieceEv:
 3682|  4.06k|inline const std::string& TrainerSpec::eos_piece() const {
 3683|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.eos_piece)
 3684|  4.06k|  if (eos_piece_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_eos_piece_.get();
  ------------------
  |  Branch (3684:7): [True: 4.06k, False: 4]
  ------------------
 3685|      4|  return _internal_eos_piece();
 3686|  4.06k|}
_ZNK13sentencepiece11TrainerSpec19_internal_eos_pieceEv:
 3695|      8|inline const std::string& TrainerSpec::_internal_eos_piece() const {
 3696|      8|  return eos_piece_.Get();
 3697|      8|}
_ZN13sentencepiece11TrainerSpec27_internal_mutable_eos_pieceEv:
 3721|     30|inline std::string* TrainerSpec::_internal_mutable_eos_piece() {
 3722|     30|  _has_bits_[0] |= 0x00000040u;
 3723|     30|  return eos_piece_.Mutable(::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_eos_piece_, GetArena());
 3724|     30|}
_ZNK13sentencepiece11TrainerSpec9pad_pieceEv:
 3756|  4.06k|inline const std::string& TrainerSpec::pad_piece() const {
 3757|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.pad_piece)
 3758|  4.06k|  if (pad_piece_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_pad_piece_.get();
  ------------------
  |  Branch (3758:7): [True: 4.06k, False: 4]
  ------------------
 3759|      4|  return _internal_pad_piece();
 3760|  4.06k|}
_ZNK13sentencepiece11TrainerSpec19_internal_pad_pieceEv:
 3769|      8|inline const std::string& TrainerSpec::_internal_pad_piece() const {
 3770|      8|  return pad_piece_.Get();
 3771|      8|}
_ZN13sentencepiece11TrainerSpec27_internal_mutable_pad_pieceEv:
 3795|     28|inline std::string* TrainerSpec::_internal_mutable_pad_piece() {
 3796|     28|  _has_bits_[0] |= 0x00000080u;
 3797|     28|  return pad_piece_.Mutable(::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_pad_piece_, GetArena());
 3798|     28|}
_ZN13sentencepiece11TrainerSpec29_internal_mutable_unk_surfaceEv:
 3869|     55|inline std::string* TrainerSpec::_internal_mutable_unk_surface() {
 3870|     55|  _has_bits_[0] |= 0x00000008u;
 3871|     55|  return unk_surface_.Mutable(::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_surface_, GetArena());
 3872|     55|}
_ZNK13sentencepiece11TrainerSpec38_internal_train_extremely_large_corpusEv:
 3904|      1|inline bool TrainerSpec::_internal_train_extremely_large_corpus() const {
 3905|      1|  return train_extremely_large_corpus_;
 3906|      1|}
_ZNK13sentencepiece11TrainerSpec34_internal_seed_sentencepieces_fileEv:
 3944|      2|inline const std::string& TrainerSpec::_internal_seed_sentencepieces_file() const {
 3945|      2|  return seed_sentencepieces_file_.Get();
 3946|      2|}
_ZN13sentencepiece11TrainerSpec42_internal_mutable_seed_sentencepieces_fileEv:
 3970|      5|inline std::string* TrainerSpec::_internal_mutable_seed_sentencepieces_file() {
 3971|      5|  _has_bits_[0] |= 0x00000200u;
 3972|      5|  return seed_sentencepieces_file_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 3973|      5|}
_ZNK13sentencepiece14NormalizerSpec14_internal_nameEv:
 4021|    314|inline const std::string& NormalizerSpec::_internal_name() const {
 4022|    314|  return name_.Get();
 4023|    314|}
_ZN13sentencepiece14NormalizerSpec22_internal_mutable_nameEv:
 4047|    841|inline std::string* NormalizerSpec::_internal_mutable_name() {
 4048|    841|  _has_bits_[0] |= 0x00000001u;
 4049|    841|  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 4050|    841|}
_ZN13sentencepiece14NormalizerSpec38_internal_mutable_precompiled_charsmapEv:
 4120|    217|inline std::string* NormalizerSpec::_internal_mutable_precompiled_charsmap() {
 4121|    217|  _has_bits_[0] |= 0x00000002u;
 4122|    217|  return precompiled_charsmap_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 4123|    217|}
_ZNK13sentencepiece14NormalizerSpec28_internal_escape_whitespacesEv:
 4211|  13.9k|inline bool NormalizerSpec::_internal_escape_whitespaces() const {
 4212|  13.9k|  return escape_whitespaces_;
 4213|  13.9k|}
_ZNK13sentencepiece14NormalizerSpec18escape_whitespacesEv:
 4214|  13.9k|inline bool NormalizerSpec::escape_whitespaces() const {
 4215|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.escape_whitespaces)
 4216|  13.9k|  return _internal_escape_whitespaces();
 4217|  13.9k|}
_ZNK13sentencepiece14NormalizerSpec32_internal_normalization_rule_tsvEv:
 4251|     32|inline const std::string& NormalizerSpec::_internal_normalization_rule_tsv() const {
 4252|     32|  return normalization_rule_tsv_.Get();
 4253|     32|}
_ZN13sentencepiece14NormalizerSpec40_internal_mutable_normalization_rule_tsvEv:
 4277|    228|inline std::string* NormalizerSpec::_internal_mutable_normalization_rule_tsv() {
 4278|    228|  _has_bits_[0] |= 0x00000004u;
 4279|    228|  return normalization_rule_tsv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 4280|    228|}
_ZN13sentencepiece19SelfTestData_Sample23_internal_mutable_inputEv:
 4354|  1.27k|inline std::string* SelfTestData_Sample::_internal_mutable_input() {
 4355|  1.27k|  _has_bits_[0] |= 0x00000001u;
 4356|  1.27k|  return input_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 4357|  1.27k|}
_ZN13sentencepiece19SelfTestData_Sample26_internal_mutable_expectedEv:
 4427|    185|inline std::string* SelfTestData_Sample::_internal_mutable_expected() {
 4428|    185|  _has_bits_[0] |= 0x00000002u;
 4429|    185|  return expected_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 4430|    185|}
_ZNK13sentencepiece12SelfTestData17_internal_samplesEi:
 4473|     91|inline const ::sentencepiece::SelfTestData_Sample& SelfTestData::_internal_samples(int index) const {
 4474|     91|  return samples_.Get(index);
 4475|     91|}
_ZN13sentencepiece12SelfTestData21_internal_add_samplesEv:
 4480|  1.58k|inline ::sentencepiece::SelfTestData_Sample* SelfTestData::_internal_add_samples() {
 4481|  1.58k|  return samples_.Add();
 4482|  1.58k|}
_ZN13sentencepiece24ModelProto_SentencePiece23_internal_mutable_pieceEv:
 4547|  92.4k|inline std::string* ModelProto_SentencePiece::_internal_mutable_piece() {
 4548|  92.4k|  _has_bits_[0] |= 0x00000001u;
 4549|  92.4k|  return piece_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 4550|  92.4k|}
_ZNK13sentencepiece24ModelProto_SentencePiece15_internal_scoreEv:
 4582|  8.21M|inline float ModelProto_SentencePiece::_internal_score() const {
 4583|  8.21M|  return score_;
 4584|  8.21M|}
_ZNK13sentencepiece24ModelProto_SentencePiece5scoreEv:
 4585|  8.19M|inline float ModelProto_SentencePiece::score() const {
 4586|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.score)
 4587|  8.19M|  return _internal_score();
 4588|  8.19M|}
_ZNK13sentencepiece10ModelProto16_internal_piecesEi:
 4650|   163M|inline const ::sentencepiece::ModelProto_SentencePiece& ModelProto::_internal_pieces(int index) const {
 4651|   163M|  return pieces_.Get(index);
 4652|   163M|}
_ZNK13sentencepiece10ModelProto6piecesEi:
 4653|   162M|inline const ::sentencepiece::ModelProto_SentencePiece& ModelProto::pieces(int index) const {
 4654|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.pieces)
 4655|   162M|  return _internal_pieces(index);
 4656|   162M|}
_ZN13sentencepiece10ModelProto20_internal_add_piecesEv:
 4657|  1.48M|inline ::sentencepiece::ModelProto_SentencePiece* ModelProto::_internal_add_pieces() {
 4658|  1.48M|  return pieces_.Add();
 4659|  1.48M|}
_ZNK13sentencepiece10ModelProto6piecesEv:
 4665|  2.45k|ModelProto::pieces() const {
 4666|       |  // @@protoc_insertion_point(field_list:sentencepiece.ModelProto.pieces)
 4667|  2.45k|  return pieces_;
 4668|  2.45k|}
_ZNK13sentencepiece10ModelProto26_internal_has_trainer_specEv:
 4671|  3.17k|inline bool ModelProto::_internal_has_trainer_spec() const {
 4672|  3.17k|  bool value = (_has_bits_[0] & 0x00000001u) != 0;
 4673|  3.17k|  PROTOBUF_ASSUME(!value || trainer_spec_ != nullptr);
  ------------------
  |  |  493|  3.17k|  GOOGLE_DCHECK(pred);               \
  |  |  ------------------
  |  |  |  |  181|  3.17k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 3.17k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  494|  4.07k|  __builtin_assume(pred)
  |  |  ------------------
  |  |  |  Branch (494:20): [True: 2.28k, False: 896]
  |  |  |  Branch (494:20): [True: 896, False: 0]
  |  |  ------------------
  ------------------
 4674|  3.17k|  return value;
 4675|  3.17k|}
_ZN13sentencepiece10ModelProto30_internal_mutable_trainer_specEv:
 4721|  3.16k|inline ::sentencepiece::TrainerSpec* ModelProto::_internal_mutable_trainer_spec() {
 4722|  3.16k|  _has_bits_[0] |= 0x00000001u;
 4723|  3.16k|  if (trainer_spec_ == nullptr) {
  ------------------
  |  Branch (4723:7): [True: 2.89k, False: 270]
  ------------------
 4724|  2.89k|    auto* p = CreateMaybeMessage<::sentencepiece::TrainerSpec>(GetArena());
 4725|  2.89k|    trainer_spec_ = p;
 4726|  2.89k|  }
 4727|  3.16k|  return trainer_spec_;
 4728|  3.16k|}
_ZNK13sentencepiece10ModelProto29_internal_has_normalizer_specEv:
 4754|  3.17k|inline bool ModelProto::_internal_has_normalizer_spec() const {
 4755|  3.17k|  bool value = (_has_bits_[0] & 0x00000002u) != 0;
 4756|  3.17k|  PROTOBUF_ASSUME(!value || normalizer_spec_ != nullptr);
  ------------------
  |  |  493|  3.17k|  GOOGLE_DCHECK(pred);               \
  |  |  ------------------
  |  |  |  |  181|  3.17k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 3.17k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  494|  3.44k|  __builtin_assume(pred)
  |  |  ------------------
  |  |  |  Branch (494:20): [True: 2.91k, False: 267]
  |  |  |  Branch (494:20): [True: 267, False: 0]
  |  |  ------------------
  ------------------
 4757|  3.17k|  return value;
 4758|  3.17k|}
_ZNK13sentencepiece10ModelProto28_internal_has_self_test_dataEv:
 4837|  3.17k|inline bool ModelProto::_internal_has_self_test_data() const {
 4838|  3.17k|  bool value = (_has_bits_[0] & 0x00000004u) != 0;
 4839|  3.17k|  PROTOBUF_ASSUME(!value || self_test_data_ != nullptr);
  ------------------
  |  |  493|  3.17k|  GOOGLE_DCHECK(pred);               \
  |  |  ------------------
  |  |  |  |  181|  3.17k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 3.17k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  494|  3.27k|  __builtin_assume(pred)
  |  |  ------------------
  |  |  |  Branch (494:20): [True: 3.08k, False: 96]
  |  |  |  Branch (494:20): [True: 96, False: 0]
  |  |  ------------------
  ------------------
 4840|  3.17k|  return value;
 4841|  3.17k|}
_ZN13sentencepiece10ModelProto32_internal_mutable_self_test_dataEv:
 4887|    744|inline ::sentencepiece::SelfTestData* ModelProto::_internal_mutable_self_test_data() {
 4888|    744|  _has_bits_[0] |= 0x00000004u;
 4889|    744|  if (self_test_data_ == nullptr) {
  ------------------
  |  Branch (4889:7): [True: 625, False: 119]
  ------------------
 4890|    625|    auto* p = CreateMaybeMessage<::sentencepiece::SelfTestData>(GetArena());
 4891|    625|    self_test_data_ = p;
 4892|    625|  }
 4893|    744|  return self_test_data_;
 4894|    744|}
_ZN13sentencepiece10ModelProto35_internal_mutable_denormalizer_specEv:
 4970|  1.28k|inline ::sentencepiece::NormalizerSpec* ModelProto::_internal_mutable_denormalizer_spec() {
 4971|  1.28k|  _has_bits_[0] |= 0x00000008u;
 4972|  1.28k|  if (denormalizer_spec_ == nullptr) {
  ------------------
  |  Branch (4972:7): [True: 628, False: 660]
  ------------------
 4973|    628|    auto* p = CreateMaybeMessage<::sentencepiece::NormalizerSpec>(GetArena());
 4974|    628|    denormalizer_spec_ = p;
 4975|    628|  }
 4976|  1.28k|  return denormalizer_spec_;
 4977|  1.28k|}

_ZN13sentencepiece9character5ModelC2ERKNS_10ModelProtoE:
   22|    150|Model::Model(const ModelProto &model_proto) {
   23|    150|  model_proto_ = &model_proto;
   24|    150|  InitializePieces();
   25|    150|}
_ZN13sentencepiece9character5ModelD2Ev:
   27|    150|Model::~Model() {}
_ZNK13sentencepiece9character5Model6EncodeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   29|    369|EncodeResult Model::Encode(absl::string_view normalized) const {
   30|    369|  if (!status().ok() || normalized.empty()) {
  ------------------
  |  Branch (30:7): [True: 0, False: 369]
  |  Branch (30:7): [True: 10, False: 359]
  |  Branch (30:25): [True: 10, False: 359]
  ------------------
   31|     10|    return {};
   32|     10|  }
   33|       |
   34|       |  // Splits the input into character sequence
   35|    359|  EncodeResult output;
   36|  3.41M|  while (!normalized.empty()) {
  ------------------
  |  Branch (36:10): [True: 3.41M, False: 359]
  ------------------
   37|  3.41M|    const int mblen = matcher_->PrefixMatch(normalized);
   38|  3.41M|    absl::string_view w(normalized.data(), mblen);
   39|  3.41M|    output.emplace_back(w, PieceToId(w));
   40|  3.41M|    normalized.remove_prefix(mblen);
   41|  3.41M|  }
   42|       |
   43|    359|  return output;
   44|    369|}

_ZN13sentencepiece4util6StatusC2Ev:
   23|   145M|Status::Status() {}
_ZN13sentencepiece4util6StatusD2Ev:
   24|   430M|Status::~Status() {}
_ZN13sentencepiece4util6StatusC2ENS0_10StatusCodeENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   32|  6.96k|    : rep_(new Rep) {
   33|  6.96k|  rep_->code = code;
   34|  6.96k|  rep_->error_message = std::string(error_message);
   35|  6.96k|}
_ZN13sentencepiece4util6StatusC2ERKS1_:
   38|   284M|    : rep_((s.rep_ == nullptr) ? nullptr : new Rep(*s.rep_)) {}
  ------------------
  |  Branch (38:12): [True: 284M, False: 1.94k]
  ------------------
_ZN13sentencepiece4util6StatusaSERKS1_:
   40|  1.11k|void Status::operator=(const Status& s) {
   41|  1.11k|  if (rep_ != s.rep_)
  ------------------
  |  Branch (41:7): [True: 1.11k, False: 0]
  ------------------
   42|  1.11k|    rep_.reset((s.rep_ == nullptr) ? nullptr : new Rep(*s.rep_));
  ------------------
  |  Branch (42:16): [True: 0, False: 1.11k]
  ------------------
   43|  1.11k|}
_ZN13sentencepiece4util6Status11IgnoreErrorEv:
  121|     18|void Status::IgnoreError() {}

_ZN13sentencepiece5model8FreeListINS_7unigram7Lattice4NodeEED2Ev:
   37|  1.50k|  virtual ~FreeList() = default;
unigram_model.cc:_ZN13sentencepiece5model8FreeListINS_7unigram12_GLOBAL__N_110HypothesisEEaSEOS5_:
   42|    365|  FreeList& operator=(FreeList&& other) noexcept = default;
unigram_model.cc:_ZN13sentencepiece5model8FreeListINS_7unigram12_GLOBAL__N_110HypothesisEED2Ev:
   37|  1.87k|  virtual ~FreeList() = default;
_ZN13sentencepiece5model8FreeListINS_7unigram7Lattice4NodeEEC2Em:
   36|  1.50k|  explicit FreeList(size_t chunk_size) : chunk_size_(chunk_size) {}
_ZN13sentencepiece5model8FreeListINS_7unigram7Lattice4NodeEE8AllocateEv:
   57|  10.0M|  T* Allocate() {
   58|  10.0M|    if (element_index_ >= chunk_size_) {
  ------------------
  |  Branch (58:9): [True: 9.51k, False: 10.0M]
  ------------------
   59|  9.51k|      ++chunk_index_;
   60|  9.51k|      element_index_ = 0;
   61|  9.51k|    }
   62|       |
   63|  10.0M|    if (chunk_index_ == freelist_.size()) {
  ------------------
  |  Branch (63:9): [True: 11.0k, False: 10.0M]
  ------------------
   64|  11.0k|      auto chunk = std::make_unique<T[]>(chunk_size_);
   65|  11.0k|      memset(static_cast<void*>(chunk.get()), 0, sizeof(T) * chunk_size_);
   66|  11.0k|      freelist_.push_back(std::move(chunk));
   67|  11.0k|    }
   68|       |
   69|  10.0M|    T* result = freelist_[chunk_index_].get() + element_index_;
   70|  10.0M|    ++element_index_;
   71|       |
   72|  10.0M|    return result;
   73|  10.0M|  }
_ZNK13sentencepiece5model8FreeListINS_7unigram7Lattice4NodeEE4sizeEv:
   54|  10.0M|  size_t size() const { return chunk_size_ * chunk_index_ + element_index_; }
_ZN13sentencepiece5model8FreeListINS_7unigram7Lattice4NodeEE4FreeEv:
   45|  1.50k|  void Free() {
   46|  1.50k|    for (auto& chunk : freelist_) {
  ------------------
  |  Branch (46:22): [True: 0, False: 1.50k]
  ------------------
   47|      0|      memset(static_cast<void*>(chunk.get()), 0, sizeof(T) * chunk_size_);
   48|      0|    }
   49|  1.50k|    chunk_index_ = 0;
   50|  1.50k|    element_index_ = 0;
   51|  1.50k|  }
unigram_model.cc:_ZN13sentencepiece5model8FreeListINS_7unigram12_GLOBAL__N_110HypothesisEE8AllocateEv:
   57|   109M|  T* Allocate() {
   58|   109M|    if (element_index_ >= chunk_size_) {
  ------------------
  |  Branch (58:9): [True: 213k, False: 109M]
  ------------------
   59|   213k|      ++chunk_index_;
   60|   213k|      element_index_ = 0;
   61|   213k|    }
   62|       |
   63|   109M|    if (chunk_index_ == freelist_.size()) {
  ------------------
  |  Branch (63:9): [True: 214k, False: 109M]
  ------------------
   64|   214k|      auto chunk = std::make_unique<T[]>(chunk_size_);
   65|   214k|      memset(static_cast<void*>(chunk.get()), 0, sizeof(T) * chunk_size_);
   66|   214k|      freelist_.push_back(std::move(chunk));
   67|   214k|    }
   68|       |
   69|   109M|    T* result = freelist_[chunk_index_].get() + element_index_;
   70|   109M|    ++element_index_;
   71|       |
   72|   109M|    return result;
   73|   109M|  }
unigram_model.cc:_ZN13sentencepiece5model8FreeListINS_7unigram12_GLOBAL__N_110HypothesisEEC2Em:
   36|  1.87k|  explicit FreeList(size_t chunk_size) : chunk_size_(chunk_size) {}
unigram_model.cc:_ZNK13sentencepiece5model8FreeListINS_7unigram12_GLOBAL__N_110HypothesisEE4sizeEv:
   54|  78.9M|  size_t size() const { return chunk_size_ * chunk_index_ + element_index_; }

_ZN13sentencepiece12ModelFactory6CreateERKNS_10ModelProtoE:
   26|  3.17k|    const ModelProto& model_proto) {
   27|  3.17k|  const auto& trainer_spec = model_proto.trainer_spec();
   28|       |
   29|  3.17k|  switch (trainer_spec.model_type()) {
   30|  2.45k|    case TrainerSpec::UNIGRAM:
  ------------------
  |  Branch (30:5): [True: 2.45k, False: 723]
  ------------------
   31|  2.45k|      return std::make_unique<unigram::Model>(model_proto);
   32|      0|      break;
   33|    287|    case TrainerSpec::BPE:
  ------------------
  |  Branch (33:5): [True: 287, False: 2.89k]
  ------------------
   34|    287|      return std::make_unique<bpe::Model>(model_proto);
   35|      0|      break;
   36|    286|    case TrainerSpec::WORD:
  ------------------
  |  Branch (36:5): [True: 286, False: 2.89k]
  ------------------
   37|    286|      return std::make_unique<word::Model>(model_proto);
   38|      0|      break;
   39|    150|    case TrainerSpec::CHAR:
  ------------------
  |  Branch (39:5): [True: 150, False: 3.02k]
  ------------------
   40|    150|      return std::make_unique<character::Model>(model_proto);
   41|      0|      break;
   42|      0|    default:
  ------------------
  |  Branch (42:5): [True: 0, False: 3.17k]
  ------------------
   43|      0|      LOG(ERROR) << "Unknown model_type: " << trainer_spec.model_type();
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   44|      0|      return nullptr;
   45|      0|      break;
   46|  3.17k|  }
   47|       |
   48|      0|  return std::make_unique<unigram::Model>(model_proto);
   49|  3.17k|}

_ZN13sentencepiece14ModelInterfaceD2Ev:
   27|  3.17k|ModelInterface::~ModelInterface() {}
_ZNK13sentencepiece14ModelInterface9unk_pieceEv:
   33|  2.03k|absl::string_view ModelInterface::unk_piece() const {
   34|  2.03k|  RETURN_PIECE(unk_piece, "<unk>");
  ------------------
  |  |   30|  2.03k|  if (model_proto_->trainer_spec().name().empty()) return default_value; \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 1, False: 2.03k]
  |  |  ------------------
  |  |   31|  2.03k|  return model_proto_->trainer_spec().name();
  ------------------
   35|      0|}
_ZNK13sentencepiece14ModelInterface9bos_pieceEv:
   37|  2.03k|absl::string_view ModelInterface::bos_piece() const {
   38|  2.03k|  RETURN_PIECE(bos_piece, "<s>");
  ------------------
  |  |   30|  2.03k|  if (model_proto_->trainer_spec().name().empty()) return default_value; \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 10, False: 2.02k]
  |  |  ------------------
  |  |   31|  2.02k|  return model_proto_->trainer_spec().name();
  ------------------
   39|      0|}
_ZNK13sentencepiece14ModelInterface9eos_pieceEv:
   41|  2.03k|absl::string_view ModelInterface::eos_piece() const {
   42|  2.03k|  RETURN_PIECE(eos_piece, "</s>");
  ------------------
  |  |   30|  2.03k|  if (model_proto_->trainer_spec().name().empty()) return default_value; \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 2.03k]
  |  |  ------------------
  |  |   31|  2.03k|  return model_proto_->trainer_spec().name();
  ------------------
   43|      0|}
_ZNK13sentencepiece14ModelInterface9pad_pieceEv:
   45|  2.03k|absl::string_view ModelInterface::pad_piece() const {
   46|  2.03k|  RETURN_PIECE(pad_piece, "<pad>");
  ------------------
  |  |   30|  2.03k|  if (model_proto_->trainer_spec().name().empty()) return default_value; \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 2.03k]
  |  |  ------------------
  |  |   31|  2.03k|  return model_proto_->trainer_spec().name();
  ------------------
   47|      0|}
_ZNK13sentencepiece14ModelInterface9PieceToIdENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   51|  4.42M|int ModelInterface::PieceToId(absl::string_view piece) const {
   52|  4.42M|  if (auto it = reserved_id_map_.find(piece); it != reserved_id_map_.end()) {
  ------------------
  |  Branch (52:47): [True: 20.4k, False: 4.40M]
  ------------------
   53|  20.4k|    return it->second;
   54|  20.4k|  }
   55|  4.40M|  if (auto it = pieces_.find(piece); it != pieces_.end()) {
  ------------------
  |  Branch (55:38): [True: 109k, False: 4.29M]
  ------------------
   56|   109k|    return it->second;
   57|   109k|  }
   58|  4.29M|  return unk_id_;
   59|  4.40M|}
_ZN13sentencepiece14ModelInterface16InitializePiecesEv:
   61|  3.17k|void ModelInterface::InitializePieces() {
   62|  3.17k|  pieces_.clear();
   63|  3.17k|  reserved_id_map_.clear();
   64|  3.17k|  unk_id_ = -1;
   65|       |
   66|  3.17k|  std::set<absl::string_view> user_defined_symbols;
   67|  3.17k|  std::vector<bool> byte_found(256, false);
   68|       |
   69|  3.17k|  int pieces_size = 0;
   70|  3.17k|  int reserved_id_map_size = 0;
   71|  1.31M|  for (int i = 0; i < model_proto_->pieces_size(); ++i) {
  ------------------
  |  Branch (71:19): [True: 1.31M, False: 3.17k]
  ------------------
   72|  1.31M|    const auto &sp = model_proto_->pieces(i);
   73|  1.31M|    const bool is_normal_piece =
   74|  1.31M|        (sp.type() == ModelProto::SentencePiece::NORMAL ||
  ------------------
  |  Branch (74:10): [True: 1.28M, False: 26.3k]
  ------------------
   75|  26.3k|         sp.type() == ModelProto::SentencePiece::USER_DEFINED ||
  ------------------
  |  Branch (75:10): [True: 646, False: 25.6k]
  ------------------
   76|  25.6k|         sp.type() == ModelProto::SentencePiece::UNUSED);
  ------------------
  |  Branch (76:10): [True: 50, False: 25.6k]
  ------------------
   77|  1.31M|    if (is_normal_piece) {
  ------------------
  |  Branch (77:9): [True: 1.28M, False: 25.6k]
  ------------------
   78|  1.28M|      ++pieces_size;
   79|  1.28M|    } else {
   80|  25.6k|      ++reserved_id_map_size;
   81|  25.6k|    }
   82|  1.31M|  }
   83|  3.17k|  pieces_.reserve(pieces_size);
   84|  3.17k|  reserved_id_map_.reserve(reserved_id_map_size);
   85|       |
   86|  47.0k|  for (int i = 0; i < model_proto_->pieces_size(); ++i) {
  ------------------
  |  Branch (86:19): [True: 44.8k, False: 2.23k]
  ------------------
   87|  44.8k|    const auto &sp = model_proto_->pieces(i);
   88|  44.8k|    if (sp.piece().empty()) {
  ------------------
  |  Branch (88:9): [True: 48, False: 44.7k]
  ------------------
   89|     48|      status_ = util::InternalError("piece must not be empty.");
   90|     48|      return;
   91|     48|    }
   92|  44.7k|    if (sp.piece().find('\0') != absl::string_view::npos) {
  ------------------
  |  Branch (92:9): [True: 850, False: 43.9k]
  ------------------
   93|    850|      status_ = util::InternalError("piece must not include null character.");
   94|    850|      return;
   95|    850|    }
   96|  43.9k|    const bool is_normal_piece =
   97|  43.9k|        (sp.type() == ModelProto::SentencePiece::NORMAL ||
  ------------------
  |  Branch (97:10): [True: 22.6k, False: 21.2k]
  ------------------
   98|  21.2k|         sp.type() == ModelProto::SentencePiece::USER_DEFINED ||
  ------------------
  |  Branch (98:10): [True: 602, False: 20.6k]
  ------------------
   99|  20.6k|         sp.type() == ModelProto::SentencePiece::UNUSED);
  ------------------
  |  Branch (99:10): [True: 48, False: 20.5k]
  ------------------
  100|  43.9k|    if (!port::InsertIfNotPresent(
  ------------------
  |  Branch (100:9): [True: 10, False: 43.9k]
  ------------------
  101|  43.9k|            is_normal_piece ? &pieces_ : &reserved_id_map_, sp.piece(), i)) {
  ------------------
  |  Branch (101:13): [True: 23.3k, False: 20.5k]
  ------------------
  102|     10|      status_ = util::InternalError(sp.piece() + " is already defined.");
  103|     10|      return;
  104|     10|    }
  105|       |
  106|  43.9k|    if (sp.type() == ModelProto::SentencePiece::USER_DEFINED) {
  ------------------
  |  Branch (106:9): [True: 602, False: 43.3k]
  ------------------
  107|    602|      user_defined_symbols.insert(sp.piece());
  108|    602|    }
  109|       |
  110|  43.9k|    if (sp.type() == ModelProto::SentencePiece::UNKNOWN) {
  ------------------
  |  Branch (110:9): [True: 2.96k, False: 40.9k]
  ------------------
  111|  2.96k|      if (unk_id_ >= 0) {
  ------------------
  |  Branch (111:11): [True: 2, False: 2.96k]
  ------------------
  112|      2|        status_ = util::InternalError("unk is already defined.");
  113|      2|        return;
  114|      2|      }
  115|  2.96k|      unk_id_ = i;
  116|  2.96k|    }
  117|       |
  118|  43.9k|    if (sp.type() == ModelProto::SentencePiece::BYTE) {
  ------------------
  |  Branch (118:9): [True: 14.7k, False: 29.1k]
  ------------------
  119|  14.7k|      if (!model_proto_->trainer_spec().byte_fallback()) {
  ------------------
  |  Branch (119:11): [True: 6, False: 14.7k]
  ------------------
  120|      6|        status_ =
  121|      6|            util::InternalError("byte piece " + sp.piece() +
  122|      6|                                " is found although `byte_fallback` is false.");
  123|      6|        return;
  124|      6|      }
  125|  14.7k|      const int byte = PieceToByte(sp.piece());
  126|  14.7k|      if (0 <= byte && byte < 256) {
  ------------------
  |  Branch (126:11): [True: 14.7k, False: 32]
  |  Branch (126:24): [True: 14.7k, False: 0]
  ------------------
  127|  14.7k|        byte_found[byte] = true;
  128|  14.7k|      } else {
  129|     32|        status_ =
  130|     32|            util::InternalError("byte piece " + sp.piece() + " is invalid.");
  131|     32|        return;
  132|     32|      }
  133|  14.7k|    }
  134|  43.9k|  }
  135|       |
  136|  2.23k|  if (unk_id_ == -1) {
  ------------------
  |  Branch (136:7): [True: 107, False: 2.12k]
  ------------------
  137|    107|    status_ = util::InternalError("unk is not defined.");
  138|    107|    return;
  139|    107|  }
  140|       |
  141|  2.12k|  if (model_proto_->trainer_spec().byte_fallback()) {
  ------------------
  |  Branch (141:7): [True: 67, False: 2.05k]
  ------------------
  142|       |    // Checks that there are 256 byte pieces.
  143|     67|    if (std::find(byte_found.begin(), byte_found.end(), false) !=
  ------------------
  |  Branch (143:9): [True: 39, False: 28]
  ------------------
  144|     67|        byte_found.end()) {
  145|     39|      status_ = util::InternalError(
  146|     39|          "there are not 256 byte pieces although `byte_fallback` is true.");
  147|     39|      return;
  148|     39|    }
  149|     67|  }
  150|       |
  151|  2.08k|  matcher_ = std::make_unique<normalizer::PrefixMatcher>(user_defined_symbols);
  152|  2.08k|}
_ZN13sentencepiece14SplitIntoWordsENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEbb:
  156|    761|                                              bool allow_ws_only_pieces) {
  157|    761|  const char *begin = text.data();
  158|    761|  const char *end = text.data() + text.size();
  159|       |
  160|       |  // Space symbol (U+2581)
  161|    761|  constexpr absl::string_view kSpaceSymbol = "\xe2\x96\x81";
  162|    761|  bool in_ws_sequence = false;
  163|       |
  164|    761|  std::vector<absl::string_view> result;
  165|    761|  if (treat_ws_as_suffix) {  // put ws tokens at the end of non-ws sequences.
  ------------------
  |  Branch (165:7): [True: 0, False: 761]
  ------------------
  166|      0|    if (begin < end) result.emplace_back(begin, 0);
  ------------------
  |  Branch (166:9): [True: 0, False: 0]
  ------------------
  167|      0|    while (begin < end) {
  ------------------
  |  Branch (167:12): [True: 0, False: 0]
  ------------------
  168|      0|      const int mblen =
  169|      0|          std::min<int>(string_util::OneCharLen(begin), end - begin);
  170|      0|      const bool is_ws = absl::string_view(begin, mblen) == kSpaceSymbol;
  171|       |
  172|      0|      if (is_ws) {  // keep track of sequences consecutive ws tokens.
  ------------------
  |  Branch (172:11): [True: 0, False: 0]
  ------------------
  173|      0|        in_ws_sequence = true;
  174|      0|      } else if (in_ws_sequence) {
  ------------------
  |  Branch (174:18): [True: 0, False: 0]
  ------------------
  175|      0|        if (allow_ws_only_pieces) result.emplace_back(begin, 0);
  ------------------
  |  Branch (175:13): [True: 0, False: 0]
  ------------------
  176|       |
  177|      0|        in_ws_sequence = false;
  178|      0|      }
  179|       |
  180|      0|      result.back() =
  181|      0|          absl::string_view(result.back().data(), result.back().size() + mblen);
  182|      0|      begin += mblen;
  183|       |
  184|      0|      if (begin < end && is_ws && !allow_ws_only_pieces)
  ------------------
  |  Branch (184:11): [True: 0, False: 0]
  |  Branch (184:26): [True: 0, False: 0]
  |  Branch (184:35): [True: 0, False: 0]
  ------------------
  185|      0|        result.emplace_back(begin, 0);
  186|      0|    }
  187|    761|  } else {
  188|  19.0M|    while (begin < end) {
  ------------------
  |  Branch (188:12): [True: 19.0M, False: 761]
  ------------------
  189|  19.0M|      const int mblen =
  190|  19.0M|          std::min<int>(string_util::OneCharLen(begin), end - begin);
  191|  19.0M|      bool is_ws = absl::string_view(begin, mblen) == kSpaceSymbol;
  192|       |
  193|       |      // if is whitespace (and not in sequence if allow_ws_only_pieces is True)
  194|  19.0M|      if (begin == text.data() ||
  ------------------
  |  Branch (194:11): [True: 761, False: 19.0M]
  ------------------
  195|  19.0M|          (is_ws && (!in_ws_sequence || !allow_ws_only_pieces))) {
  ------------------
  |  Branch (195:12): [True: 106k, False: 18.9M]
  |  Branch (195:22): [True: 104k, False: 1.68k]
  |  Branch (195:41): [True: 1.68k, False: 0]
  ------------------
  196|   107k|        result.emplace_back(begin, 0);  // add empty string piece.
  197|   107k|        in_ws_sequence = true;
  198|   107k|      }
  199|       |
  200|  19.0M|      if (in_ws_sequence && !is_ws) in_ws_sequence = false;
  ------------------
  |  Branch (200:11): [True: 212k, False: 18.8M]
  |  Branch (200:29): [True: 105k, False: 107k]
  ------------------
  201|       |
  202|  19.0M|      result.back() =
  203|  19.0M|          absl::string_view(result.back().data(), result.back().size() + mblen);
  204|  19.0M|      begin += mblen;
  205|  19.0M|    }
  206|    761|  }
  207|       |
  208|    761|  return result;
  209|    761|}
_ZN13sentencepiece11ByteToPieceEh:
  211|  1.62k|std::string ByteToPiece(unsigned char c) {
  212|  1.62k|  return absl::StrFormat("<0x%02X>", c);
  213|  1.62k|}
_ZN13sentencepiece11PieceToByteENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  215|  15.3k|int PieceToByte(absl::string_view piece) {
  216|  15.3k|  using PieceToByteMap = absl::flat_hash_map<std::string, unsigned char>;
  217|  15.3k|  static const auto *const kMap = []() -> PieceToByteMap * {
  218|  15.3k|    auto *m = new PieceToByteMap();
  219|  15.3k|    for (int i = 0; i < 256; ++i) {
  220|  15.3k|      (*m)[ByteToPiece(i)] = i;
  221|  15.3k|    }
  222|  15.3k|    return m;
  223|  15.3k|  }();
  224|       |
  225|  15.3k|  if (const auto it = kMap->find(piece); it != kMap->end()) {
  ------------------
  |  Branch (225:42): [True: 15.3k, False: 32]
  ------------------
  226|  15.3k|    return it->second;
  227|  15.3k|  }
  228|       |
  229|     32|  return -1;
  230|  15.3k|}
model_interface.cc:_ZZN13sentencepiece11PieceToByteENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEENK3$_0clEv:
  217|      1|  static const auto *const kMap = []() -> PieceToByteMap * {
  218|      1|    auto *m = new PieceToByteMap();
  219|    257|    for (int i = 0; i < 256; ++i) {
  ------------------
  |  Branch (219:21): [True: 256, False: 1]
  ------------------
  220|    256|      (*m)[ByteToPiece(i)] = i;
  221|    256|    }
  222|      1|    return m;
  223|      1|  }();

_ZN13sentencepiece14ModelInterfaceC2Ev:
   65|  3.17k|  ModelInterface() {}
_ZNK13sentencepiece14ModelInterface6statusEv:
   71|   142M|  virtual util::Status status() const { return status_; }
_ZNK13sentencepiece14ModelInterface14prefix_matcherEv:
   75|  3.17k|  virtual const normalizer::PrefixMatcher *prefix_matcher() const {
   76|  3.17k|    return matcher_.get();
   77|  3.17k|  }
_ZNK13sentencepiece14ModelInterface23IsSampleEncodeAvailableEv:
  120|    754|  virtual bool IsSampleEncodeAvailable() const { return false; }
_ZNK13sentencepiece14ModelInterface22IsNBestEncodeAvailableEv:
  123|  1.13k|  virtual bool IsNBestEncodeAvailable() const { return false; }
_ZNK13sentencepiece14ModelInterface9IdToPieceEi:
  137|  2.25M|  virtual const std::string &IdToPiece(int id) const {
  138|  2.25M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|  2.25M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|  2.25M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  2.25M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 2.25M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  2.25M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  139|  2.25M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|  2.25M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|  2.25M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  2.25M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 2.25M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  2.25M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  140|  2.25M|    return model_proto_->pieces(id).piece();
  141|  2.25M|  }
_ZNK13sentencepiece14ModelInterface12GetPieceSizeEv:
  145|  6.12M|  virtual int GetPieceSize() const {
  146|  6.12M|    if (!model_proto_) return 0;
  ------------------
  |  Branch (146:9): [True: 0, False: 6.12M]
  ------------------
  147|  6.12M|    return model_proto_->pieces_size();
  148|  6.12M|  }
_ZNK13sentencepiece14ModelInterface8GetScoreEi:
  153|  10.4k|  virtual float GetScore(int id) const {
  154|  10.4k|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|  10.4k|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|  10.4k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  10.4k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 10.4k]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  10.4k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  155|  10.4k|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|  10.4k|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|  10.4k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  10.4k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 10.4k]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  10.4k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  156|  10.4k|    return model_proto_->pieces(id).score();
  157|  10.4k|  }
_ZNK13sentencepiece14ModelInterface9IsUnknownEi:
  160|  66.8M|  virtual bool IsUnknown(int id) const {
  161|  66.8M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|  66.8M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|  66.8M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  66.8M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 66.8M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  66.8M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  162|  66.8M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|  66.8M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|  66.8M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  66.8M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 66.8M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  66.8M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  163|  66.8M|    return (model_proto_->pieces(id).type() ==
  164|  66.8M|            ModelProto::SentencePiece::UNKNOWN);
  165|  66.8M|  }
_ZNK13sentencepiece14ModelInterface9IsControlEi:
  168|  66.8M|  virtual bool IsControl(int id) const {
  169|  66.8M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|  66.8M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|  66.8M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  66.8M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 66.8M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  66.8M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  170|  66.8M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|  66.8M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|  66.8M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  66.8M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 66.8M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  66.8M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  171|  66.8M|    return (model_proto_->pieces(id).type() ==
  172|  66.8M|            ModelProto::SentencePiece::CONTROL);
  173|  66.8M|  }
_ZNK13sentencepiece14ModelInterface8IsUnusedEi:
  176|  10.4k|  virtual bool IsUnused(int id) const {
  177|  10.4k|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|  10.4k|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|  10.4k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  10.4k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 10.4k]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  10.4k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  178|  10.4k|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|  10.4k|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|  10.4k|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  10.4k|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 10.4k]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  10.4k|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  179|  10.4k|    return (model_proto_->pieces(id).type() ==
  180|  10.4k|            ModelProto::SentencePiece::UNUSED);
  181|  10.4k|  }
_ZNK13sentencepiece14ModelInterface6IsByteEi:
  192|  3.14M|  virtual bool IsByte(int id) const {
  193|  3.14M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|  3.14M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|  3.14M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  3.14M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 3.14M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  3.14M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  194|  3.14M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|  3.14M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|  3.14M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  3.14M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 3.14M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  3.14M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  195|  3.14M|    return (model_proto_->pieces(id).type() == ModelProto::SentencePiece::BYTE);
  196|  3.14M|  }
_ZNK13sentencepiece14ModelInterface19ByteFallbackEnabledEv:
  198|  46.4M|  virtual bool ByteFallbackEnabled() const {
  199|  46.4M|    return model_proto_ && model_proto_->trainer_spec().byte_fallback();
  ------------------
  |  Branch (199:12): [True: 46.4M, False: 0]
  |  Branch (199:28): [True: 500, False: 46.4M]
  ------------------
  200|  46.4M|  }
_ZNK13sentencepiece14ModelInterface23VerifyOutputsEquivalentENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
  208|     19|                                       absl::string_view actual) const {
  209|     19|    return expected == actual;
  210|     19|  }
_ZNK13sentencepiece14ModelInterface15GetScoreInlinedEi:
  216|  6.89M|  inline float GetScoreInlined(int id) const {
  217|  6.89M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|  6.89M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|  6.89M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  6.89M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 6.89M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  6.89M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  218|  6.89M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|  6.89M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|  6.89M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  6.89M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 6.89M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  6.89M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  219|  6.89M|    return model_proto_->pieces(id).score();
  220|  6.89M|  }
_ZNK13sentencepiece14ModelInterface15IsUnusedInlinedEi:
  236|  8.16M|  inline bool IsUnusedInlined(int id) const {
  237|  8.16M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|  8.16M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|  8.16M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  8.16M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 8.16M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  8.16M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  238|  8.16M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|  8.16M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|  8.16M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  8.16M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 8.16M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  8.16M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  239|  8.16M|    return (model_proto_->pieces(id).type() ==
  240|  8.16M|            ModelProto::SentencePiece::UNUSED);
  241|  8.16M|  }
_ZNK13sentencepiece14ModelInterface20IsUserDefinedInlinedEi:
  243|  7.34M|  inline bool IsUserDefinedInlined(int id) const {
  244|  7.34M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|  7.34M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|  7.34M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  7.34M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 7.34M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  7.34M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  245|  7.34M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|  7.34M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|  7.34M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|  7.34M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 7.34M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|  7.34M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  246|  7.34M|    return (model_proto_->pieces(id).type() ==
  247|  7.34M|            ModelProto::SentencePiece::USER_DEFINED);
  248|  7.34M|  }

_ZN13sentencepiece10normalizer10NormalizerC2ERKNS_14NormalizerSpecERKNS_11TrainerSpecE:
   35|  3.17k|    : spec_(&spec),
   36|  3.17k|      treat_whitespace_as_suffix_(trainer_spec.treat_whitespace_as_suffix()),
   37|  3.17k|      status_(util::OkStatus()) {
   38|  3.17k|  Init();
   39|  3.17k|}
_ZN13sentencepiece10normalizer10NormalizerC2ERKNS_14NormalizerSpecE:
   42|     17|    : spec_(&spec), status_(util::OkStatus()) {
   43|     17|  Init();
   44|     17|}
_ZN13sentencepiece10normalizer10NormalizerD2Ev:
   46|  3.19k|Normalizer::~Normalizer() {}
_ZN13sentencepiece10normalizer10Normalizer4InitEv:
   48|  3.19k|void Normalizer::Init() {
   49|  3.19k|  absl::string_view index = spec_->precompiled_charsmap();
   50|       |
   51|  3.19k|  if (!index.empty()) {
  ------------------
  |  Branch (51:7): [True: 21, False: 3.17k]
  ------------------
   52|     21|    absl::string_view trie_blob;
   53|     21|    status_ = DecodePrecompiledCharsMap(index, &trie_blob, &normalized_,
   54|     21|                                        &precompiled_charsmap_buffer_);
   55|       |
   56|     21|    if (!status_.ok()) return;
  ------------------
  |  Branch (56:9): [True: 21, False: 0]
  ------------------
   57|       |
   58|       |    // Reads the body of double array.
   59|      0|    trie_ = std::make_unique<Darts::DoubleArray>();
   60|       |
   61|       |    // The second arg of set_array is not the size of blob,
   62|       |    // but the number of double array units.
   63|      0|    trie_->set_array(const_cast<char *>(trie_blob.data()),
   64|      0|                     trie_blob.size() / trie_->unit_size());
   65|       |
   66|      0|    if (!trie_->validate()) {
  ------------------
  |  Branch (66:9): [True: 0, False: 0]
  ------------------
   67|      0|      status_ = util::InternalError(
   68|      0|          "Trie data contains out-of-bounds node references.");
   69|      0|      return;
   70|      0|    }
   71|      0|  }
   72|  3.19k|}
_ZNK13sentencepiece10normalizer10Normalizer9NormalizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEEPNS2_6vectorImNS8_ImEEEE:
   76|  14.5k|                                   std::vector<size_t> *norm_to_orig) const {
   77|  14.5k|  if (norm_to_orig) norm_to_orig->clear();
  ------------------
  |  Branch (77:7): [True: 10.4k, False: 4.08k]
  ------------------
   78|  14.5k|  normalized->clear();
   79|       |
   80|  14.5k|  if (input.empty()) {
  ------------------
  |  Branch (80:7): [True: 461, False: 14.0k]
  ------------------
   81|    461|    return util::OkStatus();
   82|    461|  }
   83|       |
   84|  14.0k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  14.0k|  do {                                 \
  |  |   45|  14.0k|    const auto _status = expr;         \
  |  |   46|  14.0k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 18, False: 14.0k]
  |  |  ------------------
  |  |   47|  14.0k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 14.0k]
  |  |  ------------------
  ------------------
   85|       |
   86|  14.0k|  size_t consumed = 0;
   87|       |
   88|       |  // Ignores heading space.
   89|  14.0k|  if (spec_->remove_extra_whitespaces()) {
  ------------------
  |  Branch (89:7): [True: 14.0k, False: 63]
  ------------------
   90|  19.9k|    while (!input.empty()) {
  ------------------
  |  Branch (90:12): [True: 19.8k, False: 154]
  ------------------
   91|  19.8k|      const auto p = NormalizePrefix(input);
   92|  19.8k|      if (p.first != " ") {
  ------------------
  |  Branch (92:11): [True: 13.8k, False: 5.95k]
  ------------------
   93|  13.8k|        break;
   94|  13.8k|      }
   95|  5.95k|      input.remove_prefix(p.second);
   96|  5.95k|      consumed += p.second;
   97|  5.95k|    }
   98|  14.0k|  }
   99|       |
  100|       |  // all chars are whitespace.
  101|  14.0k|  if (input.empty()) {
  ------------------
  |  Branch (101:7): [True: 154, False: 13.9k]
  ------------------
  102|    154|    return util::OkStatus();
  103|    154|  }
  104|       |
  105|       |  // Reserves the output buffer to avoid re-allocations.
  106|  13.9k|  const size_t kReservedSize = input.size() * 1.5;
  107|  13.9k|  normalized->reserve(kReservedSize);
  108|  13.9k|  if (norm_to_orig) norm_to_orig->reserve(kReservedSize);
  ------------------
  |  Branch (108:7): [True: 10.0k, False: 3.90k]
  ------------------
  109|       |
  110|       |  // Replaces white space with U+2581 (LOWER ONE EIGHT BLOCK)
  111|       |  // if escape_whitespaces() is set (default = true).
  112|  13.9k|  const absl::string_view kSpaceSymbol =
  113|  13.9k|      spec_->escape_whitespaces() ? "\xe2\x96\x81" : " ";
  ------------------
  |  Branch (113:7): [True: 13.8k, False: 77]
  ------------------
  114|       |
  115|       |  // adds kSpaceSymbol to the current context.
  116|  13.9k|  auto add_ws = [&consumed, &normalized, &norm_to_orig, &kSpaceSymbol]() {
  117|  13.9k|    normalized->append(kSpaceSymbol.data(), kSpaceSymbol.size());
  118|  13.9k|    if (norm_to_orig) {
  119|  13.9k|      for (size_t n = 0; n < kSpaceSymbol.size(); ++n) {
  120|  13.9k|        norm_to_orig->push_back(consumed);
  121|  13.9k|      }
  122|  13.9k|    }
  123|  13.9k|  };
  124|       |
  125|       |  // Adds a space symbol as a prefix (default is true)
  126|       |  // With this prefix, "world" and "hello world" are converted into
  127|       |  // "_world" and "_hello_world", which help the trainer to extract
  128|       |  // "_world" as one symbol.
  129|  13.9k|  if (!treat_whitespace_as_suffix_ && spec_->add_dummy_prefix()) add_ws();
  ------------------
  |  Branch (129:7): [True: 13.9k, False: 7]
  |  Branch (129:39): [True: 13.8k, False: 21]
  ------------------
  130|       |
  131|  13.9k|  bool is_prev_space = spec_->remove_extra_whitespaces();
  132|   121M|  while (!input.empty()) {
  ------------------
  |  Branch (132:10): [True: 121M, False: 13.9k]
  ------------------
  133|   121M|    auto p = NormalizePrefix(input);
  134|   121M|    absl::string_view sp = p.first;
  135|       |
  136|       |    // Removes heading spaces in sentence piece,
  137|       |    // if the previous sentence piece ends with whitespace.
  138|   122M|    while (is_prev_space && absl::ConsumePrefix(&sp, " ")) {
  ------------------
  |  Branch (138:12): [True: 1.66M, False: 120M]
  |  Branch (138:29): [True: 536k, False: 1.12M]
  ------------------
  139|   536k|    }
  140|       |
  141|   121M|    if (!sp.empty()) {
  ------------------
  |  Branch (141:9): [True: 121M, False: 536k]
  ------------------
  142|   121M|      const char *data = sp.data();
  143|   287M|      for (size_t n = 0; n < sp.size(); ++n) {
  ------------------
  |  Branch (143:26): [True: 166M, False: 121M]
  ------------------
  144|   166M|        if (data[n] == ' ') {
  ------------------
  |  Branch (144:13): [True: 578k, False: 165M]
  ------------------
  145|   578k|          add_ws();
  146|   165M|        } else {
  147|   165M|          *normalized += data[n];
  148|   165M|          if (norm_to_orig) norm_to_orig->push_back(consumed);
  ------------------
  |  Branch (148:15): [True: 118M, False: 47.3M]
  ------------------
  149|   165M|        }
  150|   166M|      }
  151|       |      // Checks whether the last character of sp is whitespace.
  152|   121M|      is_prev_space = absl::EndsWith(sp, " ");
  153|   121M|    }
  154|       |
  155|   121M|    consumed += p.second;
  156|   121M|    input.remove_prefix(p.second);
  157|   121M|    if (!spec_->remove_extra_whitespaces()) {
  ------------------
  |  Branch (157:9): [True: 7.30k, False: 121M]
  ------------------
  158|  7.30k|      is_prev_space = false;
  159|  7.30k|    }
  160|   121M|  }
  161|       |
  162|       |  // Ignores trailing space.
  163|  13.9k|  if (spec_->remove_extra_whitespaces()) {
  ------------------
  |  Branch (163:7): [True: 13.8k, False: 63]
  ------------------
  164|  14.6k|    while (absl::EndsWith(*normalized, kSpaceSymbol)) {
  ------------------
  |  Branch (164:12): [True: 836, False: 13.8k]
  ------------------
  165|    836|      const int length = normalized->size() - kSpaceSymbol.size();
  166|    836|      RET_CHECK_GE(length, 0);
  ------------------
  |  |  329|    836|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  321|    836|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 836, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|    836|  } else /* NOLINT */                                        \
  |  |  |  |  323|    836|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  167|    836|      normalized->resize(length);
  168|    836|      if (norm_to_orig) {
  ------------------
  |  Branch (168:11): [True: 598, False: 238]
  ------------------
  169|    598|        consumed = (*norm_to_orig)[length];
  170|    598|        norm_to_orig->resize(length);
  171|    598|      }
  172|    836|    }
  173|  13.8k|  }
  174|       |
  175|       |  // Adds a space symbol as a suffix (default is false)
  176|  13.9k|  if (treat_whitespace_as_suffix_ && spec_->add_dummy_prefix()) add_ws();
  ------------------
  |  Branch (176:7): [True: 7, False: 13.9k]
  |  Branch (176:38): [True: 7, False: 0]
  ------------------
  177|       |
  178|  13.9k|  if (norm_to_orig) {
  ------------------
  |  Branch (178:7): [True: 10.0k, False: 3.90k]
  ------------------
  179|  10.0k|    norm_to_orig->push_back(consumed);
  180|  10.0k|    RET_CHECK_EQ(norm_to_orig->size(), normalized->size() + 1);
  ------------------
  |  |  327|  10.0k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|  10.0k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 10.0k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  10.0k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  10.0k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  181|  10.0k|  }
  182|       |
  183|  13.9k|  return util::OkStatus();
  184|  13.9k|}
_ZNK13sentencepiece10normalizer10Normalizer9NormalizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  186|     18|std::string Normalizer::Normalize(absl::string_view input) const {
  187|     18|  std::string normalized;
  188|     18|  Normalize(input, &normalized, nullptr).IgnoreError();
  189|     18|  return normalized;
  190|     18|}
_ZNK13sentencepiece10normalizer10Normalizer15NormalizePrefixENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  193|   121M|    absl::string_view input) const {
  194|   121M|  if (input.empty()) return {};
  ------------------
  |  Branch (194:7): [True: 0, False: 121M]
  ------------------
  195|       |
  196|   121M|  if (matcher_ != nullptr) {
  ------------------
  |  Branch (196:7): [True: 121M, False: 0]
  ------------------
  197|   121M|    bool found = false;
  198|   121M|    const int mblen = matcher_->PrefixMatch(input, &found);
  199|   121M|    if (found) return {input.substr(0, mblen), mblen};
  ------------------
  |  Branch (199:9): [True: 518k, False: 121M]
  ------------------
  200|   121M|  }
  201|       |
  202|   121M|  size_t longest_length = 0;
  203|   121M|  size_t longest_value = 0;
  204|       |
  205|   121M|  if (trie_ != nullptr) {
  ------------------
  |  Branch (205:7): [True: 0, False: 121M]
  ------------------
  206|       |    // Allocates trie_results in stack, which makes the encoding speed 36%
  207|       |    // faster. (38k sentences/sec => 60k sentences/sec). Builder checks that the
  208|       |    // result size never exceeds kMaxTrieResultsSize. This array consumes
  209|       |    // 0.5kByte in stack, which is less than default stack frames (16kByte).
  210|      0|    Darts::DoubleArray::result_pair_type
  211|      0|        trie_results[Normalizer::kMaxTrieResultsSize];
  212|       |
  213|      0|    const size_t num_nodes = trie_->commonPrefixSearch(
  214|      0|        input.data(), trie_results, Normalizer::kMaxTrieResultsSize,
  215|      0|        input.size());
  216|       |
  217|       |    // Finds the longest rule.
  218|      0|    for (size_t k = 0; k < num_nodes; ++k) {
  ------------------
  |  Branch (218:24): [True: 0, False: 0]
  ------------------
  219|      0|      if (longest_length == 0 || trie_results[k].length > longest_length) {
  ------------------
  |  Branch (219:11): [True: 0, False: 0]
  |  Branch (219:34): [True: 0, False: 0]
  ------------------
  220|      0|        longest_length = trie_results[k].length;  // length of prefix
  221|      0|        longest_value = trie_results[k].value;    // pointer to |normalized_|.
  222|      0|      }
  223|      0|    }
  224|      0|  }
  225|       |
  226|   121M|  std::pair<absl::string_view, int> result;
  227|   121M|  if (longest_length == 0 || longest_length > input.size() ||
  ------------------
  |  Branch (227:7): [True: 121M, False: 0]
  |  Branch (227:30): [True: 0, False: 0]
  ------------------
  228|   121M|      longest_value >= normalized_.size()) {
  ------------------
  |  Branch (228:7): [True: 0, False: 0]
  ------------------
  229|   121M|    size_t length = 0;
  230|   121M|    if (!string_util::IsValidDecodeUTF8(input, &length)) {
  ------------------
  |  Branch (230:9): [True: 20.3M, False: 100M]
  ------------------
  231|       |      // Found a malformed utf8.
  232|       |      // The rune is set to be 0xFFFD (REPLACEMENT CHARACTER),
  233|       |      // which is a valid Unicode of three bytes in utf8,
  234|       |      // but here we only consume one byte.
  235|  20.3M|      result.second = 1;
  236|  20.3M|      static constexpr absl::string_view kReplacementChar = "\xEF\xBF\xBD";
  237|  20.3M|      result.first = kReplacementChar;
  238|   100M|    } else {
  239|   100M|      result.second = length;
  240|   100M|      result.first = absl::string_view(input.data(), result.second);
  241|   100M|    }
  242|   121M|  } else {
  243|      0|    result.second = longest_length;
  244|       |    // No need to pass the size of normalized sentence,
  245|       |    // since |normalized| is delimitered by "\0".
  246|      0|    result.first = normalized_.data() + longest_value;
  247|      0|  }
  248|       |
  249|   121M|  return result;
  250|   121M|}
_ZN13sentencepiece10normalizer10Normalizer25DecodePrecompiledCharsMapENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPS6_S7_PNS2_12basic_stringIcS5_NS2_9allocatorIcEEEE:
  273|     21|    absl::string_view *normalized, std::string *buffer) {
  274|     21|  uint32_t trie_blob_size = 0;
  275|     21|  if (blob.size() <= sizeof(trie_blob_size) ||
  ------------------
  |  Branch (275:7): [True: 1, False: 20]
  ------------------
  276|     20|      !string_util::DecodePOD<uint32_t>(
  ------------------
  |  Branch (276:7): [True: 0, False: 20]
  ------------------
  277|     20|          absl::string_view(blob.data(), sizeof(trie_blob_size)),
  278|     20|          &trie_blob_size)) {
  279|      1|    return util::InternalError("Blob for normalization rule is broken.");
  280|      1|  }
  281|       |
  282|       |  if constexpr (util::is_bigendian()) {
  283|       |    trie_blob_size = util::Swap32(trie_blob_size);
  284|       |  }
  285|       |
  286|     20|  if (trie_blob_size >= blob.size()) {
  ------------------
  |  Branch (286:7): [True: 18, False: 2]
  ------------------
  287|     18|    return util::InternalError("Trie data size exceeds the input blob size.");
  288|     18|  }
  289|       |
  290|       |  // Dart unit_size is 4 and blob size in units must be a multiple of 256.
  291|      2|  if (trie_blob_size < 1024 || (trie_blob_size & 0x3FF) != 0) {
  ------------------
  |  Branch (291:7): [True: 2, False: 0]
  |  Branch (291:32): [True: 0, False: 0]
  ------------------
  292|      2|    return util::InternalError("Trie data size is not divisible by 1024.");
  293|      2|  }
  294|       |
  295|      0|  blob.remove_prefix(sizeof(trie_blob_size));
  296|       |
  297|       |  if constexpr (util::is_bigendian()) {
  298|       |    RET_CHECK(buffer);
  299|       |    buffer->assign(blob.data(), trie_blob_size);
  300|       |    uint32_t *data =
  301|       |        reinterpret_cast<uint32_t *>(const_cast<char *>(buffer->data()));
  302|       |    for (int i = 0; i < buffer->size() / 4; ++i)
  303|       |      data[i] = util::Swap32(data[i]);
  304|       |    *trie_blob = absl::string_view(buffer->data(), trie_blob_size);
  305|      0|  } else {
  306|      0|    *trie_blob = absl::string_view(blob.data(), trie_blob_size);
  307|      0|  }
  308|       |
  309|      0|  blob.remove_prefix(trie_blob_size);
  310|      0|  *normalized = absl::string_view(blob.data(), blob.size());
  311|       |
  312|      0|  if (normalized->empty() || normalized->back() != '\0') {
  ------------------
  |  Branch (312:7): [True: 0, False: 0]
  |  Branch (312:30): [True: 0, False: 0]
  ------------------
  313|      0|    return util::InternalError("normalized block must be null terminated.");
  314|      0|  }
  315|       |
  316|      0|  return util::OkStatus();
  317|      0|}
_ZN13sentencepiece10normalizer13PrefixMatcherC2ERKNSt3__13setINS2_17basic_string_viewIcNS2_11char_traitsIcEEEENS2_4lessIS7_EENS2_9allocatorIS7_EEEE:
  319|  2.08k|PrefixMatcher::PrefixMatcher(const std::set<absl::string_view> &dic) {
  320|  2.08k|  if (dic.empty()) return;
  ------------------
  |  Branch (320:7): [True: 1.66k, False: 423]
  ------------------
  321|    423|  std::vector<const char *> key;
  322|    423|  std::vector<size_t> lengths;
  323|    423|  key.reserve(dic.size());
  324|    423|  lengths.reserve(dic.size());
  325|    526|  for (const auto &it : dic) {
  ------------------
  |  Branch (325:23): [True: 526, False: 423]
  ------------------
  326|    526|    key.push_back(it.data());
  327|    526|    lengths.push_back(it.size());
  328|    526|  }
  329|    423|  trie_ = std::make_unique<Darts::DoubleArray>();
  330|    423|  if (trie_->build(key.size(), const_cast<char **>(key.data()),
  ------------------
  |  Branch (330:7): [True: 0, False: 423]
  ------------------
  331|    423|                   const_cast<size_t *>(lengths.data()), nullptr) != 0) {
  332|      0|    LOG(ERROR) << "Failed to build the TRIE for PrefixMatcher";
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  333|      0|    trie_.reset();
  334|      0|  }
  335|    423|}
_ZNK13sentencepiece10normalizer13PrefixMatcher11PrefixMatchENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPb:
  337|   125M|int PrefixMatcher::PrefixMatch(absl::string_view w, bool *found) const {
  338|   125M|  if (trie_ == nullptr) {
  ------------------
  |  Branch (338:7): [True: 116M, False: 9.55M]
  ------------------
  339|   116M|    if (found) *found = false;
  ------------------
  |  Branch (339:9): [True: 113M, False: 3.35M]
  ------------------
  340|   116M|    return std::min<int>(w.size(), string_util::OneCharLen(w.data()));
  341|   116M|  }
  342|       |
  343|  9.55M|  constexpr int kResultSize = 64;
  344|  9.55M|  Darts::DoubleArray::result_pair_type trie_results[kResultSize];
  345|  9.55M|  const int num_nodes =
  346|  9.55M|      trie_->commonPrefixSearch(w.data(), trie_results, kResultSize, w.size());
  347|       |
  348|  9.55M|  if (found) *found = (num_nodes > 0);
  ------------------
  |  Branch (348:7): [True: 9.48M, False: 67.0k]
  ------------------
  349|  9.55M|  if (num_nodes == 0) {
  ------------------
  |  Branch (349:7): [True: 9.03M, False: 518k]
  ------------------
  350|  9.03M|    return std::min<int>(w.size(), string_util::OneCharLen(w.data()));
  351|  9.03M|  }
  352|       |
  353|   518k|  int mblen = 0;
  354|  1.03M|  for (int i = 0; i < num_nodes; ++i) {
  ------------------
  |  Branch (354:19): [True: 518k, False: 518k]
  ------------------
  355|   518k|    mblen = std::max<int>(trie_results[i].length, mblen);
  356|   518k|  }
  357|       |
  358|   518k|  return mblen;
  359|  9.55M|}
normalizer.cc:_ZZNK13sentencepiece10normalizer10Normalizer9NormalizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEEPNS2_6vectorImNS8_ImEEEEENK3$_0clEv:
  116|   592k|  auto add_ws = [&consumed, &normalized, &norm_to_orig, &kSpaceSymbol]() {
  117|   592k|    normalized->append(kSpaceSymbol.data(), kSpaceSymbol.size());
  118|   592k|    if (norm_to_orig) {
  ------------------
  |  Branch (118:9): [True: 423k, False: 169k]
  ------------------
  119|  1.69M|      for (size_t n = 0; n < kSpaceSymbol.size(); ++n) {
  ------------------
  |  Branch (119:26): [True: 1.26M, False: 423k]
  ------------------
  120|  1.26M|        norm_to_orig->push_back(consumed);
  121|  1.26M|      }
  122|   423k|    }
  123|   592k|  };

_ZN13sentencepiece10normalizer10Normalizer16SetPrefixMatcherEPKNS0_13PrefixMatcherE:
   71|  3.17k|  virtual void SetPrefixMatcher(const PrefixMatcher *matcher) {
   72|  3.17k|    matcher_ = matcher;
   73|  3.17k|  }
_ZNK13sentencepiece10normalizer10Normalizer6statusEv:
   77|   142M|  virtual util::Status status() const { return status_; }

_ZN13sentencepiece26ImmutableSentencePieceTextC2Ev:
  107|  4.06k|    : spt_(&SentencePieceText::default_instance()) {}
_ZN13sentencepiece26ImmutableSentencePieceTextD2Ev:
  113|  4.06k|ImmutableSentencePieceText::~ImmutableSentencePieceText() {}
_ZN13sentencepiece26ImmutableSentencePieceText13mutable_protoEv:
  173|  4.06k|SentencePieceText *ImmutableSentencePieceText::mutable_proto() {
  174|  4.06k|  if (rep_ == nullptr) {
  ------------------
  |  Branch (174:7): [True: 4.06k, False: 0]
  ------------------
  175|  4.06k|    rep_ = std::make_shared<SentencePieceText>();
  176|  4.06k|    spt_ = rep_.get();
  177|  4.06k|  }
  178|  4.06k|  return rep_.get();
  179|  4.06k|}
_ZNK13sentencepiece26ImmutableSentencePieceText17SerializeAsStringEv:
  185|  4.06k|util::bytes ImmutableSentencePieceText::SerializeAsString() const {
  186|  4.06k|  return spt_->SerializeAsString();
  187|  4.06k|}
_ZN13sentencepiece22SentencePieceProcessorC2Ev:
  228|  7.70k|SentencePieceProcessor::SentencePieceProcessor() {}
_ZN13sentencepiece22SentencePieceProcessorD2Ev:
  229|  7.70k|SentencePieceProcessor::~SentencePieceProcessor() {}
_ZN13sentencepiece22SentencePieceProcessor23LoadFromSerializedProtoENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  248|  7.70k|    absl::string_view serialized) {
  249|  7.70k|  auto model_proto = std::make_unique<ModelProto>();
  250|  7.70k|  RET_CHECK(model_proto->ParseFromArray(serialized.data(), serialized.size()));
  ------------------
  |  |  321|  7.70k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 3.17k, False: 4.52k]
  |  |  ------------------
  |  |  322|  3.17k|  } else /* NOLINT */                                        \
  |  |  323|  7.70k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|  4.52k|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|  4.52k|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  251|  3.17k|  return Load(std::move(model_proto));
  252|  7.70k|}
_ZN13sentencepiece22SentencePieceProcessor4LoadENSt3__110unique_ptrINS_10ModelProtoENS1_14default_deleteIS3_EEEE:
  255|  3.17k|    std::unique_ptr<ModelProto> model_proto) {
  256|  3.17k|  model_proto_ = std::move(model_proto);
  257|  3.17k|  model_ = ModelFactory::Create(*model_proto_);
  258|  3.17k|  normalizer_ = std::make_unique<normalizer::Normalizer>(
  259|  3.17k|      model_proto_->normalizer_spec(), model_proto_->trainer_spec());
  260|  3.17k|  if (model_proto_->has_denormalizer_spec() &&
  ------------------
  |  Branch (260:7): [True: 126, False: 3.05k]
  ------------------
  261|    126|      !model_proto_->denormalizer_spec().precompiled_charsmap().empty()) {
  ------------------
  |  Branch (261:7): [True: 17, False: 109]
  ------------------
  262|     17|    denormalizer_ = std::make_unique<normalizer::Normalizer>(
  263|     17|        model_proto_->denormalizer_spec());
  264|     17|  }
  265|       |
  266|       |  // Escapes user-defined-symbols in normalizer.
  267|  3.17k|  normalizer_->SetPrefixMatcher(model_->prefix_matcher());
  268|       |
  269|  3.17k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  3.17k|  do {                                 \
  |  |   45|  3.17k|    const auto _status = expr;         \
  |  |   46|  3.17k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 1.09k, False: 2.08k]
  |  |  ------------------
  |  |   47|  3.17k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 2.08k]
  |  |  ------------------
  ------------------
  270|       |
  271|       |  // Running self-testing.
  272|  2.08k|  std::vector<std::string> errors, sps;
  273|  2.08k|  for (const auto &s : model_proto_->self_test_data().samples()) {
  ------------------
  |  Branch (273:22): [True: 301, False: 2.08k]
  ------------------
  274|    301|    RETURN_IF_ERROR(Encode(s.input(), &sps));
  ------------------
  |  |   44|    301|  do {                                 \
  |  |   45|    301|    const auto _status = expr;         \
  |  |   46|    301|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 301]
  |  |  ------------------
  |  |   47|    301|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 301]
  |  |  ------------------
  ------------------
  275|    301|    const std::string result = absl::StrJoin(sps, " ");
  276|    301|    if (!model_->VerifyOutputsEquivalent(s.expected(), result)) {
  ------------------
  |  Branch (276:9): [True: 128, False: 173]
  ------------------
  277|    128|      errors.emplace_back(
  278|    128|          absl::StrCat(s.input(), "\t", s.expected(), "\t", result));
  279|    128|    }
  280|    301|  }
  281|       |
  282|  2.08k|  if (!errors.empty()) {
  ------------------
  |  Branch (282:7): [True: 48, False: 2.03k]
  ------------------
  283|    144|    LOG(INFO) << errors.size() << "/"
  ------------------
  |  |  218|     48|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|     48|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|     48|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|     96|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|     96|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 48, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|     48|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 48]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|     48|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 48]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|     48|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    240|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|    240|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  284|    144|              << model_proto_->self_test_data().samples_size()
  285|    144|              << " samples did not pass the test.";
  286|    128|    for (const auto &e : errors) {
  ------------------
  |  Branch (286:24): [True: 128, False: 48]
  ------------------
  287|    384|      LOG(INFO) << e;
  ------------------
  |  |  218|    128|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|    128|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|    128|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|    256|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|    256|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 128, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|    128|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 128]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|    128|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 128]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|    128|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    256|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|    256|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  288|    128|    }
  289|     48|    return util::InternalError("Self-test failures. See LOG(INFO).");
  290|     48|  }
  291|       |
  292|  2.03k|  return util::OkStatus();
  293|  2.08k|}
_ZNK13sentencepiece22SentencePieceProcessor6statusEv:
  305|   142M|util::Status SentencePieceProcessor::status() const {
  306|   142M|  RET_CHECK(model_) << "Model is not initialized.";
  ------------------
  |  |  321|   142M|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 142M, False: 0]
  |  |  ------------------
  |  |  322|   142M|  } else /* NOLINT */                                        \
  |  |  323|   142M|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  307|   142M|  RET_CHECK(normalizer_) << "Normalizer is not initialized.";
  ------------------
  |  |  321|   142M|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 142M, False: 0]
  |  |  ------------------
  |  |  322|   142M|  } else /* NOLINT */                                        \
  |  |  323|   142M|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  308|   142M|  RETURN_IF_ERROR(model_->status());
  ------------------
  |  |   44|   142M|  do {                                 \
  |  |   45|   142M|    const auto _status = expr;         \
  |  |   46|   142M|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 1.09k, False: 142M]
  |  |  ------------------
  |  |   47|   142M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 142M]
  |  |  ------------------
  ------------------
  309|   142M|  RETURN_IF_ERROR(normalizer_->status());
  ------------------
  |  |   44|   142M|  do {                                 \
  |  |   45|   142M|    const auto _status = expr;         \
  |  |   46|   142M|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 1, False: 142M]
  |  |  ------------------
  |  |   47|   142M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 142M]
  |  |  ------------------
  ------------------
  310|   142M|  return util::OkStatus();
  311|   142M|}
_ZNK13sentencepiece22SentencePieceProcessor6EncodeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPNS1_6vectorINS1_12basic_stringIcS4_NS1_9allocatorIcEEEENS8_ISA_EEEE:
  395|  2.33k|    absl::string_view input, std::vector<std::string> *pieces) const {
  396|  4.66k|  RET_CHECK_STATUS_STL(pieces);
  ------------------
  |  |  383|  2.33k|  RETURN_IF_ERROR(status());                          \
  |  |  ------------------
  |  |  |  |   44|  2.33k|  do {                                 \
  |  |  |  |   45|  2.33k|    const auto _status = expr;         \
  |  |  |  |   46|  2.33k|    if (!_status.ok()) return _status; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:9): [True: 0, False: 2.33k]
  |  |  |  |  ------------------
  |  |  |  |   47|  2.33k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:12): [Folded, False: 2.33k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  384|  2.33k|  RET_CHECK(container) << "output container is null"; \
  |  |  ------------------
  |  |  |  |  321|  2.33k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 2.33k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  2.33k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  2.33k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  385|  2.33k|  container->clear();
  ------------------
  397|       |
  398|  4.66k|  Arena arena;
  399|  4.66k|  auto *spt = Arena::Create<SentencePieceText>(&arena);
  400|  4.66k|  RETURN_IF_ERROR(Encode(input, spt));
  ------------------
  |  |   44|  2.33k|  do {                                 \
  |  |   45|  2.33k|    const auto _status = expr;         \
  |  |   46|  2.33k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 21, False: 2.31k]
  |  |  ------------------
  |  |   47|  2.33k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 2.31k]
  |  |  ------------------
  ------------------
  401|  1.56M|  for (const auto &sp : spt->pieces()) {
  ------------------
  |  Branch (401:23): [True: 1.56M, False: 2.31k]
  ------------------
  402|  1.56M|    pieces->emplace_back(sp.piece());
  403|  1.56M|  }
  404|       |
  405|  2.31k|  return util::OkStatus();
  406|  4.66k|}
_ZNK13sentencepiece22SentencePieceProcessor6EncodeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPNS1_6vectorIiNS1_9allocatorIiEEEE:
  409|  2.03k|                                            std::vector<int> *ids) const {
  410|  4.06k|  RET_CHECK_STATUS_STL(ids);
  ------------------
  |  |  383|  2.03k|  RETURN_IF_ERROR(status());                          \
  |  |  ------------------
  |  |  |  |   44|  2.03k|  do {                                 \
  |  |  |  |   45|  2.03k|    const auto _status = expr;         \
  |  |  |  |   46|  2.03k|    if (!_status.ok()) return _status; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:9): [True: 0, False: 2.03k]
  |  |  |  |  ------------------
  |  |  |  |   47|  2.03k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:12): [Folded, False: 2.03k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  384|  2.03k|  RET_CHECK(container) << "output container is null"; \
  |  |  ------------------
  |  |  |  |  321|  2.03k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 2.03k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  2.03k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  2.03k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  385|  2.03k|  container->clear();
  ------------------
  411|       |
  412|       |  // The following is a pared down version of PopulateSentencePieceText, that
  413|       |  // only populates the ids; skipping the surface and begin/end fields as they
  414|       |  // will be thrown away otherwise.
  415|  4.06k|  std::string normalized;
  416|       |
  417|  4.06k|  RETURN_IF_ERROR(
  ------------------
  |  |   44|  2.03k|  do {                                 \
  |  |   45|  2.03k|    const auto _status = expr;         \
  |  |   46|  2.03k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 2.03k]
  |  |  ------------------
  |  |   47|  2.03k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 2.03k]
  |  |  ------------------
  ------------------
  418|  4.06k|      normalizer_->Normalize(input, &normalized, /*norm_to_orig=*/nullptr));
  419|  2.03k|  const EncodeResult result = model_->Encode(normalized);
  420|  2.03k|  const bool byte_fallback_enabled = model_->ByteFallbackEnabled();
  421|       |
  422|  2.03k|  bool is_prev_unk = false;
  423|  2.03k|  ids->reserve(result.size());
  424|       |
  425|  10.6M|  for (const auto &[w, id] : result) {
  ------------------
  |  Branch (425:28): [True: 10.6M, False: 2.03k]
  ------------------
  426|  10.6M|    RET_CHECK(!w.empty()) << "Empty piece is not allowed.";
  ------------------
  |  |  321|  10.6M|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.6M, False: 0]
  |  |  ------------------
  |  |  322|  10.6M|  } else /* NOLINT */                                        \
  |  |  323|  10.6M|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  427|  10.6M|    if (IsControl(id)) {
  ------------------
  |  Branch (427:9): [True: 370, False: 10.6M]
  ------------------
  428|    370|      ids->emplace_back(id);
  429|    370|      is_prev_unk = false;
  430|  10.6M|    } else {
  431|  10.6M|      const bool is_unk = IsUnknown(id);
  432|  10.6M|      if (is_unk && byte_fallback_enabled) {
  ------------------
  |  Branch (432:11): [True: 9.37M, False: 1.22M]
  |  Branch (432:21): [True: 132, False: 9.37M]
  ------------------
  433|    460|        for (size_t i = 0; i < w.size(); ++i) {
  ------------------
  |  Branch (433:28): [True: 328, False: 132]
  ------------------
  434|    328|          const auto sp_id =
  435|    328|              model_->PieceToId(ByteToPiece(static_cast<uint8_t>(w[i])));
  436|    328|          ids->emplace_back(sp_id);
  437|    328|        }
  438|  10.6M|      } else {
  439|       |        // Merge continuous runs of unknown pieces.
  440|  10.6M|        if (!is_prev_unk || !is_unk) {
  ------------------
  |  Branch (440:13): [True: 1.22M, False: 9.37M]
  |  Branch (440:29): [True: 336k, False: 9.03M]
  ------------------
  441|  1.56M|          ids->emplace_back(id);
  442|  1.56M|        }
  443|  10.6M|      }
  444|  10.6M|      is_prev_unk = is_unk;
  445|  10.6M|    }
  446|  10.6M|  }
  447|       |
  448|       |  // Inlining ApplyExtraOptions but just the ids part.
  449|  2.03k|  for (const auto &extra_option : encode_extra_options_) {
  ------------------
  |  Branch (449:33): [True: 0, False: 2.03k]
  ------------------
  450|      0|    switch (extra_option) {
  451|      0|      case REVERSE:
  ------------------
  |  Branch (451:7): [True: 0, False: 0]
  ------------------
  452|      0|        std::reverse(ids->begin(), ids->end());
  453|      0|        break;
  454|      0|      case EOS:
  ------------------
  |  Branch (454:7): [True: 0, False: 0]
  ------------------
  455|      0|        ids->emplace_back(PieceToId(model_->eos_piece()));
  456|      0|        break;
  457|      0|      case BOS:
  ------------------
  |  Branch (457:7): [True: 0, False: 0]
  ------------------
  458|      0|        ids->insert(ids->begin(), PieceToId(model_->bos_piece()));
  459|      0|        break;
  460|      0|      default:
  ------------------
  |  Branch (460:7): [True: 0, False: 0]
  ------------------
  461|      0|        ids->clear();
  462|      0|        return util::InternalError("unknown extra_option type.");
  463|      0|    }
  464|      0|  }
  465|       |
  466|  2.03k|  return util::OkStatus();
  467|  2.03k|}
_ZNK13sentencepiece22SentencePieceProcessor6DecodeERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEEPS8_:
  470|  1.93k|    const std::vector<std::string> &pieces, std::string *detokenized) const {
  471|  1.93k|  return Decode(ToPieceArray(pieces), detokenized);
  472|  1.93k|}
_ZNK13sentencepiece22SentencePieceProcessor6DecodeERKNSt3__16vectorINS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS1_9allocatorIS6_EEEEPNS1_12basic_stringIcS5_NS7_IcEEEE:
  476|  1.93k|    std::string *detokenized) const {
  477|  3.86k|  RET_CHECK_STATUS_STL(detokenized);
  ------------------
  |  |  383|  1.93k|  RETURN_IF_ERROR(status());                          \
  |  |  ------------------
  |  |  |  |   44|  1.93k|  do {                                 \
  |  |  |  |   45|  1.93k|    const auto _status = expr;         \
  |  |  |  |   46|  1.93k|    if (!_status.ok()) return _status; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:9): [True: 0, False: 1.93k]
  |  |  |  |  ------------------
  |  |  |  |   47|  1.93k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:12): [Folded, False: 1.93k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  384|  1.93k|  RET_CHECK(container) << "output container is null"; \
  |  |  ------------------
  |  |  |  |  321|  1.93k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 1.93k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  1.93k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  1.93k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  385|  1.93k|  container->clear();
  ------------------
  478|       |
  479|       |  // Allocate SentencePieceText on an arena to improve allocation and
  480|       |  // deallocation costs.
  481|  3.86k|  Arena arena;
  482|  3.86k|  auto *spt = Arena::Create<SentencePieceText>(&arena);
  483|  3.86k|  RETURN_IF_ERROR(Decode(pieces, spt));
  ------------------
  |  |   44|  1.93k|  do {                                 \
  |  |   45|  1.93k|    const auto _status = expr;         \
  |  |   46|  1.93k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 1.93k]
  |  |  ------------------
  |  |   47|  1.93k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 1.93k]
  |  |  ------------------
  ------------------
  484|  1.93k|  *detokenized = std::move(*spt->mutable_text());
  485|       |
  486|  1.93k|  return util::OkStatus();
  487|  3.86k|}
_ZNK13sentencepiece22SentencePieceProcessor6DecodeERKNSt3__16vectorIiNS1_9allocatorIiEEEEPNS1_12basic_stringIcNS1_11char_traitsIcEENS3_IcEEEE:
  490|  1.95k|                                            std::string *detokenized) const {
  491|  3.90k|  RET_CHECK_STATUS_STL(detokenized);
  ------------------
  |  |  383|  1.95k|  RETURN_IF_ERROR(status());                          \
  |  |  ------------------
  |  |  |  |   44|  1.95k|  do {                                 \
  |  |  |  |   45|  1.95k|    const auto _status = expr;         \
  |  |  |  |   46|  1.95k|    if (!_status.ok()) return _status; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:9): [True: 0, False: 1.95k]
  |  |  |  |  ------------------
  |  |  |  |   47|  1.95k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:12): [Folded, False: 1.95k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  384|  1.95k|  RET_CHECK(container) << "output container is null"; \
  |  |  ------------------
  |  |  |  |  321|  1.95k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 1.95k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  1.95k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  1.95k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  385|  1.95k|  container->clear();
  ------------------
  492|       |
  493|       |  // Allocate SentencePieceText on an arena to improve allocation and
  494|       |  // deallocation costs.
  495|  3.90k|  Arena arena;
  496|  3.90k|  auto *spt = Arena::Create<SentencePieceText>(&arena);
  497|  3.90k|  RETURN_IF_ERROR(Decode(ids, spt));
  ------------------
  |  |   44|  1.95k|  do {                                 \
  |  |   45|  1.95k|    const auto _status = expr;         \
  |  |   46|  1.95k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 1.95k]
  |  |  ------------------
  |  |   47|  1.95k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 1.95k]
  |  |  ------------------
  ------------------
  498|  1.95k|  *detokenized = std::move(*spt->mutable_text());
  499|       |
  500|  1.95k|  return util::OkStatus();
  501|  3.90k|}
_ZNK13sentencepiece22SentencePieceProcessor11NBestEncodeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEiPNS1_6vectorINS6_INS1_12basic_stringIcS4_NS1_9allocatorIcEEEENS8_ISA_EEEENS8_ISC_EEEE:
  505|  2.03k|    std::vector<std::vector<std::string>> *pieces) const {
  506|  4.06k|  RET_CHECK_STATUS_STL(pieces);
  ------------------
  |  |  383|  2.03k|  RETURN_IF_ERROR(status());                          \
  |  |  ------------------
  |  |  |  |   44|  2.03k|  do {                                 \
  |  |  |  |   45|  2.03k|    const auto _status = expr;         \
  |  |  |  |   46|  2.03k|    if (!_status.ok()) return _status; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:9): [True: 0, False: 2.03k]
  |  |  |  |  ------------------
  |  |  |  |   47|  2.03k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:12): [Folded, False: 2.03k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  384|  2.03k|  RET_CHECK(container) << "output container is null"; \
  |  |  ------------------
  |  |  |  |  321|  2.03k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 2.03k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  2.03k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  2.03k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  385|  2.03k|  container->clear();
  ------------------
  507|       |
  508|  4.06k|  Arena arena;
  509|  4.06k|  auto *spt = Arena::Create<NBestSentencePieceText>(&arena);
  510|  4.06k|  RETURN_IF_ERROR(NBestEncode(input, nbest_size, spt));
  ------------------
  |  |   44|  2.03k|  do {                                 \
  |  |   45|  2.03k|    const auto _status = expr;         \
  |  |   46|  2.03k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 452, False: 1.58k]
  |  |  ------------------
  |  |   47|  2.03k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 1.58k]
  |  |  ------------------
  ------------------
  511|  1.58k|  pieces->reserve(spt->nbests().size());
  512|  2.14k|  for (const auto &nbest : spt->nbests()) {
  ------------------
  |  Branch (512:26): [True: 2.14k, False: 1.58k]
  ------------------
  513|  2.14k|    std::vector<std::string> &result = pieces->emplace_back();
  514|  2.14k|    result.reserve(nbest.pieces().size());
  515|  2.18M|    for (const auto &sp : nbest.pieces()) {
  ------------------
  |  Branch (515:25): [True: 2.18M, False: 2.14k]
  ------------------
  516|  2.18M|      result.emplace_back(sp.piece());
  517|  2.18M|    }
  518|  2.14k|  }
  519|       |
  520|  1.58k|  return util::OkStatus();
  521|  4.06k|}
_ZNK13sentencepiece22SentencePieceProcessor12SampleEncodeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEifPNS1_6vectorINS1_12basic_stringIcS4_NS1_9allocatorIcEEEENS8_ISA_EEEE:
  545|  2.03k|    std::vector<std::string> *pieces) const {
  546|  4.06k|  RET_CHECK_STATUS_STL(pieces);
  ------------------
  |  |  383|  2.03k|  RETURN_IF_ERROR(status());                          \
  |  |  ------------------
  |  |  |  |   44|  2.03k|  do {                                 \
  |  |  |  |   45|  2.03k|    const auto _status = expr;         \
  |  |  |  |   46|  2.03k|    if (!_status.ok()) return _status; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:9): [True: 0, False: 2.03k]
  |  |  |  |  ------------------
  |  |  |  |   47|  2.03k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:12): [Folded, False: 2.03k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  384|  2.03k|  RET_CHECK(container) << "output container is null"; \
  |  |  ------------------
  |  |  |  |  321|  2.03k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 2.03k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  2.03k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  2.03k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  385|  2.03k|  container->clear();
  ------------------
  547|       |
  548|  4.06k|  Arena arena;
  549|  4.06k|  auto *spt = Arena::Create<SentencePieceText>(&arena);
  550|  4.06k|  RETURN_IF_ERROR(SampleEncode(input, nbest_size, alpha, spt));
  ------------------
  |  |   44|  2.03k|  do {                                 \
  |  |   45|  2.03k|    const auto _status = expr;         \
  |  |   46|  2.03k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 392, False: 1.64k]
  |  |  ------------------
  |  |   47|  2.03k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 1.64k]
  |  |  ------------------
  ------------------
  551|  1.64k|  pieces->reserve(spt->pieces().size());
  552|  1.53M|  for (const auto &sp : spt->pieces()) {
  ------------------
  |  Branch (552:23): [True: 1.53M, False: 1.64k]
  ------------------
  553|  1.53M|    pieces->emplace_back(sp.piece());
  554|  1.53M|  }
  555|       |
  556|  1.64k|  return util::OkStatus();
  557|  4.06k|}
_ZNK13sentencepiece22SentencePieceProcessor25PopulateSentencePieceTextENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_RKNS1_6vectorImNS1_9allocatorImEEEERKNS6_INS1_4pairIS5_iEENS7_ISD_EEEEPNS_17SentencePieceTextEb:
  629|  9.82k|    SentencePieceText *spt, bool skip_surface) const {
  630|  9.82k|  size_t consumed = 0;
  631|  9.82k|  bool is_prev_unk = false;
  632|  53.1M|  for (const auto &p : result) {
  ------------------
  |  Branch (632:22): [True: 53.1M, False: 9.82k]
  ------------------
  633|  53.1M|    const absl::string_view w = p.first;  // piece
  634|  53.1M|    const int id = p.second;              // id
  635|       |
  636|  53.1M|    RET_CHECK(!w.empty()) << "Empty piece is not allowed.";
  ------------------
  |  |  321|  53.1M|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 53.1M, False: 0]
  |  |  ------------------
  |  |  322|  53.1M|  } else /* NOLINT */                                        \
  |  |  323|  53.1M|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  637|       |
  638|  53.1M|    const bool is_unk = IsUnknown(id);
  639|       |
  640|  53.1M|    if (IsControl(id)) {
  ------------------
  |  Branch (640:9): [True: 1.46k, False: 53.1M]
  ------------------
  641|       |      // Control symbol has no corresponding source surface, so begin == end.
  642|  1.46k|      auto *sp = spt->add_pieces();
  643|  1.46k|      sp->set_piece(w.data(), w.size());
  644|  1.46k|      sp->set_id(id);
  645|  1.46k|      sp->set_begin(norm_to_orig[consumed]);
  646|  1.46k|      sp->set_end(norm_to_orig[consumed]);
  647|  53.1M|    } else {
  648|  53.1M|      const size_t begin = consumed;
  649|  53.1M|      const size_t end = consumed + w.size();
  650|  53.1M|      RET_CHECK_LT(begin, norm_to_orig.size());
  ------------------
  |  |  332|  53.1M|#define RET_CHECK_LT(a, b) RET_CHECK((a) < (b))
  |  |  ------------------
  |  |  |  |  321|  53.1M|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 53.1M, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  53.1M|  } else /* NOLINT */                                        \
  |  |  |  |  323|  53.1M|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  651|  53.1M|      RET_CHECK_LT(end, norm_to_orig.size());
  ------------------
  |  |  332|  53.1M|#define RET_CHECK_LT(a, b) RET_CHECK((a) < (b))
  |  |  ------------------
  |  |  |  |  321|  53.1M|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 53.1M, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  53.1M|  } else /* NOLINT */                                        \
  |  |  |  |  323|  53.1M|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  652|  53.1M|      const size_t orig_begin = norm_to_orig[begin];
  653|  53.1M|      const size_t orig_end = norm_to_orig[end];
  654|  53.1M|      RET_CHECK_LE(orig_begin, input.size());
  ------------------
  |  |  330|  53.1M|#define RET_CHECK_LE(a, b) RET_CHECK((a) <= (b))
  |  |  ------------------
  |  |  |  |  321|  53.1M|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 53.1M, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  53.1M|  } else /* NOLINT */                                        \
  |  |  |  |  323|  53.1M|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  655|  53.1M|      RET_CHECK_LE(orig_end, input.size());
  ------------------
  |  |  330|  53.1M|#define RET_CHECK_LE(a, b) RET_CHECK((a) <= (b))
  |  |  ------------------
  |  |  |  |  321|  53.1M|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 53.1M, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  53.1M|  } else /* NOLINT */                                        \
  |  |  |  |  323|  53.1M|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  656|  53.1M|      RET_CHECK_LE(orig_begin, orig_end);
  ------------------
  |  |  330|  53.1M|#define RET_CHECK_LE(a, b) RET_CHECK((a) <= (b))
  |  |  ------------------
  |  |  |  |  321|  53.1M|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 53.1M, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  53.1M|  } else /* NOLINT */                                        \
  |  |  |  |  323|  53.1M|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  657|  53.1M|      const auto surface =
  658|  53.1M|          absl::ClippedSubstr(input, orig_begin, orig_end - orig_begin);
  659|       |
  660|  53.1M|      if (is_unk && model_->ByteFallbackEnabled()) {
  ------------------
  |  Branch (660:11): [True: 46.4M, False: 6.67M]
  |  Branch (660:21): [True: 472, False: 46.4M]
  ------------------
  661|       |        // Decomposes an unknown piece into UTF-8 bytes
  662|  1.50k|        for (size_t i = 0; i < w.size(); ++i) {
  ------------------
  |  Branch (662:28): [True: 1.03k, False: 472]
  ------------------
  663|       |          // Create a byte piece
  664|  1.03k|          const uint8_t b = static_cast<uint8_t>(w[i]);
  665|  1.03k|          SentencePieceText::SentencePiece *sp = spt->add_pieces();
  666|  1.03k|          std::string &piece = *sp->mutable_piece();
  667|  1.03k|          piece = ByteToPiece(b);
  668|  1.03k|          int sp_id = model_->PieceToId(piece);
  669|  1.03k|          sp->set_id(sp_id);
  670|       |
  671|       |          // The last byte piece holds the surface of the original unknown
  672|       |          // character. The other byte pieces have no surface.
  673|  1.03k|          if (i == w.size() - 1) {
  ------------------
  |  Branch (673:15): [True: 472, False: 564]
  ------------------
  674|    472|            if (!skip_surface) sp->set_surface(surface.data(), surface.size());
  ------------------
  |  Branch (674:17): [True: 472, False: 0]
  ------------------
  675|    472|            sp->set_begin(orig_begin);
  676|    472|            sp->set_end(orig_end);
  677|    564|          } else {
  678|       |            // begin == end
  679|    564|            sp->set_begin(orig_begin);
  680|    564|            sp->set_end(orig_begin);
  681|    564|          }
  682|  1.03k|        }
  683|  53.1M|      } else {
  684|       |        // Merges continuous run of unknown pieces so that decoder
  685|       |        // can copy or generate unknown tokens easily.
  686|       |        // Note that merged tokens are still unknown,
  687|       |        // since known pieces never consist of unknown characters.
  688|  53.1M|        if (is_prev_unk && is_unk) {
  ------------------
  |  Branch (688:13): [True: 46.4M, False: 6.69M]
  |  Branch (688:28): [True: 44.7M, False: 1.69M]
  ------------------
  689|  44.7M|          auto *sp = spt->mutable_pieces(spt->pieces_size() - 1);
  690|  44.7M|          sp->mutable_piece()->append(w);
  691|  44.7M|          if (!skip_surface) sp->mutable_surface()->append(surface);
  ------------------
  |  Branch (691:15): [True: 44.7M, False: 0]
  ------------------
  692|  44.7M|          sp->set_end(orig_end);
  693|  44.7M|        } else {
  694|  8.38M|          auto *sp = spt->add_pieces();
  695|  8.38M|          sp->set_piece(w.data(), w.size());
  696|  8.38M|          sp->set_id(id);
  697|  8.38M|          if (!skip_surface) sp->set_surface(surface.data(), surface.size());
  ------------------
  |  Branch (697:15): [True: 8.38M, False: 0]
  ------------------
  698|  8.38M|          sp->set_begin(orig_begin);
  699|  8.38M|          sp->set_end(orig_end);
  700|  8.38M|        }
  701|  53.1M|      }
  702|  53.1M|      consumed += w.size();
  703|  53.1M|    }
  704|  53.1M|    is_prev_unk = is_unk;
  705|  53.1M|  }
  706|       |
  707|  9.82k|  RET_CHECK_EQ(consumed, normalized.size())
  ------------------
  |  |  327|  9.82k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|  9.89k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 9.75k, False: 72]
  |  |  |  |  ------------------
  |  |  |  |  322|  9.75k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  9.89k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|     72|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|     72|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  708|     72|      << "all normalized characters are not consumed.";
  709|       |
  710|  9.75k|  spt->set_text(input.data(), input.size());
  711|       |
  712|  9.75k|  RETURN_IF_ERROR(ApplyExtraOptions(encode_extra_options_, spt));
  ------------------
  |  |   44|  9.75k|  do {                                 \
  |  |   45|  9.75k|    const auto _status = expr;         \
  |  |   46|  9.75k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 9.75k]
  |  |  ------------------
  |  |   47|  9.75k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 9.75k]
  |  |  ------------------
  ------------------
  713|       |
  714|  9.75k|  return util::OkStatus();
  715|  9.75k|}  // namespace sentencepiece
_ZNK13sentencepiece22SentencePieceProcessor6EncodeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPNS_17SentencePieceTextE:
  718|  4.36k|                                            SentencePieceText *spt) const {
  719|  8.73k|  RET_CHECK_STATUS_PROTO(spt);
  ------------------
  |  |  388|  4.36k|  RETURN_IF_ERROR(status());                  \
  |  |  ------------------
  |  |  |  |   44|  4.36k|  do {                                 \
  |  |  |  |   45|  4.36k|    const auto _status = expr;         \
  |  |  |  |   46|  4.36k|    if (!_status.ok()) return _status; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:9): [True: 0, False: 4.36k]
  |  |  |  |  ------------------
  |  |  |  |   47|  4.36k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:12): [Folded, False: 4.36k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  389|  4.36k|  RET_CHECK(proto) << "output proto is null"; \
  |  |  ------------------
  |  |  |  |  321|  4.36k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 4.36k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  4.36k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  4.36k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  390|  4.36k|  proto->Clear();
  ------------------
  720|       |
  721|  8.73k|  std::string normalized;
  722|  8.73k|  std::vector<size_t> norm_to_orig;
  723|  8.73k|  RETURN_IF_ERROR(normalizer_->Normalize(input, &normalized, &norm_to_orig));
  ------------------
  |  |   44|  4.36k|  do {                                 \
  |  |   45|  4.36k|    const auto _status = expr;         \
  |  |   46|  4.36k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 4.36k]
  |  |  ------------------
  |  |   47|  4.36k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 4.36k]
  |  |  ------------------
  ------------------
  724|       |
  725|  4.36k|  const auto result = model_->Encode(normalized);
  726|  4.36k|  RETURN_IF_ERROR(
  ------------------
  |  |   44|  4.36k|  do {                                 \
  |  |   45|  4.36k|    const auto _status = expr;         \
  |  |   46|  4.36k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 42, False: 4.32k]
  |  |  ------------------
  |  |   47|  4.36k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 4.32k]
  |  |  ------------------
  ------------------
  727|  4.36k|      PopulateSentencePieceText(input, normalized, norm_to_orig, result, spt));
  728|       |
  729|  4.32k|  return util::OkStatus();
  730|  4.36k|}
_ZNK13sentencepiece22SentencePieceProcessor11NBestEncodeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEiPNS_22NBestSentencePieceTextE:
  734|  2.03k|    NBestSentencePieceText *nbest_spt) const {
  735|  4.06k|  RET_CHECK_STATUS_PROTO(nbest_spt);
  ------------------
  |  |  388|  2.03k|  RETURN_IF_ERROR(status());                  \
  |  |  ------------------
  |  |  |  |   44|  2.03k|  do {                                 \
  |  |  |  |   45|  2.03k|    const auto _status = expr;         \
  |  |  |  |   46|  2.03k|    if (!_status.ok()) return _status; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:9): [True: 0, False: 2.03k]
  |  |  |  |  ------------------
  |  |  |  |   47|  2.03k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:12): [Folded, False: 2.03k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  389|  2.03k|  RET_CHECK(proto) << "output proto is null"; \
  |  |  ------------------
  |  |  |  |  321|  2.03k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 2.03k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  2.03k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  2.03k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  390|  2.03k|  proto->Clear();
  ------------------
  736|       |
  737|  4.06k|  RET_CHECK_LE(nbest_size, kMaxNBestSize)
  ------------------
  |  |  330|  2.03k|#define RET_CHECK_LE(a, b) RET_CHECK((a) <= (b))
  |  |  ------------------
  |  |  |  |  321|  2.03k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 2.03k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  2.03k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  2.03k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  738|      0|      << "nbest_size must be nbest_size <= " << kMaxNBestSize;
  739|       |
  740|  2.03k|  std::string normalized;
  741|  2.03k|  std::vector<size_t> norm_to_orig;
  742|  2.03k|  RETURN_IF_ERROR(normalizer_->Normalize(input, &normalized, &norm_to_orig));
  ------------------
  |  |   44|  2.03k|  do {                                 \
  |  |   45|  2.03k|    const auto _status = expr;         \
  |  |   46|  2.03k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 2.03k]
  |  |  ------------------
  |  |   47|  2.03k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 2.03k]
  |  |  ------------------
  ------------------
  743|       |
  744|  2.03k|  RET_CHECK(model_->IsNBestEncodeAvailable())
  ------------------
  |  |  321|  2.48k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 1.58k, False: 452]
  |  |  ------------------
  |  |  322|  1.58k|  } else /* NOLINT */                                        \
  |  |  323|  2.48k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|    452|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|    452|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  745|    452|      << "NBestEncode is not available for the current model.";
  746|       |
  747|  1.58k|  const auto nbests = model_->NBestEncode(normalized, nbest_size);
  748|  1.58k|  RET_CHECK(!nbests.empty()) << "NBestEncode returns empty result.";
  ------------------
  |  |  321|  1.58k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 1.58k, False: 0]
  |  |  ------------------
  |  |  322|  1.58k|  } else /* NOLINT */                                        \
  |  |  323|  1.58k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  749|       |
  750|  2.14k|  for (const auto &result : nbests) {
  ------------------
  |  Branch (750:27): [True: 2.14k, False: 1.58k]
  ------------------
  751|  2.14k|    auto *spt = nbest_spt->add_nbests();
  752|  2.14k|    spt->set_score(result.second);
  753|  2.14k|    RETURN_IF_ERROR(PopulateSentencePieceText(input, normalized, norm_to_orig,
  ------------------
  |  |   44|  2.14k|  do {                                 \
  |  |   45|  2.14k|    const auto _status = expr;         \
  |  |   46|  2.14k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 2.14k]
  |  |  ------------------
  |  |   47|  2.14k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 2.14k]
  |  |  ------------------
  ------------------
  754|  2.14k|                                              result.first, spt));
  755|  2.14k|  }
  756|       |
  757|  1.58k|  return util::OkStatus();
  758|  1.58k|}
_ZNK13sentencepiece22SentencePieceProcessor12SampleEncodeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEifPNS_17SentencePieceTextE:
  762|  4.06k|    SentencePieceText *spt) const {
  763|  8.13k|  RET_CHECK_STATUS_PROTO(spt);
  ------------------
  |  |  388|  4.06k|  RETURN_IF_ERROR(status());                  \
  |  |  ------------------
  |  |  |  |   44|  4.06k|  do {                                 \
  |  |  |  |   45|  4.06k|    const auto _status = expr;         \
  |  |  |  |   46|  4.06k|    if (!_status.ok()) return _status; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:9): [True: 0, False: 4.06k]
  |  |  |  |  ------------------
  |  |  |  |   47|  4.06k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:12): [Folded, False: 4.06k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  389|  4.06k|  RET_CHECK(proto) << "output proto is null"; \
  |  |  ------------------
  |  |  |  |  321|  4.06k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 4.06k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  4.06k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  4.06k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  390|  4.06k|  proto->Clear();
  ------------------
  764|       |
  765|  8.13k|  RET_CHECK(!std::isnan(alpha));
  ------------------
  |  |  321|  4.06k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 4.06k, False: 0]
  |  |  ------------------
  |  |  322|  4.06k|  } else /* NOLINT */                                        \
  |  |  323|  4.06k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  766|  4.06k|  RET_CHECK_GE(alpha, 0.0);
  ------------------
  |  |  329|  4.06k|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  321|  4.06k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 4.06k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  4.06k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  4.06k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  767|  4.06k|  RET_CHECK_LE(nbest_size, kMaxNBestSize)
  ------------------
  |  |  330|  4.06k|#define RET_CHECK_LE(a, b) RET_CHECK((a) <= (b))
  |  |  ------------------
  |  |  |  |  321|  4.06k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 4.06k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  4.06k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  4.06k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  768|      0|      << "nbest_size must be nbest_size <= " << kMaxNBestSize;
  769|       |
  770|  4.06k|  std::string normalized;
  771|  4.06k|  std::vector<size_t> norm_to_orig;
  772|  4.06k|  RETURN_IF_ERROR(normalizer_->Normalize(input, &normalized, &norm_to_orig));
  ------------------
  |  |   44|  4.06k|  do {                                 \
  |  |   45|  4.06k|    const auto _status = expr;         \
  |  |   46|  4.06k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 4.06k]
  |  |  ------------------
  |  |   47|  4.06k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 4.06k]
  |  |  ------------------
  ------------------
  773|       |
  774|  4.06k|  if (!model_->IsNBestEncodeAvailable() || nbest_size < 0) {
  ------------------
  |  Branch (774:7): [True: 904, False: 3.16k]
  |  Branch (774:44): [True: 0, False: 3.16k]
  ------------------
  775|    904|    RET_CHECK(model_->IsSampleEncodeAvailable())
  ------------------
  |  |  321|  1.65k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 150, False: 754]
  |  |  ------------------
  |  |  322|    150|  } else /* NOLINT */                                        \
  |  |  323|  1.65k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|    754|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|    754|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  776|    754|        << "SampleEncode is not available for the current model.";
  777|    150|    const auto result = model_->SampleEncode(normalized, alpha);
  778|    150|    RETURN_IF_ERROR(PopulateSentencePieceText(input, normalized, norm_to_orig,
  ------------------
  |  |   44|    150|  do {                                 \
  |  |   45|    150|    const auto _status = expr;         \
  |  |   46|    150|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 30, False: 120]
  |  |  ------------------
  |  |   47|    150|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 120]
  |  |  ------------------
  ------------------
  779|    150|                                              result, spt));
  780|  3.16k|  } else if (nbest_size == 1 || nbest_size == 0) {
  ------------------
  |  Branch (780:14): [True: 3.16k, False: 0]
  |  Branch (780:33): [True: 0, False: 0]
  ------------------
  781|  3.16k|    const auto result = model_->Encode(normalized);
  782|  3.16k|    RETURN_IF_ERROR(PopulateSentencePieceText(input, normalized, norm_to_orig,
  ------------------
  |  |   44|  3.16k|  do {                                 \
  |  |   45|  3.16k|    const auto _status = expr;         \
  |  |   46|  3.16k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 3.16k]
  |  |  ------------------
  |  |   47|  3.16k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 3.16k]
  |  |  ------------------
  ------------------
  783|  3.16k|                                              result, spt));
  784|  3.16k|  } else if (nbest_size > 1) {
  ------------------
  |  Branch (784:14): [True: 0, False: 0]
  ------------------
  785|      0|    const auto nbests = model_->NBestEncode(normalized, nbest_size);
  786|      0|    RET_CHECK(!nbests.empty()) << "NBestEncode returns empty result.";
  ------------------
  |  |  321|      0|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  322|      0|  } else /* NOLINT */                                        \
  |  |  323|      0|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  787|       |
  788|      0|    std::vector<double> log_probs;
  789|      0|    log_probs.reserve(nbests.size());
  790|      0|    std::transform(nbests.begin(), nbests.end(), std::back_inserter(log_probs),
  791|      0|                   [alpha](const auto &nbest) { return alpha * nbest.second; });
  792|       |
  793|      0|    const double Z = log_domain::LogSum(log_probs);
  794|      0|    std::vector<double> probs;
  795|      0|    probs.reserve(log_probs.size());
  796|      0|    std::transform(
  797|      0|        log_probs.begin(), log_probs.end(), std::back_inserter(probs),
  798|      0|        [Z](const auto &log_prob) { return std::exp(log_prob - Z); });
  799|       |
  800|      0|    auto *mt = random::GetRandomGenerator();
  801|      0|    std::discrete_distribution<int> dist(probs.begin(), probs.end());
  802|      0|    RETURN_IF_ERROR(PopulateSentencePieceText(input, normalized, norm_to_orig,
  ------------------
  |  |   44|      0|  do {                                 \
  |  |   45|      0|    const auto _status = expr;         \
  |  |   46|      0|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   47|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  803|      0|                                              nbests[dist(*mt)].first, spt));
  804|      0|  }
  805|       |
  806|  3.28k|  return util::OkStatus();
  807|  4.06k|}
_ZNK13sentencepiece22SentencePieceProcessor6DecodeERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEEPNS_17SentencePieceTextE:
  854|  1.95k|    const std::vector<std::string> &pieces, SentencePieceText *spt) const {
  855|  1.95k|  return Decode(ToPieceArray(pieces), spt);
  856|  1.95k|}
_ZNK13sentencepiece22SentencePieceProcessor6DecodeERKNSt3__16vectorINS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS1_9allocatorIS6_EEEEPNS_17SentencePieceTextE:
  860|  3.88k|    SentencePieceText *spt) const {
  861|  7.76k|  RET_CHECK_STATUS_PROTO(spt);
  ------------------
  |  |  388|  3.88k|  RETURN_IF_ERROR(status());                  \
  |  |  ------------------
  |  |  |  |   44|  3.88k|  do {                                 \
  |  |  |  |   45|  3.88k|    const auto _status = expr;         \
  |  |  |  |   46|  3.88k|    if (!_status.ok()) return _status; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (46:9): [True: 0, False: 3.88k]
  |  |  |  |  ------------------
  |  |  |  |   47|  3.88k|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (47:12): [Folded, False: 3.88k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  389|  3.88k|  RET_CHECK(proto) << "output proto is null"; \
  |  |  ------------------
  |  |  |  |  321|  3.88k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 3.88k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  3.88k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  3.88k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  390|  3.88k|  proto->Clear();
  ------------------
  862|       |
  863|  7.76k|  absl::string_view unk_surface = kDefaultUnknownSymbol;
  864|  7.76k|  if (model_proto_ && model_proto_->trainer_spec().has_unk_surface())
  ------------------
  |  Branch (864:7): [True: 3.88k, False: 0]
  |  Branch (864:23): [True: 46, False: 3.83k]
  ------------------
  865|     46|    unk_surface = model_proto_->trainer_spec().unk_surface();
  866|       |
  867|       |  // Returns decoded piece and a boolean indicating if the function has consumed
  868|       |  // a bos whitespace token (a piece starting with a kSpaceSymbol). This is used
  869|       |  // to strip only the first whitespace token from the decoded sequence for
  870|       |  // add_dummy_prefix.
  871|  7.76k|  auto DecodeSentencePiece =
  872|  7.76k|      [&](absl::string_view piece, int id,
  873|  7.76k|          bool is_bos_ws) -> std::pair<std::string, bool> {
  874|  7.76k|    if (IsControl(id)) {                 // <s>, </s>
  875|  7.76k|      return std::make_pair("", false);  // invisible symbol.
  876|  7.76k|    } else if (IsUnknown(id)) {
  877|  7.76k|      if (IdToPiece(id) == piece) {  // <unk>
  878|  7.76k|        return std::make_pair(std::string(unk_surface), false);
  879|  7.76k|      } else {  // return piece when piece is not <unk>.
  880|  7.76k|        return std::make_pair(std::string(piece), false);
  881|  7.76k|      }
  882|  7.76k|    }
  883|       |
  884|  7.76k|    bool has_bos_ws = false;  // whether the token starts with a kSpaceSymbol
  885|  7.76k|    if (is_bos_ws &&
  886|  7.76k|        (!model_proto_ ||
  887|  7.76k|         (model_proto_ &&
  888|  7.76k|          (model_proto_->normalizer_spec().add_dummy_prefix() ||
  889|  7.76k|           model_proto_->normalizer_spec().remove_extra_whitespaces())))) {
  890|       |      // Consume if the current position is bos and
  891|       |      // piece starts with kSpaceSymbol.
  892|  7.76k|      has_bos_ws = absl::ConsumePrefix(&piece, kSpaceSymbol);
  893|       |
  894|  7.76k|      if (model_proto_ &&
  895|  7.76k|          model_proto_->normalizer_spec().remove_extra_whitespaces()) {
  896|       |        // if we are removing extra whitespace, we remove all leading whitespace
  897|  7.76k|        has_bos_ws = false;
  898|  7.76k|      }
  899|  7.76k|    }
  900|       |
  901|  7.76k|    return std::make_pair(absl::StrReplaceAll(piece, {{kSpaceSymbol, " "}}),
  902|  7.76k|                          has_bos_ws);
  903|  7.76k|  };
  904|       |
  905|  7.76k|  spt->mutable_pieces()->Reserve(pieces.size());
  906|  3.13M|  for (absl::string_view w : pieces) {
  ------------------
  |  Branch (906:28): [True: 3.13M, False: 3.88k]
  ------------------
  907|  3.13M|    auto *sp = spt->add_pieces();
  908|  3.13M|    sp->mutable_piece()->assign(w.data(), w.size());
  909|  3.13M|    sp->set_id(PieceToId(w));
  910|  3.13M|  }
  911|       |
  912|  7.76k|  RETURN_IF_ERROR(ApplyExtraOptions(decode_extra_options_, spt));
  ------------------
  |  |   44|  3.88k|  do {                                 \
  |  |   45|  3.88k|    const auto _status = expr;         \
  |  |   46|  3.88k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 3.88k]
  |  |  ------------------
  |  |   47|  3.88k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 3.88k]
  |  |  ------------------
  ------------------
  913|       |
  914|  3.88k|  std::string *text = spt->mutable_text();
  915|  3.88k|  auto SetSurface = [&](int index, absl::string_view surface) {
  916|  3.88k|    auto *sp = spt->mutable_pieces(index);
  917|  3.88k|    sp->set_surface(surface.data(), surface.size());
  918|  3.88k|    sp->set_begin(text->size());
  919|  3.88k|    sp->set_end(text->size() + surface.size());
  920|  3.88k|    absl::StrAppend(text, surface);
  921|  3.88k|  };
  922|       |
  923|  3.88k|  auto ProcessBytePieces = [&](int token_index_begin,
  924|  3.88k|                               int token_index_end) -> util::Status {
  925|  3.88k|    if (token_index_begin >= token_index_end) {
  926|  3.88k|      return util::OkStatus();
  927|  3.88k|    }
  928|       |
  929|       |    // Constructs byte sequence.
  930|  3.88k|    std::string bytes;
  931|  3.88k|    for (int i = token_index_begin; i < token_index_end; ++i) {
  932|  3.88k|      const auto &sp = spt->pieces(i);
  933|  3.88k|      const int byte = PieceToByte(sp.piece());
  934|  3.88k|      RET_CHECK_LE(0, byte);
  935|  3.88k|      bytes.append(1, byte);
  936|  3.88k|    }
  937|       |
  938|       |    // Set surfaces of `bytes` for each Unicode character.
  939|  3.88k|    int offset = 0;
  940|  3.88k|    const int bytes_len = bytes.size();
  941|  3.88k|    while (offset < bytes_len) {
  942|       |      // Consume `bytes` by one Unicode character.
  943|  3.88k|      size_t consumed;  // Number of bytes consumed in this iteration.
  944|  3.88k|      const bool is_valid = string_util::IsValidDecodeUTF8(
  945|  3.88k|          absl::string_view(bytes).substr(offset), &consumed);
  946|       |
  947|       |      // Set surfaces of the consumed byte pieces.
  948|  3.88k|      const int token_index = token_index_begin + offset;
  949|       |
  950|  3.88k|      if (!is_valid) {
  951|       |        // The byte piece at `token_index` is structurally invalid. Map it to
  952|       |        // REPLACEMENT CHARACTER (U+FFFD).
  953|  3.88k|        RET_CHECK_EQ(consumed, 1);
  954|  3.88k|        SetSurface(token_index, kReplacementCharacter);
  955|  3.88k|      } else {
  956|  3.88k|        const absl::string_view utf8 =
  957|  3.88k|            absl::string_view(bytes).substr(offset, consumed);
  958|  3.88k|        for (size_t j = 0; j < consumed; j++) {
  959|       |          // The last byte piece holds the surface of the original unknown
  960|       |          // character. The other byte pieces hold an empty string as
  961|       |          // surface.
  962|  3.88k|          if (j == consumed - 1) {
  963|  3.88k|            SetSurface(token_index + j, utf8);
  964|  3.88k|          } else {
  965|  3.88k|            SetSurface(token_index + j, "");
  966|  3.88k|          }
  967|  3.88k|        }
  968|  3.88k|      }
  969|  3.88k|      offset += consumed;
  970|  3.88k|    }
  971|  3.88k|    RET_CHECK_EQ(token_index_begin + offset, token_index_end);
  972|       |
  973|  3.88k|    return util::OkStatus();
  974|  3.88k|  };
  975|       |
  976|  3.88k|  int byte_start = 0;
  977|  3.88k|  bool is_bos_ws = true;  // whether we expect a bos ws token to consume.
  978|  3.88k|  bool bos_ws_seen = false;
  979|  3.88k|  std::string decoded;
  980|       |
  981|  3.13M|  for (int i = 0; i < spt->pieces_size(); ++i) {
  ------------------
  |  Branch (981:19): [True: 3.13M, False: 3.88k]
  ------------------
  982|  3.13M|    const auto &sp = spt->pieces(i);
  983|  3.13M|    if (!IsByte(sp.id())) {
  ------------------
  |  Branch (983:9): [True: 3.13M, False: 656]
  ------------------
  984|  3.13M|      RETURN_IF_ERROR(ProcessBytePieces(byte_start, i));
  ------------------
  |  |   44|  3.13M|  do {                                 \
  |  |   45|  3.13M|    const auto _status = expr;         \
  |  |   46|  3.13M|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 3.13M]
  |  |  ------------------
  |  |   47|  3.13M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 3.13M]
  |  |  ------------------
  ------------------
  985|       |
  986|       |      // if we have seen a bos_ws token or any non-empty token
  987|  3.13M|      if (bos_ws_seen || !text->empty()) is_bos_ws = false;
  ------------------
  |  Branch (987:11): [True: 4, False: 3.13M]
  |  Branch (987:26): [True: 3.12M, False: 6.98k]
  ------------------
  988|       |
  989|  3.13M|      byte_start = i + 1;
  990|  3.13M|      std::tie(decoded, bos_ws_seen) =
  991|  3.13M|          DecodeSentencePiece(sp.piece(), sp.id(), is_bos_ws);
  992|       |
  993|  3.13M|      SetSurface(i, decoded);
  994|  3.13M|    }
  995|  3.13M|  }
  996|  3.88k|  RETURN_IF_ERROR(ProcessBytePieces(byte_start, spt->pieces_size()));
  ------------------
  |  |   44|  3.88k|  do {                                 \
  |  |   45|  3.88k|    const auto _status = expr;         \
  |  |   46|  3.88k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 3.88k]
  |  |  ------------------
  |  |   47|  3.88k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 3.88k]
  |  |  ------------------
  ------------------
  997|       |
  998|  3.88k|  if (denormalizer_) {
  ------------------
  |  Branch (998:7): [True: 18, False: 3.86k]
  ------------------
  999|     18|    *text = denormalizer_->Normalize(*text);
 1000|     18|  }
 1001|       |
 1002|  3.88k|  return util::OkStatus();
 1003|  3.88k|}
_ZNK13sentencepiece22SentencePieceProcessor6DecodeERKNSt3__16vectorIiNS1_9allocatorIiEEEEPNS_17SentencePieceTextE:
 1006|  1.95k|                                            SentencePieceText *spt) const {
 1007|  1.95k|  std::vector<std::string> pieces;
 1008|  1.95k|  const int num_pieces = GetPieceSize();
 1009|  1.95k|  pieces.reserve(ids.size());
 1010|  1.56M|  for (const int id : ids) {
  ------------------
  |  Branch (1010:21): [True: 1.56M, False: 1.95k]
  ------------------
 1011|  1.56M|    if (id < 0 || id >= num_pieces) {
  ------------------
  |  Branch (1011:9): [True: 0, False: 1.56M]
  |  Branch (1011:19): [True: 0, False: 1.56M]
  ------------------
 1012|      0|      return util::Status(util::StatusCode::kOutOfRange,
 1013|      0|                          absl::StrCat("Invalid id: ", id));
 1014|      0|    }
 1015|  1.56M|    pieces.emplace_back(IdToPiece(id));
 1016|  1.56M|  }
 1017|  1.95k|  return Decode(pieces, spt);
 1018|  1.95k|}
_ZNK13sentencepiece22SentencePieceProcessor9NormalizeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPNS1_12basic_stringIcS4_NS1_9allocatorIcEEEE:
 1027|  2.03k|                                               std::string *normalized) const {
 1028|  2.03k|  RET_CHECK(normalizer_);
  ------------------
  |  |  321|  2.03k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 2.03k, False: 0]
  |  |  ------------------
  |  |  322|  2.03k|  } else /* NOLINT */                                        \
  |  |  323|  2.03k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
 1029|  2.03k|  return normalizer_->Normalize(input, normalized, nullptr);
 1030|  2.03k|}
_ZNK13sentencepiece22SentencePieceProcessor12GetPieceSizeEv:
 1045|  3.98k|int SentencePieceProcessor::GetPieceSize() const {
 1046|  3.98k|  RET_CHECK_OR_RETURN_DEFAULT(0);
  ------------------
  |  | 1021|  3.98k|  if (!status().ok()) {                                                      \
  |  |  ------------------
  |  |  |  Branch (1021:7): [True: 0, False: 3.98k]
  |  |  ------------------
  |  | 1022|      0|    LOG(ERROR) << status().message() << "\nReturns default value " << value; \
  |  |  ------------------
  |  |  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1023|      0|    return value;                                                            \
  |  | 1024|      0|  }
  ------------------
 1047|  3.98k|  return model_->GetPieceSize();
 1048|  3.98k|}
_ZNK13sentencepiece22SentencePieceProcessor9PieceToIdENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
 1050|  3.15M|int SentencePieceProcessor::PieceToId(absl::string_view piece) const {
 1051|  3.15M|  RET_CHECK_OR_RETURN_DEFAULT(0);
  ------------------
  |  | 1021|  3.15M|  if (!status().ok()) {                                                      \
  |  |  ------------------
  |  |  |  Branch (1021:7): [True: 0, False: 3.15M]
  |  |  ------------------
  |  | 1022|      0|    LOG(ERROR) << status().message() << "\nReturns default value " << value; \
  |  |  ------------------
  |  |  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1023|      0|    return value;                                                            \
  |  | 1024|      0|  }
  ------------------
 1052|  3.15M|  return model_->PieceToId(piece);
 1053|  3.15M|}
_ZNK13sentencepiece22SentencePieceProcessor9IdToPieceEi:
 1055|  2.25M|const std::string &SentencePieceProcessor::IdToPiece(int id) const {
 1056|  2.25M|  static const std::string *kEmptyString = new std::string;
 1057|  2.25M|  RET_CHECK_OR_RETURN_DEFAULT(*kEmptyString);
  ------------------
  |  | 1021|  2.25M|  if (!status().ok()) {                                                      \
  |  |  ------------------
  |  |  |  Branch (1021:7): [True: 0, False: 2.25M]
  |  |  ------------------
  |  | 1022|      0|    LOG(ERROR) << status().message() << "\nReturns default value " << value; \
  |  |  ------------------
  |  |  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1023|      0|    return value;                                                            \
  |  | 1024|      0|  }
  ------------------
 1058|  2.25M|  return model_->IdToPiece(id);
 1059|  2.25M|}
_ZNK13sentencepiece22SentencePieceProcessor8GetScoreEi:
 1070|  10.4k|float SentencePieceProcessor::GetScore(int id) const {
 1071|  10.4k|  RET_CHECK_OR_RETURN_DEFAULT(0.0);
  ------------------
  |  | 1021|  10.4k|  if (!status().ok()) {                                                      \
  |  |  ------------------
  |  |  |  Branch (1021:7): [True: 0, False: 10.4k]
  |  |  ------------------
  |  | 1022|      0|    LOG(ERROR) << status().message() << "\nReturns default value " << value; \
  |  |  ------------------
  |  |  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1023|      0|    return value;                                                            \
  |  | 1024|      0|  }
  ------------------
 1072|  10.4k|  return model_->GetScore(id);
 1073|  10.4k|}
_ZNK13sentencepiece22SentencePieceProcessor9IsControlEi:
 1075|  66.8M|bool SentencePieceProcessor::IsControl(int id) const {
 1076|  66.8M|  RET_CHECK_OR_RETURN_DEFAULT(0);
  ------------------
  |  | 1021|  66.8M|  if (!status().ok()) {                                                      \
  |  |  ------------------
  |  |  |  Branch (1021:7): [True: 0, False: 66.8M]
  |  |  ------------------
  |  | 1022|      0|    LOG(ERROR) << status().message() << "\nReturns default value " << value; \
  |  |  ------------------
  |  |  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1023|      0|    return value;                                                            \
  |  | 1024|      0|  }
  ------------------
 1077|  66.8M|  return model_->IsControl(id);
 1078|  66.8M|}
_ZNK13sentencepiece22SentencePieceProcessor9IsUnknownEi:
 1080|  66.8M|bool SentencePieceProcessor::IsUnknown(int id) const {
 1081|  66.8M|  RET_CHECK_OR_RETURN_DEFAULT(0);
  ------------------
  |  | 1021|  66.8M|  if (!status().ok()) {                                                      \
  |  |  ------------------
  |  |  |  Branch (1021:7): [True: 0, False: 66.8M]
  |  |  ------------------
  |  | 1022|      0|    LOG(ERROR) << status().message() << "\nReturns default value " << value; \
  |  |  ------------------
  |  |  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1023|      0|    return value;                                                            \
  |  | 1024|      0|  }
  ------------------
 1082|  66.8M|  return model_->IsUnknown(id);
 1083|  66.8M|}
_ZNK13sentencepiece22SentencePieceProcessor8IsUnusedEi:
 1085|  10.4k|bool SentencePieceProcessor::IsUnused(int id) const {
 1086|  10.4k|  RET_CHECK_OR_RETURN_DEFAULT(false);
  ------------------
  |  | 1021|  10.4k|  if (!status().ok()) {                                                      \
  |  |  ------------------
  |  |  |  Branch (1021:7): [True: 0, False: 10.4k]
  |  |  ------------------
  |  | 1022|      0|    LOG(ERROR) << status().message() << "\nReturns default value " << value; \
  |  |  ------------------
  |  |  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1023|      0|    return value;                                                            \
  |  | 1024|      0|  }
  ------------------
 1087|  10.4k|  return model_->IsUnused(id);
 1088|  10.4k|}
_ZNK13sentencepiece22SentencePieceProcessor6IsByteEi:
 1090|  3.14M|bool SentencePieceProcessor::IsByte(int id) const {
 1091|  3.14M|  RET_CHECK_OR_RETURN_DEFAULT(false);
  ------------------
  |  | 1021|  3.14M|  if (!status().ok()) {                                                      \
  |  |  ------------------
  |  |  |  Branch (1021:7): [True: 0, False: 3.14M]
  |  |  ------------------
  |  | 1022|      0|    LOG(ERROR) << status().message() << "\nReturns default value " << value; \
  |  |  ------------------
  |  |  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  |  |  ------------------
  |  |  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1023|      0|    return value;                                                            \
  |  | 1024|      0|  }
  ------------------
 1092|  3.14M|  return model_->IsByte(id);
 1093|  3.14M|}
_ZNK13sentencepiece22SentencePieceProcessor6unk_idEv:
 1095|  2.03k|int SentencePieceProcessor::unk_id() const {
 1096|  2.03k|  const int id = PieceToId(model_->unk_piece());
 1097|  2.03k|  return IsUnknown(id) ? id : -1;
  ------------------
  |  Branch (1097:10): [True: 2.02k, False: 12]
  ------------------
 1098|  2.03k|}
_ZNK13sentencepiece22SentencePieceProcessor6bos_idEv:
 1100|  2.03k|int SentencePieceProcessor::bos_id() const {
 1101|  2.03k|  const int id = PieceToId(model_->bos_piece());
 1102|  2.03k|  return IsControl(id) ? id : -1;
  ------------------
  |  Branch (1102:10): [True: 1.00k, False: 1.02k]
  ------------------
 1103|  2.03k|}
_ZNK13sentencepiece22SentencePieceProcessor6eos_idEv:
 1105|  2.03k|int SentencePieceProcessor::eos_id() const {
 1106|  2.03k|  const int id = PieceToId(model_->eos_piece());
 1107|  2.03k|  return IsControl(id) ? id : -1;
  ------------------
  |  Branch (1107:10): [True: 661, False: 1.37k]
  ------------------
 1108|  2.03k|}
_ZNK13sentencepiece22SentencePieceProcessor6pad_idEv:
 1110|  2.03k|int SentencePieceProcessor::pad_id() const {
 1111|  2.03k|  const int id = PieceToId(model_->pad_piece());
 1112|  2.03k|  return IsControl(id) ? id : -1;
  ------------------
  |  Branch (1112:10): [True: 0, False: 2.03k]
  ------------------
 1113|  2.03k|}
_ZNK13sentencepiece22SentencePieceProcessor17ApplyExtraOptionsERKNSt3__16vectorINS0_11ExtraOptionENS1_9allocatorIS3_EEEEPNS_17SentencePieceTextE:
 1118|  13.6k|    SentencePieceText *spt) const {
 1119|  13.6k|  for (const auto &extra_option : extra_options) {
  ------------------
  |  Branch (1119:33): [True: 0, False: 13.6k]
  ------------------
 1120|      0|    switch (extra_option) {
 1121|      0|      case REVERSE:
  ------------------
  |  Branch (1121:7): [True: 0, False: 0]
  ------------------
 1122|      0|        std::reverse(spt->mutable_pieces()->begin(),
 1123|      0|                     spt->mutable_pieces()->end());
 1124|      0|        break;
 1125|      0|      case EOS: {
  ------------------
  |  Branch (1125:7): [True: 0, False: 0]
  ------------------
 1126|      0|        auto *piece = spt->add_pieces();
 1127|      0|        piece->set_id(PieceToId(model_->eos_piece()));
 1128|      0|        piece->set_piece(model_->eos_piece().data(),
 1129|      0|                         model_->eos_piece().size());
 1130|      0|        piece->set_begin(spt->text().size());
 1131|      0|        piece->set_end(spt->text().size());
 1132|      0|      } break;
 1133|      0|      case BOS: {
  ------------------
  |  Branch (1133:7): [True: 0, False: 0]
  ------------------
 1134|      0|        auto *array = spt->mutable_pieces();
 1135|      0|        array->Add();
 1136|      0|        for (int i = array->size() - 1; i > 0; --i) {
  ------------------
  |  Branch (1136:41): [True: 0, False: 0]
  ------------------
 1137|      0|          array->SwapElements(i - 1, i);
 1138|      0|        }
 1139|      0|        auto *piece = array->Mutable(0);
 1140|      0|        piece->set_id(PieceToId(model_->bos_piece()));
 1141|      0|        piece->set_piece(model_->bos_piece().data(),
 1142|      0|                         model_->bos_piece().size());
 1143|      0|        piece->set_begin(0);
 1144|      0|        piece->set_end(0);
 1145|      0|      } break;
 1146|      0|      case UNK_PIECE: {
  ------------------
  |  Branch (1146:7): [True: 0, False: 0]
  ------------------
 1147|      0|        for (int i = 0; i < spt->pieces_size(); ++i) {
  ------------------
  |  Branch (1147:25): [True: 0, False: 0]
  ------------------
 1148|      0|          auto *piece = spt->mutable_pieces(i);
 1149|      0|          if (IsUnknown(piece->id())) {
  ------------------
  |  Branch (1149:15): [True: 0, False: 0]
  ------------------
 1150|      0|            piece->set_piece(model_->unk_piece().data(),
 1151|      0|                             model_->unk_piece().size());
 1152|      0|          }
 1153|      0|        }
 1154|      0|      } break;
 1155|      0|      default:
  ------------------
  |  Branch (1155:7): [True: 0, False: 0]
  ------------------
 1156|      0|        spt->Clear();
 1157|      0|        return util::InternalError("unknown extra_option type.");
 1158|      0|    }
 1159|      0|  }
 1160|       |
 1161|  13.6k|  return util::OkStatus();
 1162|  13.6k|}
_ZNK13sentencepiece22SentencePieceProcessor22serialized_model_protoEv:
 1212|  2.03k|std::string SentencePieceProcessor::serialized_model_proto() const {
 1213|  2.03k|  return model_proto_ ? model_proto_->SerializeAsString() : "";
  ------------------
  |  Branch (1213:10): [True: 2.03k, False: 0]
  ------------------
 1214|  2.03k|}
sentencepiece_processor.cc:_ZN13sentencepiece12_GLOBAL__N_112ToPieceArrayERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
   68|  3.88k|std::vector<absl::string_view> ToPieceArray(const std::vector<std::string> &v) {
   69|  3.88k|  std::vector<absl::string_view> out(v.size());
   70|  3.13M|  for (size_t i = 0; i < v.size(); ++i) out[i] = v[i];
  ------------------
  |  Branch (70:22): [True: 3.13M, False: 3.88k]
  ------------------
   71|  3.88k|  return out;
   72|  3.88k|}
sentencepiece_processor.cc:_ZZNK13sentencepiece22SentencePieceProcessor6DecodeERKNSt3__16vectorINS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS1_9allocatorIS6_EEEEPNS_17SentencePieceTextEENK3$_2clEii:
  924|  3.13M|                               int token_index_end) -> util::Status {
  925|  3.13M|    if (token_index_begin >= token_index_end) {
  ------------------
  |  Branch (925:9): [True: 3.13M, False: 36]
  ------------------
  926|  3.13M|      return util::OkStatus();
  927|  3.13M|    }
  928|       |
  929|       |    // Constructs byte sequence.
  930|     36|    std::string bytes;
  931|    692|    for (int i = token_index_begin; i < token_index_end; ++i) {
  ------------------
  |  Branch (931:37): [True: 656, False: 36]
  ------------------
  932|    656|      const auto &sp = spt->pieces(i);
  933|    656|      const int byte = PieceToByte(sp.piece());
  934|    656|      RET_CHECK_LE(0, byte);
  ------------------
  |  |  330|    656|#define RET_CHECK_LE(a, b) RET_CHECK((a) <= (b))
  |  |  ------------------
  |  |  |  |  321|    656|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 656, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|    656|  } else /* NOLINT */                                        \
  |  |  |  |  323|    656|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  935|    656|      bytes.append(1, byte);
  936|    656|    }
  937|       |
  938|       |    // Set surfaces of `bytes` for each Unicode character.
  939|     36|    int offset = 0;
  940|     36|    const int bytes_len = bytes.size();
  941|    448|    while (offset < bytes_len) {
  ------------------
  |  Branch (941:12): [True: 412, False: 36]
  ------------------
  942|       |      // Consume `bytes` by one Unicode character.
  943|    412|      size_t consumed;  // Number of bytes consumed in this iteration.
  944|    412|      const bool is_valid = string_util::IsValidDecodeUTF8(
  945|    412|          absl::string_view(bytes).substr(offset), &consumed);
  946|       |
  947|       |      // Set surfaces of the consumed byte pieces.
  948|    412|      const int token_index = token_index_begin + offset;
  949|       |
  950|    412|      if (!is_valid) {
  ------------------
  |  Branch (950:11): [True: 0, False: 412]
  ------------------
  951|       |        // The byte piece at `token_index` is structurally invalid. Map it to
  952|       |        // REPLACEMENT CHARACTER (U+FFFD).
  953|      0|        RET_CHECK_EQ(consumed, 1);
  ------------------
  |  |  327|      0|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|      0|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|      0|  } else /* NOLINT */                                        \
  |  |  |  |  323|      0|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  954|      0|        SetSurface(token_index, kReplacementCharacter);
  955|    412|      } else {
  956|    412|        const absl::string_view utf8 =
  957|    412|            absl::string_view(bytes).substr(offset, consumed);
  958|  1.06k|        for (size_t j = 0; j < consumed; j++) {
  ------------------
  |  Branch (958:28): [True: 656, False: 412]
  ------------------
  959|       |          // The last byte piece holds the surface of the original unknown
  960|       |          // character. The other byte pieces hold an empty string as
  961|       |          // surface.
  962|    656|          if (j == consumed - 1) {
  ------------------
  |  Branch (962:15): [True: 412, False: 244]
  ------------------
  963|    412|            SetSurface(token_index + j, utf8);
  964|    412|          } else {
  965|    244|            SetSurface(token_index + j, "");
  966|    244|          }
  967|    656|        }
  968|    412|      }
  969|    412|      offset += consumed;
  970|    412|    }
  971|     36|    RET_CHECK_EQ(token_index_begin + offset, token_index_end);
  ------------------
  |  |  327|     36|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|     36|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 36, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|     36|  } else /* NOLINT */                                        \
  |  |  |  |  323|     36|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  972|       |
  973|     36|    return util::OkStatus();
  974|     36|  };
sentencepiece_processor.cc:_ZZNK13sentencepiece22SentencePieceProcessor6DecodeERKNSt3__16vectorINS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS1_9allocatorIS6_EEEEPNS_17SentencePieceTextEENK3$_0clES6_ib:
  873|  3.13M|          bool is_bos_ws) -> std::pair<std::string, bool> {
  874|  3.13M|    if (IsControl(id)) {                 // <s>, </s>
  ------------------
  |  Branch (874:9): [True: 1.50k, False: 3.13M]
  ------------------
  875|  1.50k|      return std::make_pair("", false);  // invisible symbol.
  876|  3.13M|    } else if (IsUnknown(id)) {
  ------------------
  |  Branch (876:16): [True: 678k, False: 2.45M]
  ------------------
  877|   678k|      if (IdToPiece(id) == piece) {  // <unk>
  ------------------
  |  Branch (877:11): [True: 339k, False: 338k]
  ------------------
  878|   339k|        return std::make_pair(std::string(unk_surface), false);
  879|   339k|      } else {  // return piece when piece is not <unk>.
  880|   338k|        return std::make_pair(std::string(piece), false);
  881|   338k|      }
  882|   678k|    }
  883|       |
  884|  2.45M|    bool has_bos_ws = false;  // whether the token starts with a kSpaceSymbol
  885|  2.45M|    if (is_bos_ws &&
  ------------------
  |  Branch (885:9): [True: 2.59k, False: 2.44M]
  ------------------
  886|  2.59k|        (!model_proto_ ||
  ------------------
  |  Branch (886:10): [True: 0, False: 2.59k]
  ------------------
  887|  2.59k|         (model_proto_ &&
  ------------------
  |  Branch (887:11): [True: 2.59k, False: 0]
  ------------------
  888|  2.59k|          (model_proto_->normalizer_spec().add_dummy_prefix() ||
  ------------------
  |  Branch (888:12): [True: 2.58k, False: 10]
  ------------------
  889|  2.59k|           model_proto_->normalizer_spec().remove_extra_whitespaces())))) {
  ------------------
  |  Branch (889:12): [True: 10, False: 0]
  ------------------
  890|       |      // Consume if the current position is bos and
  891|       |      // piece starts with kSpaceSymbol.
  892|  2.59k|      has_bos_ws = absl::ConsumePrefix(&piece, kSpaceSymbol);
  893|       |
  894|  2.59k|      if (model_proto_ &&
  ------------------
  |  Branch (894:11): [True: 2.59k, False: 0]
  ------------------
  895|  2.59k|          model_proto_->normalizer_spec().remove_extra_whitespaces()) {
  ------------------
  |  Branch (895:11): [True: 2.58k, False: 4]
  ------------------
  896|       |        // if we are removing extra whitespace, we remove all leading whitespace
  897|  2.58k|        has_bos_ws = false;
  898|  2.58k|      }
  899|  2.59k|    }
  900|       |
  901|  2.45M|    return std::make_pair(absl::StrReplaceAll(piece, {{kSpaceSymbol, " "}}),
  902|  2.45M|                          has_bos_ws);
  903|  3.13M|  };
sentencepiece_processor.cc:_ZZNK13sentencepiece22SentencePieceProcessor6DecodeERKNSt3__16vectorINS1_17basic_string_viewIcNS1_11char_traitsIcEEEENS1_9allocatorIS6_EEEEPNS_17SentencePieceTextEENK3$_1clEiS6_:
  915|  3.13M|  auto SetSurface = [&](int index, absl::string_view surface) {
  916|  3.13M|    auto *sp = spt->mutable_pieces(index);
  917|  3.13M|    sp->set_surface(surface.data(), surface.size());
  918|  3.13M|    sp->set_begin(text->size());
  919|  3.13M|    sp->set_end(text->size() + surface.size());
  920|  3.13M|    absl::StrAppend(text, surface);
  921|  3.13M|  };

_ZN13sentencepiece7unigram7LatticeC2Ev:
   90|  1.50k|Lattice::Lattice() : node_allocator_(kPreallocateLatticeNodeSize) {}
_ZN13sentencepiece7unigram7LatticeD2Ev:
   91|  1.50k|Lattice::~Lattice() {}
_ZNK13sentencepiece7unigram7Lattice11begin_nodesEi:
   93|  1.50k|const std::vector<Lattice::Node *> &Lattice::begin_nodes(int pos) const {
   94|  1.50k|  return begin_nodes_[pos];
   95|  1.50k|}
_ZNK13sentencepiece7unigram7Lattice9end_nodesEi:
   97|   323M|const std::vector<Lattice::Node *> &Lattice::end_nodes(int pos) const {
   98|   323M|  return end_nodes_[pos];
   99|   323M|}
_ZNK13sentencepiece7unigram7Lattice4sizeEv:
  101|  6.02k|int Lattice::size() const {
  102|       |  // -1 because surface_ may include the EOS.
  103|  6.02k|  return std::max<int>(0, surface_.size() - 1);
  104|  6.02k|}
_ZNK13sentencepiece7unigram7Lattice9utf8_sizeEv:
  106|  1.50k|int Lattice::utf8_size() const { return sentence_.size(); }
_ZNK13sentencepiece7unigram7Lattice8sentenceEv:
  108|  1.50k|const char *Lattice::sentence() const { return sentence_.data(); }
_ZNK13sentencepiece7unigram7Lattice7surfaceEi:
  110|  43.2M|const char *Lattice::surface(int pos) const { return surface_[pos]; }
_ZNK13sentencepiece7unigram7Lattice8bos_nodeEv:
  112|  78.9M|Lattice::Node *Lattice::bos_node() const { return end_nodes_[0][0]; }
_ZNK13sentencepiece7unigram7Lattice8eos_nodeEv:
  114|  1.50k|Lattice::Node *Lattice::eos_node() const { return begin_nodes_[size()][0]; }
_ZN13sentencepiece7unigram7Lattice7NewNodeEv:
  116|  10.0M|Lattice::Node *Lattice::NewNode() {
  117|  10.0M|  Node *node = node_allocator_.Allocate();
  118|  10.0M|  node->node_id = node_allocator_.size() - 1;
  119|  10.0M|  return node;
  120|  10.0M|}
_ZN13sentencepiece7unigram7Lattice5ClearEv:
  122|  1.50k|void Lattice::Clear() {
  123|  1.50k|  begin_nodes_.clear();
  124|  1.50k|  end_nodes_.clear();
  125|  1.50k|  sentence_ = absl::string_view("");
  126|  1.50k|  surface_.clear();
  127|  1.50k|  node_allocator_.Free();
  128|  1.50k|}
_ZN13sentencepiece7unigram7Lattice11SetSentenceENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  130|  1.50k|void Lattice::SetSentence(absl::string_view sentence) {
  131|  1.50k|  Clear();
  132|       |
  133|  1.50k|  sentence_ = sentence;
  134|  1.50k|  surface_.reserve(sentence.size() + 1);
  135|       |
  136|  9.86M|  while (!sentence.empty()) {
  ------------------
  |  Branch (136:10): [True: 9.86M, False: 1.50k]
  ------------------
  137|  9.86M|    const int mblen = std::min<int>(string_util::OneCharLen(sentence.data()),
  138|  9.86M|                                    sentence.size());
  139|  9.86M|    surface_.push_back(sentence.data());
  140|  9.86M|    sentence.remove_prefix(mblen);
  141|  9.86M|  }
  142|  1.50k|  surface_.push_back(sentence.data());
  143|       |
  144|  1.50k|  const size_t len = size();
  145|  1.50k|  begin_nodes_.resize(len + 1);
  146|  1.50k|  end_nodes_.resize(len + 1);
  147|       |
  148|  1.50k|  constexpr size_t kReservedNodeSize = 16;
  149|  9.87M|  for (size_t i = 0; i <= len; ++i) {
  ------------------
  |  Branch (149:22): [True: 9.86M, False: 1.50k]
  ------------------
  150|  9.86M|    begin_nodes_[i].reserve(kReservedNodeSize);
  151|  9.86M|    end_nodes_[i].reserve(kReservedNodeSize);
  152|  9.86M|  }
  153|       |
  154|  1.50k|  Node *bos = NewNode();
  155|  1.50k|  bos->id = -1;
  156|  1.50k|  bos->pos = 0;
  157|  1.50k|  end_nodes_[0].push_back(bos);
  158|       |
  159|  1.50k|  Node *eos = NewNode();
  160|  1.50k|  eos->id = -1;
  161|  1.50k|  eos->pos = len;
  162|  1.50k|  begin_nodes_[len].push_back(eos);
  163|  1.50k|}
_ZN13sentencepiece7unigram7Lattice6InsertEii:
  165|  10.0M|Lattice::Node *Lattice::Insert(int pos, int length) {
  166|  10.0M|  Node *node = NewNode();
  167|  10.0M|  node->pos = pos;
  168|  10.0M|  node->length = length;
  169|  10.0M|  const int utf8_length =
  170|  10.0M|      static_cast<int>(surface(pos + length) - surface(pos));
  171|  10.0M|  node->piece = absl::string_view(surface(pos), utf8_length);
  172|  10.0M|  begin_nodes_[pos].push_back(node);
  173|  10.0M|  end_nodes_[pos + node->length].push_back(node);
  174|       |
  175|  10.0M|  return node;
  176|  10.0M|}
_ZN13sentencepiece7unigram7Lattice7ViterbiEv:
  178|  1.50k|Lattice::LatticePathWithScore Lattice::Viterbi() {
  179|  1.50k|  const size_t len = size();
  180|       |
  181|  9.87M|  for (size_t pos = 0; pos <= len; ++pos) {
  ------------------
  |  Branch (181:24): [True: 9.86M, False: 1.50k]
  ------------------
  182|  10.0M|    for (Node *rnode : begin_nodes_[pos]) {
  ------------------
  |  Branch (182:22): [True: 10.0M, False: 9.86M]
  ------------------
  183|  10.0M|      rnode->prev = nullptr;
  184|  10.0M|      float best_score = 0.0;
  185|  10.0M|      Node *best_node = nullptr;
  186|  10.4M|      for (Node *lnode : end_nodes_[pos]) {
  ------------------
  |  Branch (186:24): [True: 10.4M, False: 10.0M]
  ------------------
  187|  10.4M|        const float score = lnode->backtrace_score + rnode->score;
  188|  10.4M|        if (best_node == nullptr || score > best_score) {
  ------------------
  |  Branch (188:13): [True: 10.0M, False: 406k]
  |  Branch (188:37): [True: 8.65k, False: 397k]
  ------------------
  189|  10.0M|          best_node = lnode;
  190|  10.0M|          best_score = score;
  191|  10.0M|        }
  192|  10.4M|      }
  193|  10.0M|      if (best_node == nullptr) {
  ------------------
  |  Branch (193:11): [True: 0, False: 10.0M]
  ------------------
  194|      0|        LOG(ERROR) << "Failed to find the best path in Viterbi.";
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  195|      0|        return {};
  196|      0|      }
  197|  10.0M|      rnode->prev = best_node;
  198|  10.0M|      rnode->backtrace_score = best_score;
  199|  10.0M|    }
  200|  9.86M|  }
  201|       |
  202|       |  // backtrace
  203|  1.50k|  std::vector<Node *> results;
  204|  1.50k|  float score = begin_nodes(len)[0]->backtrace_score;
  205|  9.26M|  for (Node *node = begin_nodes_[len][0]->prev; node->prev != nullptr;
  ------------------
  |  Branch (205:49): [True: 9.26M, False: 1.50k]
  ------------------
  206|  9.26M|       node = node->prev) {
  207|  9.26M|    results.push_back(node);
  208|  9.26M|  }
  209|       |
  210|  1.50k|  std::reverse(results.begin(), results.end());
  211|       |
  212|  1.50k|  LatticePathWithScore retval = {results, score};
  213|       |
  214|  1.50k|  return retval;
  215|  1.50k|}
_ZN13sentencepiece7unigram7Lattice5NBestEmbf:
  364|  1.50k|                                                          float inv_theta) {
  365|  1.50k|  if (nbest_size < 1) {
  ------------------
  |  Branch (365:7): [True: 0, False: 1.50k]
  ------------------
  366|      0|    LOG(WARNING) << "nbest_size >= 1. Returns empty result.";
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  174|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|      0|  ::absl::log_internal::LogMessage(   \
  |  |  |  |  |  |   61|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::WarningTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  367|      0|    return {};
  368|      0|  }
  369|       |
  370|  1.50k|  if (nbest_size == 1 && !sample) {
  ------------------
  |  Branch (370:7): [True: 0, False: 1.50k]
  |  Branch (370:26): [True: 0, False: 0]
  ------------------
  371|      0|    return {Viterbi()};
  372|      0|  }
  373|       |
  374|       |  // Uses A* search to enumerate N-bests.
  375|       |  // Given a lattice, enumerates hypotheses (paths) from EOS.
  376|       |  // At each partial path x, compute f(x) as follows
  377|       |  //   f(x) = g(x) + h(x).
  378|       |  // g(x): the sum of scores from  EOS to the left-most node in x.
  379|       |  //       for a complete hypothesis, g(hyp) is the score of the hypothesis.
  380|       |  // h(x): a heuristic that estimates the largest score from x to BOS.
  381|       |  // f(x): the priority to pop a new hypothesis from the priority queue.
  382|       |  //
  383|       |  // As left-to-right Viterbi search can tell the *exact* value of h(x),
  384|       |  // we can obtain the exact n-best results with A*.
  385|       |
  386|  1.50k|  class HypothesisComparator {
  387|  1.50k|   public:
  388|  1.50k|    const bool operator()(Hypothesis *h1, Hypothesis *h2) {
  389|  1.50k|      return (h1->fx < h2->fx);
  390|  1.50k|    }
  391|  1.50k|  };
  392|       |
  393|  1.50k|  using Agenda = std::priority_queue<Hypothesis *, std::vector<Hypothesis *>,
  394|  1.50k|                                     HypothesisComparator>;
  395|  1.50k|  constexpr size_t kPreallocatedHypothesisSize = 512;
  396|  1.50k|  model::FreeList<Hypothesis> hypothesis_allocator(kPreallocatedHypothesisSize);
  397|       |
  398|  1.50k|  Agenda agenda;
  399|  1.50k|  std::vector<Lattice::LatticePathWithScore> results;
  400|       |
  401|  1.50k|  auto *eos = hypothesis_allocator.Allocate();
  402|  1.50k|  eos->node = eos_node();
  403|  1.50k|  eos->next = nullptr;
  404|  1.50k|  eos->gx = 0.0;
  405|       |
  406|  1.50k|  std::vector<float> alpha(node_allocator_.size(), 0.0);
  407|       |
  408|  1.50k|  if (sample) {
  ------------------
  |  Branch (408:7): [True: 0, False: 1.50k]
  ------------------
  409|       |    // Run forwards algorithm to get normalising constants
  410|      0|    alpha = ForwardAlgorithm(inv_theta);
  411|       |    // f(eos) = Gumbel(0), as it is the perturbed score of the entire lattice.
  412|      0|    eos->fx = Gumbel();
  413|  1.50k|  } else {
  414|       |    // Run Viterbi first to fill backtrace score.
  415|  1.50k|    Viterbi();
  416|  1.50k|    eos->fx = eos->node->backtrace_score;
  417|  1.50k|  }
  418|  1.50k|  agenda.push(eos);
  419|       |
  420|  1.50k|  int shrink_count = 0;  // Number of times agenda has shrunk. For logging only.
  421|  1.50k|  bool printed_memory_warning = false;  // For logging only.
  422|  78.9M|  while (!agenda.empty()) {
  ------------------
  |  Branch (422:10): [True: 78.9M, False: 943]
  ------------------
  423|  78.9M|    auto *top = agenda.top();
  424|  78.9M|    agenda.pop();
  425|  78.9M|    auto *node = top->node;
  426|       |
  427|       |    // Reaches to BOS
  428|  78.9M|    if (node == bos_node()) {
  ------------------
  |  Branch (428:9): [True: 2.06k, False: 78.9M]
  ------------------
  429|  2.06k|      results.resize(results.size() + 1);
  430|  13.0M|      for (auto *n = top->next; n->next != nullptr; n = n->next) {
  ------------------
  |  Branch (430:33): [True: 13.0M, False: 2.06k]
  ------------------
  431|  13.0M|        results.back().first.push_back(n->node);
  432|  13.0M|      }
  433|  2.06k|      results.back().second = top->fx;
  434|  2.06k|      if (results.size() == nbest_size) {
  ------------------
  |  Branch (434:11): [True: 563, False: 1.50k]
  ------------------
  435|    563|        break;
  436|    563|      }
  437|  1.50k|      continue;
  438|  2.06k|    }
  439|       |
  440|  78.9M|    const size_t end_nodes_size = end_nodes(node->pos).size();
  441|  78.9M|    std::vector<float> probs(end_nodes_size, 0.0);
  442|  78.9M|    std::vector<float> perturbed_probs(end_nodes_size, 0.0);
  443|  78.9M|    std::vector<double> adjusted_probs(end_nodes_size, 0.0);
  444|  78.9M|    const float Z = alpha[node->node_id];
  445|  78.9M|    if (sample) {
  ------------------
  |  Branch (445:9): [True: 0, False: 78.9M]
  ------------------
  446|      0|      float max_score = -1e8;
  447|       |      // Calculate the marginal and perturbed scores for stochastic search
  448|      0|      for (size_t i = 0; i < end_nodes(node->pos).size(); i++) {
  ------------------
  |  Branch (448:26): [True: 0, False: 0]
  ------------------
  449|      0|        Node *lnode = end_nodes(node->pos)[i];
  450|       |        // Calculate backwards transition score
  451|      0|        probs[i] =
  452|      0|            top->gx + alpha[lnode->node_id] + (inv_theta * lnode->score) - Z;
  453|      0|        perturbed_probs[i] = probs[i] + Gumbel();
  454|      0|        if (perturbed_probs[i] > max_score) {
  ------------------
  |  Branch (454:13): [True: 0, False: 0]
  ------------------
  455|      0|          max_score = perturbed_probs[i];
  456|      0|        }
  457|      0|      }
  458|       |      // Now constrain the sampled continuations to match the score of parent
  459|      0|      for (size_t i = 0; i < adjusted_probs.size(); i++) {
  ------------------
  |  Branch (459:26): [True: 0, False: 0]
  ------------------
  460|       |        // Use numerically stable version of truncated Gumbel:
  461|       |        // https://arxiv.org/pdf/1903.06059.pdf appendix B.3
  462|      0|        const float v = top->fx - perturbed_probs[i] +
  463|      0|                        std::log1p(-std::exp(perturbed_probs[i] - max_score));
  464|      0|        adjusted_probs[i] = top->fx - std::max(static_cast<float>(0.0), v) -
  465|      0|                            std::log1p(std::exp(-std::abs(v)));
  466|      0|      }
  467|      0|    }
  468|       |
  469|       |    // Expands new node ending at node->pos
  470|   161M|    for (size_t i = 0; i < end_nodes(node->pos).size(); i++) {
  ------------------
  |  Branch (470:24): [True: 83.0M, False: 78.9M]
  ------------------
  471|  83.0M|      Node *lnode = end_nodes(node->pos)[i];
  472|  83.0M|      auto *hyp = hypothesis_allocator.Allocate();
  473|  83.0M|      hyp->node = lnode;
  474|  83.0M|      if (sample) {
  ------------------
  |  Branch (474:11): [True: 0, False: 83.0M]
  ------------------
  475|      0|        hyp->gx = probs[i];
  476|      0|        hyp->fx = adjusted_probs[i];
  477|  83.0M|      } else {
  478|  83.0M|        hyp->gx = lnode->score + top->gx;  // just adds node->score
  479|  83.0M|        hyp->fx =
  480|  83.0M|            lnode->backtrace_score + top->gx;  // backtrace_score is h(node).
  481|  83.0M|      }
  482|  83.0M|      hyp->next = top;
  483|  83.0M|      agenda.push(hyp);
  484|  83.0M|    }
  485|       |
  486|  78.9M|    static constexpr int kOneBillion = 1000000000;  // 10^9.
  487|  78.9M|    if (hypothesis_allocator.size() >= kOneBillion) {
  ------------------
  |  Branch (487:9): [True: 0, False: 78.9M]
  ------------------
  488|      0|      if (!printed_memory_warning) {
  ------------------
  |  Branch (488:11): [True: 0, False: 0]
  ------------------
  489|      0|        printed_memory_warning = true;
  490|      0|        LOG(WARNING) << "Allocator size exceeds " << kOneBillion
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  174|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|      0|  ::absl::log_internal::LogMessage(   \
  |  |  |  |  |  |   61|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::WarningTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  491|      0|                     << " with an example of length " << this->size();
  492|      0|      }
  493|      0|    }
  494|       |
  495|       |    // When the input is too long or contains duplicated phrases,
  496|       |    // `agenda` will get extremely big. Here we avoid this case by
  497|       |    // dynamically shrinking the agenda.
  498|  78.9M|    constexpr int kMaxAgendaSize = 10000;
  499|  78.9M|    constexpr int kMinAgendaSize = 512;
  500|  78.9M|    if (agenda.size() >= kMaxAgendaSize) {
  ------------------
  |  Branch (500:9): [True: 365, False: 78.9M]
  ------------------
  501|       |      // Keeps the top `kMinAgendaSize` hypothesis.
  502|    365|      Agenda new_agenda;
  503|       |      // Keeps the top hypothesis and the ones on their "next" paths.
  504|    365|      model::FreeList<Hypothesis> new_allocator(kPreallocatedHypothesisSize);
  505|       |      // Map between old Hypothesis* and new Hypothesis*.
  506|    365|      absl::flat_hash_map<const Hypothesis *, Hypothesis *> clone_map;
  507|       |
  508|    365|      const size_t size = std::min<size_t>(kMinAgendaSize, nbest_size * 10);
  509|    365|      shrink_count++;
  510|  1.09k|      LOG(WARNING) << "Too big agenda size " << agenda.size()
  ------------------
  |  |  218|    365|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|    365|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  174|    365|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|    730|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|    730|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 365, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|    365|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 365]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|    365|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 365]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|    365|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|  2.92k|  ::absl::log_internal::LogMessage(   \
  |  |  |  |  |  |   61|  2.92k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::WarningTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  511|  1.09k|                   << ". Shrinking (round " << shrink_count << ") down to "
  512|  1.09k|                   << size << ".";
  513|  7.66k|      for (size_t i = 0; i < size; ++i) {
  ------------------
  |  Branch (513:26): [True: 7.30k, False: 365]
  ------------------
  514|  7.30k|        const Hypothesis *top_hyp = agenda.top();
  515|  7.30k|        Hypothesis *cloned_hyp =
  516|  7.30k|            CloneHypAndDependents(top_hyp, &clone_map, &new_allocator);
  517|  7.30k|        new_agenda.push(cloned_hyp);
  518|  7.30k|        agenda.pop();
  519|  7.30k|      }
  520|    365|      agenda = std::move(new_agenda);
  521|    365|      hypothesis_allocator = std::move(new_allocator);
  522|    365|    }
  523|  78.9M|  }
  524|       |
  525|  1.50k|  return results;
  526|  1.50k|}
_ZNK13sentencepiece7unigram5Model13PopulateNodesEPNS0_7LatticeE:
  561|  1.50k|void Model::PopulateNodes(Lattice *lattice) const {
  562|  1.50k|  auto get_chars_length = [&lattice](int begin_pos, const char *end) {
  563|  1.50k|    int pos = begin_pos;
  564|  1.50k|    while (lattice->surface(pos) < end) ++pos;
  565|  1.50k|    return pos - begin_pos;
  566|  1.50k|  };
  567|       |
  568|  1.50k|  const float unk_score = min_score() - kUnkPenalty;
  569|       |
  570|  1.50k|  const size_t len = lattice->size();
  571|  1.50k|  const char *end = lattice->sentence() + lattice->utf8_size();
  572|       |
  573|       |  // +1 just in case.
  574|  1.50k|  std::vector<Darts::DoubleArray::result_pair_type> trie_results(
  575|  1.50k|      trie_results_size_ + 1);
  576|       |
  577|  9.86M|  for (size_t begin_pos = 0; begin_pos < len; ++begin_pos) {
  ------------------
  |  Branch (577:30): [True: 9.86M, False: 1.50k]
  ------------------
  578|  9.86M|    const char *begin = lattice->surface(begin_pos);
  579|       |
  580|       |    // Finds all pieces which are prefix of surface(begin_pos).
  581|  9.86M|    const size_t num_nodes = trie_->commonPrefixSearch(
  582|  9.86M|        begin, trie_results.data(), trie_results.size(),
  583|  9.86M|        static_cast<int>(end - begin));
  584|  9.86M|    CHECK_LT(num_nodes, trie_results.size());
  ------------------
  |  |  124|  9.86M|  ABSL_LOG_INTERNAL_CHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   55|  9.86M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_LT, <, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  9.86M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 9.86M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  9.86M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  9.86M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  9.86M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  9.86M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  9.86M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  9.86M|    ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS, true)                         \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  180|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   75|      0|  ABSL_LOG_INTERNAL_CHECK(::absl::implicit_cast<const char* absl_nonnull>(     \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   76|      0|                              absl_log_internal_check_op_result))              \
  |  |  |  |  |  |   77|      0|      .InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  585|       |
  586|  9.86M|    bool has_single_node = false;
  587|       |
  588|       |    // Inserts pieces to the lattice.
  589|  11.0M|    for (size_t k = 0; k < num_nodes; ++k) {
  ------------------
  |  Branch (589:24): [True: 1.22M, False: 9.86M]
  ------------------
  590|  1.22M|      const int length =
  591|  1.22M|          get_chars_length(begin_pos, begin + trie_results[k].length);
  592|  1.22M|      const int id = trie_results[k].value;
  593|  1.22M|      if (IsUnusedInlined(id)) continue;
  ------------------
  |  Branch (593:11): [True: 371, False: 1.22M]
  ------------------
  594|  1.22M|      Lattice::Node *node = lattice->Insert(begin_pos, length);
  595|  1.22M|      node->id = id;  // the value of Trie stores vocab_id.
  596|       |      // User defined symbol receives extra bonus to always be selected.
  597|  1.22M|      node->score = IsUserDefinedInlined(id) ? GetUserDefinedScore(length)
  ------------------
  |  Branch (597:21): [True: 74.1k, False: 1.14M]
  ------------------
  598|  1.22M|                                             : GetScoreInlined(id);
  599|  1.22M|      if (!has_single_node && node->length == 1) {
  ------------------
  |  Branch (599:11): [True: 1.21M, False: 5.66k]
  |  Branch (599:31): [True: 1.00M, False: 215k]
  ------------------
  600|  1.00M|        has_single_node = true;
  601|  1.00M|      }
  602|  1.22M|    }
  603|       |
  604|  9.86M|    if (!has_single_node) {
  ------------------
  |  Branch (604:9): [True: 8.86M, False: 1.00M]
  ------------------
  605|  8.86M|      Lattice::Node *node = lattice->Insert(begin_pos, 1);
  606|  8.86M|      node->id = unk_id_;  // add UNK node.
  607|  8.86M|      node->score = unk_score;
  608|  8.86M|    }
  609|  9.86M|  }
  610|  1.50k|}
_ZNK13sentencepiece7unigram5Model9PieceToIdENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  612|  3.07M|int Model::PieceToId(absl::string_view piece) const {
  613|  3.07M|  auto it = reserved_id_map_.find(piece);
  614|  3.07M|  if (it != reserved_id_map_.end()) {
  ------------------
  |  Branch (614:7): [True: 331k, False: 2.74M]
  ------------------
  615|   331k|    return it->second;
  616|   331k|  }
  617|  2.74M|  int id = 0;
  618|  2.74M|  trie_->exactMatchSearch(piece.data(), id, piece.size());
  619|  2.74M|  return id == -1 ? unk_id_ : id;
  ------------------
  |  Branch (619:10): [True: 328k, False: 2.41M]
  ------------------
  620|  3.07M|}
_ZN13sentencepiece7unigram5Model9BuildTrieEPNSt3__16vectorINS2_4pairINS2_17basic_string_viewIcNS2_11char_traitsIcEEEEiEENS2_9allocatorIS9_EEEE:
  622|  2.45k|void Model::BuildTrie(std::vector<std::pair<absl::string_view, int>> *pieces) {
  623|  2.45k|  if (!status().ok()) return;
  ------------------
  |  Branch (623:7): [True: 830, False: 1.62k]
  ------------------
  624|       |
  625|  1.62k|  if (pieces->empty()) {
  ------------------
  |  Branch (625:7): [True: 3, False: 1.62k]
  ------------------
  626|      3|    status_ = util::InternalError("no pieces are loaded.");
  627|      3|    return;
  628|      3|  }
  629|       |
  630|       |  // sort by sentencepiece since DoubleArray::build()
  631|       |  // only accepts sorted strings.
  632|  1.62k|  sort(pieces->begin(), pieces->end());
  633|       |
  634|       |  // Makes key/value/length set for DoubleArrayTrie.
  635|  1.62k|  std::vector<const char *> key(pieces->size());
  636|  1.62k|  std::vector<size_t> length(pieces->size());
  637|  1.62k|  std::vector<int> value(pieces->size());
  638|  17.6k|  for (size_t i = 0; i < pieces->size(); ++i) {
  ------------------
  |  Branch (638:22): [True: 16.0k, False: 1.62k]
  ------------------
  639|  16.0k|    key[i] = (*pieces)[i].first.data();  // sorted piece.
  640|  16.0k|    length[i] = (*pieces)[i].first.size();
  641|  16.0k|    value[i] = (*pieces)[i].second;  // vocab_id
  642|  16.0k|  }
  643|       |
  644|  1.62k|  trie_ = std::make_unique<Darts::DoubleArray>();
  645|  1.62k|  if (trie_->build(key.size(), const_cast<char **>(&key[0]),
  ------------------
  |  Branch (645:7): [True: 0, False: 1.62k]
  ------------------
  646|  1.62k|                   const_cast<size_t *>(&length[0]), &value[0]) != 0) {
  647|      0|    status_ = util::InternalError("cannot build double-array.");
  648|      0|    return;
  649|      0|  }
  650|       |
  651|       |  // Computes the maximum number of shared prefixes in the trie.
  652|  1.62k|  const int kMaxTrieResultsSize = 1024;
  653|  1.62k|  std::vector<Darts::DoubleArray::result_pair_type> results(
  654|  1.62k|      kMaxTrieResultsSize);
  655|  1.62k|  trie_results_size_ = 0;
  656|  16.0k|  for (const auto &p : *pieces) {
  ------------------
  |  Branch (656:22): [True: 16.0k, False: 1.62k]
  ------------------
  657|  16.0k|    const int num_nodes = trie_->commonPrefixSearch(
  658|  16.0k|        p.first.data(), results.data(), results.size(), p.first.size());
  659|  16.0k|    trie_results_size_ = std::max(trie_results_size_, num_nodes);
  660|  16.0k|  }
  661|       |
  662|  1.62k|  pieces_.clear();
  663|       |
  664|  1.62k|  if (trie_results_size_ == 0)
  ------------------
  |  Branch (664:7): [True: 0, False: 1.62k]
  ------------------
  665|      0|    status_ = util::InternalError("no entry is found in the trie.");
  666|  1.62k|}
_ZN13sentencepiece7unigram5ModelC2ERKNS_10ModelProtoE:
  668|  2.45k|Model::Model(const ModelProto &model_proto) {
  669|  2.45k|  model_proto_ = &model_proto;
  670|       |
  671|  2.45k|  InitializePieces();
  672|       |
  673|  2.45k|  min_score_ = FLT_MAX;
  674|  1.29M|  for (const auto &sp : model_proto_->pieces()) {
  ------------------
  |  Branch (674:23): [True: 1.29M, False: 2.45k]
  ------------------
  675|  1.29M|    if (sp.type() == ModelProto::SentencePiece::NORMAL) {
  ------------------
  |  Branch (675:9): [True: 1.28M, False: 16.9k]
  ------------------
  676|  1.28M|      min_score_ = std::min(min_score_, sp.score());
  677|  1.28M|    }
  678|  1.29M|  }
  679|       |
  680|  2.45k|  std::vector<std::pair<absl::string_view, int>> pieces;
  681|  18.4k|  for (const auto &it : pieces_) pieces.emplace_back(it.first, it.second);
  ------------------
  |  Branch (681:23): [True: 18.4k, False: 2.45k]
  ------------------
  682|       |
  683|  2.45k|  BuildTrie(&pieces);
  684|  2.45k|}
_ZN13sentencepiece7unigram5ModelD2Ev:
  686|  2.45k|Model::~Model() {}
_ZNK13sentencepiece7unigram5Model6EncodeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  688|  8.18k|EncodeResult Model::Encode(absl::string_view normalized) const {
  689|  8.18k|  return EncodeOptimized(normalized);
  690|  8.18k|}
_ZNK13sentencepiece7unigram5Model11NBestEncodeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEi:
  693|  1.58k|                                     int nbest_size) const {
  694|  1.58k|  if (!status().ok() || normalized.empty()) {
  ------------------
  |  Branch (694:7): [True: 0, False: 1.58k]
  |  Branch (694:7): [True: 75, False: 1.50k]
  |  Branch (694:25): [True: 75, False: 1.50k]
  ------------------
  695|     75|    return {{{}, 0.0}};
  696|     75|  }
  697|       |
  698|  1.50k|  nbest_size = std::max<int>(1, std::min<int>(nbest_size, 1024));
  699|       |
  700|  1.50k|  if (nbest_size <= 1) {
  ------------------
  |  Branch (700:7): [True: 0, False: 1.50k]
  ------------------
  701|      0|    return {std::pair<EncodeResult, float>(Encode(normalized), 0.0)};
  702|      0|  }
  703|       |
  704|  1.50k|  Lattice lattice;
  705|  1.50k|  lattice.SetSentence(normalized);
  706|  1.50k|  PopulateNodes(&lattice);
  707|       |
  708|  1.50k|  NBestEncodeResult nbest_results;
  709|  2.06k|  for (const auto &nbest : lattice.NBest(nbest_size, false, 0.0)) {
  ------------------
  |  Branch (709:26): [True: 2.06k, False: 1.50k]
  ------------------
  710|  2.06k|    EncodeResult results;
  711|  13.0M|    for (const auto *node : nbest.first) {
  ------------------
  |  Branch (711:27): [True: 13.0M, False: 2.06k]
  ------------------
  712|  13.0M|      results.emplace_back(node->piece, node->id);
  713|  13.0M|    }
  714|  2.06k|    nbest_results.emplace_back(results, nbest.second);
  715|  2.06k|  }
  716|       |
  717|  1.50k|  return nbest_results;
  718|  1.50k|}
_ZNK13sentencepiece7unigram5Model23VerifyOutputsEquivalentENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_:
  863|    282|                                    absl::string_view actual) const {
  864|    282|  auto compute_unigram_model_score =
  865|    282|      [this](std::vector<absl::string_view> output_pieces) {
  866|    282|        float total_score = 0;
  867|    282|        const float unk_score = min_score() - kUnkPenalty;
  868|    282|        for (const auto p : output_pieces) {
  869|    282|          const auto id = PieceToId(p);
  870|    282|          if (id == unk_id_) {
  871|    282|            total_score += unk_score;
  872|    282|          } else {
  873|    282|            const int length = p.size();
  874|    282|            total_score += IsUserDefinedInlined(id)
  875|    282|                               ? GetUserDefinedScore(length)
  876|    282|                               : GetScoreInlined(id);
  877|    282|          }
  878|    282|        }
  879|    282|        return total_score;
  880|    282|      };
  881|    282|  const auto expected_score =
  882|    282|      compute_unigram_model_score(absl::StrSplit(expected, ' '));
  883|    282|  const auto actual_score =
  884|    282|      compute_unigram_model_score(absl::StrSplit(actual, ' '));
  885|    282|  if (std::abs(expected_score - actual_score) > kEpsilon) {
  ------------------
  |  Branch (885:7): [True: 120, False: 162]
  ------------------
  886|    360|    LOG(WARNING) << "Two sentence piece sequences are not equivalent! Left: "
  ------------------
  |  |  218|    120|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|    120|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  174|    120|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|    240|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|    240|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 120, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|    120|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 120]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|    120|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 120]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|    120|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|  1.20k|  ::absl::log_internal::LogMessage(   \
  |  |  |  |  |  |   61|  1.20k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::WarningTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  887|    360|                 << expected << ", Score: " << expected_score
  888|    360|                 << ". Right: " << actual << ", Score: " << actual_score << ".";
  889|    120|    return false;
  890|    120|  }
  891|    162|  return true;
  892|    282|}
_ZNK13sentencepiece7unigram5Model15EncodeOptimizedENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  894|  8.18k|EncodeResult Model::EncodeOptimized(absl::string_view normalized) const {
  895|       |  // An optimized Viterbi algorithm for unigram language models. Benchmarking
  896|       |  // results show that it generates almost identical outputs and achieves 2.1x
  897|       |  // speedup on average for 102 languages compared to the original
  898|       |  // implementation. It's based on the following three ideas:
  899|       |  //
  900|       |  // 1. Because it uses the *unigram* model:
  901|       |  //     best_score(x1, x2, …, xt) = best_score(x1, x2, …, x{t-1}) + score(xt)
  902|       |  // Deciding the best path (and score) can be decoupled into two isolated
  903|       |  // terms: (a) the best path ended before the last token `best_score(x1, x2, …,
  904|       |  // x{t-1})`, and (b) the last token and its `score(xt)`. The two terms are
  905|       |  // not related to each other at all.
  906|       |  //
  907|       |  // Therefore, we can compute once and store the *best_path ending at
  908|       |  // each character position*. In this way, when we know best_path_ends_at[M],
  909|       |  // we can reuse it to compute all the best_path_ends_at_[...] where the last
  910|       |  // token starts at the same character position M.
  911|       |  //
  912|       |  // This improves the time complexity from O(n*k*k) to O(n*k) because it
  913|       |  // eliminates the extra loop of recomputing the best path ending at the same
  914|       |  // position, where n is the input length and k is the maximum number of tokens
  915|       |  // that can be recognized starting at each position.
  916|       |  //
  917|       |  // 2. Again, because it uses the *unigram* model, we don’t need to actually
  918|       |  // store the lattice nodes. We still recognize all the tokens and lattice
  919|       |  // nodes from the input, but along identifying them, we use and discard them
  920|       |  // on the fly. There is no need to actually store them for best path Viterbi
  921|       |  // decoding. The only thing we need to store is the best_path ending at
  922|       |  // each character position.
  923|       |  //
  924|       |  // This improvement reduces the things needed to store in memory from O(n*k)
  925|       |  // to O(n), where n is the input length and k is the maximum number of tokens
  926|       |  // that can be recognized starting at each position.
  927|       |  //
  928|       |  // It also avoids the need of dynamic-size lattice node pool, because the
  929|       |  // number of things to store is fixed as n.
  930|       |  //
  931|       |  // 3. SentencePiece is designed to work with unicode, taking utf-8 encoding
  932|       |  // inputs. In the original implementation, the lattice positions are based on
  933|       |  // unicode positions. A mapping from unicode position to the utf-8 position is
  934|       |  // maintained to recover the utf-8 string piece.
  935|       |  //
  936|       |  // We found that it is sufficient and beneficial to directly work with utf-8
  937|       |  // positions:
  938|       |  //
  939|       |  // Firstly, it saves the conversion and mapping between unicode positions and
  940|       |  // utf-8 positions.
  941|       |  //
  942|       |  // Secondly, it reduces the number of fields we need to maintain in the
  943|       |  // node/path structure. Specifically, there are 8 fields defined in
  944|       |  // `Lattice::Node` used by the original encoder, but here in the optimized
  945|       |  // encoder we only need to define 3 fields in `BestPathNode`.
  946|       |
  947|  8.18k|  if (!status().ok() || normalized.empty()) {
  ------------------
  |  Branch (947:7): [True: 0, False: 8.18k]
  |  Branch (947:7): [True: 419, False: 7.76k]
  |  Branch (947:25): [True: 419, False: 7.76k]
  ------------------
  948|    419|    return {};
  949|    419|  }
  950|       |  // Represents the last node of the best path.
  951|  7.76k|  struct BestPathNode {
  952|  7.76k|    int id = -1;  // The vocab id. (maybe -1 for UNK)
  953|  7.76k|    float best_path_score =
  954|  7.76k|        0;  // The total score of the best path ending at this node.
  955|  7.76k|    int starts_at =
  956|  7.76k|        -1;  // The starting position (in utf-8) of this node. The entire best
  957|       |             // path can be constructed by backtracking along this link.
  958|  7.76k|  };
  959|  7.76k|  const size_t size = normalized.size();
  960|  7.76k|  const float unk_score = min_score() - kUnkPenalty;
  961|       |  // The ends are exclusive.
  962|  7.76k|  std::vector<BestPathNode> best_path_ends_at(size + 1);
  963|       |  // Generate lattice on-the-fly (not stored) and update best_path_ends_at.
  964|  7.76k|  size_t starts_at = 0;
  965|  49.3M|  while (starts_at < size) {
  ------------------
  |  Branch (965:10): [True: 49.3M, False: 7.76k]
  ------------------
  966|  49.3M|    std::size_t node_pos = 0;
  967|  49.3M|    std::size_t key_pos = starts_at;
  968|  49.3M|    const auto best_path_score_till_here =
  969|  49.3M|        best_path_ends_at[starts_at].best_path_score;
  970|  49.3M|    bool has_single_node = false;
  971|  49.3M|    const int mblen =
  972|  49.3M|        std::min<int>(string_util::OneCharLen(normalized.data() + starts_at),
  973|  49.3M|                      size - starts_at);
  974|  61.2M|    while (key_pos < size) {
  ------------------
  |  Branch (974:12): [True: 61.2M, False: 845]
  ------------------
  975|  61.2M|      const int ret =
  976|  61.2M|          trie_->traverse(normalized.data(), node_pos, key_pos, key_pos + 1);
  977|  61.2M|      if (ret == -2) break;
  ------------------
  |  Branch (977:11): [True: 49.3M, False: 11.9M]
  ------------------
  978|  11.9M|      if (ret >= 0 && ret < GetPieceSize()) {
  ------------------
  |  Branch (978:11): [True: 6.12M, False: 5.79M]
  |  Branch (978:23): [True: 6.12M, False: 0]
  ------------------
  979|  6.12M|        if (IsUnusedInlined(ret)) continue;
  ------------------
  |  Branch (979:13): [True: 1.85k, False: 6.11M]
  ------------------
  980|       |        // Update the best path node.
  981|  6.11M|        auto &target_node = best_path_ends_at[key_pos];
  982|  6.11M|        const auto length = (key_pos - starts_at);
  983|       |        // User defined symbol receives extra bonus to always be selected.
  984|  6.11M|        const auto score = IsUserDefinedInlined(ret)
  ------------------
  |  Branch (984:28): [True: 370k, False: 5.74M]
  ------------------
  985|  6.11M|                               ? GetUserDefinedScore(length)
  986|  6.11M|                               : GetScoreInlined(ret);
  987|  6.11M|        const auto candidate_best_path_score =
  988|  6.11M|            score + best_path_score_till_here;
  989|  6.11M|        if (target_node.starts_at == -1 ||
  ------------------
  |  Branch (989:13): [True: 6.10M, False: 11.7k]
  ------------------
  990|  6.11M|            candidate_best_path_score > target_node.best_path_score) {
  ------------------
  |  Branch (990:13): [True: 7.62k, False: 4.10k]
  ------------------
  991|  6.11M|          target_node.best_path_score = candidate_best_path_score;
  992|  6.11M|          target_node.starts_at = starts_at;
  993|  6.11M|          target_node.id = ret;
  994|  6.11M|        }
  995|  6.11M|        if (!has_single_node && length == static_cast<size_t>(mblen)) {
  ------------------
  |  Branch (995:13): [True: 6.10M, False: 10.1k]
  |  Branch (995:33): [True: 5.01M, False: 1.09M]
  ------------------
  996|  5.01M|          has_single_node = true;
  997|  5.01M|        }
  998|  6.11M|      }
  999|  11.9M|    }
 1000|  49.3M|    if (!has_single_node) {
  ------------------
  |  Branch (1000:9): [True: 44.3M, False: 5.01M]
  ------------------
 1001|  44.3M|      auto &target_node = best_path_ends_at[starts_at + mblen];
 1002|  44.3M|      const auto candidate_best_path_score =
 1003|  44.3M|          unk_score + best_path_score_till_here;
 1004|  44.3M|      if (target_node.starts_at == -1 ||
  ------------------
  |  Branch (1004:11): [True: 43.2M, False: 1.07M]
  ------------------
 1005|  43.2M|          candidate_best_path_score > target_node.best_path_score) {
  ------------------
  |  Branch (1005:11): [True: 25.0k, False: 1.05M]
  ------------------
 1006|  43.2M|        target_node.best_path_score = candidate_best_path_score;
 1007|  43.2M|        target_node.starts_at = starts_at;
 1008|  43.2M|        target_node.id = unk_id_;
 1009|  43.2M|      }
 1010|  44.3M|    }
 1011|       |    // Move by one unicode character.
 1012|  49.3M|    starts_at += mblen;
 1013|  49.3M|  }
 1014|       |  // Backtrack to identify the best path.
 1015|  7.76k|  EncodeResult results;
 1016|  7.76k|  results.reserve(size / 4 + 1);
 1017|  7.76k|  int ends_at = size;
 1018|  46.3M|  while (ends_at > 0) {
  ------------------
  |  Branch (1018:10): [True: 46.3M, False: 7.76k]
  ------------------
 1019|  46.3M|    const auto &node = best_path_ends_at[ends_at];
 1020|  46.3M|    results.emplace_back(
 1021|  46.3M|        normalized.substr(node.starts_at, ends_at - node.starts_at), node.id);
 1022|  46.3M|    ends_at = node.starts_at;
 1023|  46.3M|  }
 1024|  7.76k|  std::reverse(results.begin(), results.end());
 1025|  7.76k|  return results;
 1026|  8.18k|}
unigram_model.cc:_ZN13sentencepiece7unigram12_GLOBAL__N_121CloneHypAndDependentsEPKNS1_10HypothesisEPN4absl12lts_2026010713flat_hash_mapIS4_PS2_NS6_18container_internal6HashEqIS4_vE4HashENSB_2EqENSt3__19allocatorINSE_4pairIKS4_S8_EEEEEEPNS_5model8FreeListIS2_EE:
  333|  7.30k|    model::FreeList<Hypothesis> *allocator) {
  334|  7.30k|  Hypothesis *cloned = nullptr;
  335|  7.30k|  Hypothesis **result_callback = &cloned;
  336|       |
  337|       |  // Iteratively clone "to_clone" and its dependencies.
  338|       |  // The new pointer will be written back to *result_callback.
  339|  26.4M|  while (to_clone != nullptr) {
  ------------------
  |  Branch (339:10): [True: 26.4M, False: 365]
  ------------------
  340|       |    // If "to_clone" has already been cloned before, we just look up the result.
  341|  26.4M|    auto iter = clone_map->find(to_clone);
  342|  26.4M|    if (iter != clone_map->end()) {
  ------------------
  |  Branch (342:9): [True: 6.93k, False: 26.4M]
  ------------------
  343|  6.93k|      *result_callback = iter->second;
  344|  6.93k|      break;
  345|  6.93k|    }
  346|       |
  347|       |    // Allocate a new Hypothesis and copy the values.
  348|  26.4M|    Hypothesis *new_hyp = allocator->Allocate();
  349|  26.4M|    *new_hyp = *to_clone;
  350|  26.4M|    *result_callback = new_hyp;
  351|  26.4M|    clone_map->insert({to_clone, new_hyp});
  352|       |
  353|       |    // Move on to clone "to_clone->next".
  354|  26.4M|    to_clone = to_clone->next;
  355|  26.4M|    result_callback = &(new_hyp->next);
  356|  26.4M|  }
  357|  7.30k|  return cloned;
  358|  7.30k|}
unigram_model.cc:_ZZNK13sentencepiece7unigram5Model13PopulateNodesEPNS0_7LatticeEENK3$_0clEiPKc:
  562|  1.22M|  auto get_chars_length = [&lattice](int begin_pos, const char *end) {
  563|  1.22M|    int pos = begin_pos;
  564|  3.07M|    while (lattice->surface(pos) < end) ++pos;
  ------------------
  |  Branch (564:12): [True: 1.84M, False: 1.22M]
  ------------------
  565|  1.22M|    return pos - begin_pos;
  566|  1.22M|  };
unigram_model.cc:_ZN13sentencepiece7unigram12_GLOBAL__N_119GetUserDefinedScoreEi:
   76|   444k|inline float GetUserDefinedScore(int length) { return 0.1 * (length - 1); }
unigram_model.cc:_ZZNK13sentencepiece7unigram5Model23VerifyOutputsEquivalentENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_ENK3$_0clENS2_6vectorIS6_NS2_9allocatorIS6_EEEE:
  865|    564|      [this](std::vector<absl::string_view> output_pieces) {
  866|    564|        float total_score = 0;
  867|    564|        const float unk_score = min_score() - kUnkPenalty;
  868|  1.06k|        for (const auto p : output_pieces) {
  ------------------
  |  Branch (868:27): [True: 1.06k, False: 564]
  ------------------
  869|  1.06k|          const auto id = PieceToId(p);
  870|  1.06k|          if (id == unk_id_) {
  ------------------
  |  Branch (870:15): [True: 616, False: 452]
  ------------------
  871|    616|            total_score += unk_score;
  872|    616|          } else {
  873|    452|            const int length = p.size();
  874|    452|            total_score += IsUserDefinedInlined(id)
  ------------------
  |  Branch (874:28): [True: 0, False: 452]
  ------------------
  875|    452|                               ? GetUserDefinedScore(length)
  876|    452|                               : GetScoreInlined(id);
  877|    452|          }
  878|  1.06k|        }
  879|    564|        return total_score;
  880|    564|      };
unigram_model.cc:_ZZN13sentencepiece7unigram7Lattice5NBestEmbfEN20HypothesisComparatorclEPNS0_12_GLOBAL__N_110HypothesisES5_:
  388|  1.23G|    const bool operator()(Hypothesis *h1, Hypothesis *h2) {
  389|  1.23G|      return (h1->fx < h2->fx);
  390|  1.23G|    }

_ZNK13sentencepiece7unigram5Model22IsNBestEncodeAvailableEv:
  154|  4.74k|  bool IsNBestEncodeAvailable() const override { return true; }
_ZNK13sentencepiece7unigram5Model9min_scoreEv:
  158|  9.83k|  float min_score() const { return min_score_; }

_ZN13sentencepiece11string_util10DecodeUTF8EPKcS2_Pm:
   59|   121M|char32 DecodeUTF8(const char *begin, const char *end, size_t *mblen) {
   60|   121M|  const size_t len = end - begin;
   61|       |
   62|   121M|  if (static_cast<unsigned char>(begin[0]) < 0x80) {
  ------------------
  |  Branch (62:7): [True: 98.1M, False: 23.0M]
  ------------------
   63|  98.1M|    *mblen = 1;
   64|  98.1M|    return static_cast<unsigned char>(begin[0]);
   65|  98.1M|  } else if (len >= 2 && (begin[0] & 0xE0) == 0xC0) {
  ------------------
  |  Branch (65:14): [True: 23.0M, False: 2.65k]
  |  Branch (65:26): [True: 4.62M, False: 18.3M]
  ------------------
   66|  4.62M|    const char32 cp = (((begin[0] & 0x1F) << 6) | ((begin[1] & 0x3F)));
   67|  4.62M|    if (IsTrailByte(begin[1]) && cp >= 0x0080 && IsValidCodepoint(cp)) {
  ------------------
  |  Branch (67:9): [True: 2.53M, False: 2.08M]
  |  Branch (67:34): [True: 2.48M, False: 52.4k]
  |  Branch (67:50): [True: 2.48M, False: 0]
  ------------------
   68|  2.48M|      *mblen = 2;
   69|  2.48M|      return cp;
   70|  2.48M|    }
   71|  18.3M|  } else if (len >= 3 && (begin[0] & 0xF0) == 0xE0) {
  ------------------
  |  Branch (71:14): [True: 18.3M, False: 5.20k]
  |  Branch (71:26): [True: 2.13M, False: 16.2M]
  ------------------
   72|  2.13M|    const char32 cp = (((begin[0] & 0x0F) << 12) | ((begin[1] & 0x3F) << 6) |
   73|  2.13M|                       ((begin[2] & 0x3F)));
   74|  2.13M|    if (IsTrailByte(begin[1]) && IsTrailByte(begin[2]) && cp >= 0x0800 &&
  ------------------
  |  Branch (74:9): [True: 263k, False: 1.87M]
  |  Branch (74:34): [True: 188k, False: 75.0k]
  |  Branch (74:59): [True: 187k, False: 571]
  ------------------
   75|   187k|        IsValidCodepoint(cp)) {
  ------------------
  |  Branch (75:9): [True: 187k, False: 546]
  ------------------
   76|   187k|      *mblen = 3;
   77|   187k|      return cp;
   78|   187k|    }
   79|  16.2M|  } else if (len >= 4 && (begin[0] & 0xf8) == 0xF0) {
  ------------------
  |  Branch (79:14): [True: 16.2M, False: 7.23k]
  |  Branch (79:26): [True: 239k, False: 16.0M]
  ------------------
   80|   239k|    const char32 cp = (((begin[0] & 0x07) << 18) | ((begin[1] & 0x3F) << 12) |
   81|   239k|                       ((begin[2] & 0x3F) << 6) | ((begin[3] & 0x3F)));
   82|   239k|    if (IsTrailByte(begin[1]) && IsTrailByte(begin[2]) &&
  ------------------
  |  Branch (82:9): [True: 31.6k, False: 208k]
  |  Branch (82:34): [True: 13.2k, False: 18.4k]
  ------------------
   83|  13.2k|        IsTrailByte(begin[3]) && cp >= 0x10000 && IsValidCodepoint(cp)) {
  ------------------
  |  Branch (83:9): [True: 8.78k, False: 4.47k]
  |  Branch (83:34): [True: 8.60k, False: 182]
  |  Branch (83:51): [True: 7.47k, False: 1.13k]
  ------------------
   84|  7.47k|      *mblen = 4;
   85|  7.47k|      return cp;
   86|  7.47k|    }
   87|   239k|  }
   88|       |
   89|       |  // Invalid UTF-8.
   90|  20.3M|  *mblen = 1;
   91|  20.3M|  return kUnicodeError;
   92|   121M|}

_ZN13sentencepiece4util13StatusBuilderC2ENS0_10StatusCodeE:
  304|  5.79k|  explicit StatusBuilder(StatusCode code) : code_(code) {}
_ZNK13sentencepiece4util13StatusBuildercvNS0_6StatusEEv:
  313|  5.79k|  operator Status() const { return Status(code_, os_.str()); }
_ZN13sentencepiece4util13InternalErrorENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  276|  1.16k|  inline util::Status FUNC##Error(absl::string_view str) { \
  277|  1.16k|    return util::Status(StatusCode::k##FUNC, str.data());  \
  278|  1.16k|  }                                                        \
_ZN13sentencepiece4util8OkStatusEv:
  273|   145M|inline Status OkStatus() { return Status(); }
_ZN13sentencepiece11string_util10OneCharLenEPKc:
  106|   203M|inline size_t OneCharLen(const char *src) {
  107|   203M|  return "\1\1\1\1\1\1\1\1\1\1\1\1\2\2\3\4"[(*src & 0xFF) >> 4];
  108|   203M|}
_ZN13sentencepiece11string_util17IsValidDecodeUTF8ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPm:
  128|   121M|inline bool IsValidDecodeUTF8(absl::string_view input, size_t *mblen) {
  129|   121M|  const char32 c = DecodeUTF8(input, mblen);
  130|   121M|  return c != kUnicodeError || *mblen == 3;
  ------------------
  |  Branch (130:10): [True: 100M, False: 20.3M]
  |  Branch (130:32): [True: 1.66k, False: 20.3M]
  ------------------
  131|   121M|}
_ZN13sentencepiece11string_util10DecodeUTF8ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPm:
  124|   121M|inline char32 DecodeUTF8(absl::string_view input, size_t *mblen) {
  125|   121M|  return DecodeUTF8(input.data(), input.data() + input.size(), mblen);
  126|   121M|}
_ZN13sentencepiece4util13StatusBuilderlsIA31_cEERS1_RKT_:
  308|  5.79k|  StatusBuilder &operator<<(const T &value) {
  309|  5.79k|    os_ << value;
  310|  5.79k|    return *this;
  311|  5.79k|  }
_ZN13sentencepiece4util13StatusBuilderlsIA2_cEERS1_RKT_:
  308|  5.79k|  StatusBuilder &operator<<(const T &value) {
  309|  5.79k|    os_ << value;
  310|  5.79k|    return *this;
  311|  5.79k|  }
_ZN13sentencepiece4util13StatusBuilderlsIiEERS1_RKT_:
  308|  5.79k|  StatusBuilder &operator<<(const T &value) {
  309|  5.79k|    os_ << value;
  310|  5.79k|    return *this;
  311|  5.79k|  }
_ZN13sentencepiece4util13StatusBuilderlsIA4_cEERS1_RKT_:
  308|  5.79k|  StatusBuilder &operator<<(const T &value) {
  309|  5.79k|    os_ << value;
  310|  5.79k|    return *this;
  311|  5.79k|  }
_ZN13sentencepiece4util13StatusBuilderlsIA66_cEERS1_RKT_:
  308|  4.52k|  StatusBuilder &operator<<(const T &value) {
  309|  4.52k|    os_ << value;
  310|  4.52k|    return *this;
  311|  4.52k|  }
_ZN13sentencepiece4util13StatusBuilderlsIA3_cEERS1_RKT_:
  308|  5.79k|  StatusBuilder &operator<<(const T &value) {
  309|  5.79k|    os_ << value;
  310|  5.79k|    return *this;
  311|  5.79k|  }
_ZN13sentencepiece4util13StatusBuilderlsIA34_cEERS1_RKT_:
  308|    826|  StatusBuilder &operator<<(const T &value) {
  309|    826|    os_ << value;
  310|    826|    return *this;
  311|    826|  }
_ZN13sentencepiece4util13StatusBuilderlsIA44_cEERS1_RKT_:
  308|     72|  StatusBuilder &operator<<(const T &value) {
  309|     72|    os_ << value;
  310|     72|    return *this;
  311|     72|  }
_ZN13sentencepiece4util13StatusBuilderlsIA33_cEERS1_RKT_:
  308|    452|  StatusBuilder &operator<<(const T &value) {
  309|    452|    os_ << value;
  310|    452|    return *this;
  311|    452|  }
_ZN13sentencepiece4util13StatusBuilderlsIA52_cEERS1_RKT_:
  308|    452|  StatusBuilder &operator<<(const T &value) {
  309|    452|    os_ << value;
  310|    452|    return *this;
  311|    452|  }
_ZN13sentencepiece4util13StatusBuilderlsIA53_cEERS1_RKT_:
  308|    754|  StatusBuilder &operator<<(const T &value) {
  309|    754|    os_ << value;
  310|    754|    return *this;
  311|    754|  }
_ZN13sentencepiece11string_util11IsTrailByteEc:
  112|  7.30M|inline bool IsTrailByte(char x) { return static_cast<signed char>(x) < -0x40; }
_ZN13sentencepiece11string_util16IsValidCodepointEj:
  114|  2.68M|inline bool IsValidCodepoint(char32 c) {
  115|  2.68M|  return (static_cast<uint32_t>(c) < 0xD800) || (c >= 0xE000 && c <= 0x10FFFF);
  ------------------
  |  Branch (115:10): [True: 2.66M, False: 14.0k]
  |  Branch (115:50): [True: 13.5k, False: 546]
  |  Branch (115:65): [True: 12.4k, False: 1.13k]
  ------------------
  116|  2.68M|}
_ZN13sentencepiece4port18InsertIfNotPresentIN4absl12lts_2026010713flat_hash_mapINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEiNS3_18container_internal10StringHashENSA_8StringEqENS5_9allocatorINS5_4pairIKS9_iEEEEEEEEbPT_RKNSJ_10value_type10first_typeERKNSL_11second_typeE:
  183|  43.9k|    const typename Collection::value_type::second_type &value) {
  184|  43.9k|  return InsertIfNotPresent(collection,
  185|  43.9k|                            typename Collection::value_type(key, value));
  186|  43.9k|}
_ZN13sentencepiece4port18InsertIfNotPresentIN4absl12lts_2026010713flat_hash_mapINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEiNS3_18container_internal10StringHashENSA_8StringEqENS5_9allocatorINS5_4pairIKS9_iEEEEEEEEbPT_RKNSJ_10value_typeE:
  175|  43.9k|                        const typename Collection::value_type &vt) {
  176|  43.9k|  return collection->insert(vt).second;
  177|  43.9k|}
_ZN13sentencepiece11string_util9DecodePODIjEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_:
   70|     20|inline bool DecodePOD(absl::string_view str, T *result) {
   71|     20|  static_assert(std::is_trivially_copyable<T>::value,
   72|     20|                "T must be trivially copyable");
   73|     20|  if (sizeof(*result) != str.size()) {
  ------------------
  |  Branch (73:7): [True: 0, False: 20]
  ------------------
   74|      0|    return false;
   75|      0|  }
   76|     20|  std::memcpy(result, str.data(), sizeof(T));
   77|     20|  return true;
   78|     20|}

_ZN13sentencepiece4word5ModelC2ERKNS_10ModelProtoE:
   22|    286|Model::Model(const ModelProto &model_proto) {
   23|    286|  model_proto_ = &model_proto;
   24|    286|  InitializePieces();
   25|    286|}
_ZN13sentencepiece4word5ModelD2Ev:
   27|    286|Model::~Model() {}
_ZNK13sentencepiece4word5Model6EncodeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   29|    777|EncodeResult Model::Encode(absl::string_view normalized) const {
   30|    777|  if (!status().ok() || normalized.empty()) {
  ------------------
  |  Branch (30:7): [True: 0, False: 777]
  |  Branch (30:7): [True: 16, False: 761]
  |  Branch (30:25): [True: 16, False: 761]
  ------------------
   31|     16|    return {};
   32|     16|  }
   33|       |
   34|    761|  EncodeResult output;
   35|   107k|  for (const auto &w : SplitIntoWords(normalized)) {
  ------------------
  |  Branch (35:22): [True: 107k, False: 761]
  ------------------
   36|   107k|    output.emplace_back(w, PieceToId(w));
   37|   107k|  }
   38|       |
   39|    761|  return output;
   40|    777|}

_ZN4absl12lts_2026010713base_internal11ControlWordEPNS0_9once_flagE:
  194|    661|    once_flag* absl_nonnull flag) {
  195|    661|  return &flag->control_;
  196|    661|}
_ZN4absl12lts_2026010713base_internal16SchedulingHelperC2ENS1_14SchedulingModeE:
  118|      1|  explicit SchedulingHelper(base_internal::SchedulingMode mode) : mode_(mode) {
  119|      1|    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
  ------------------
  |  Branch (119:9): [True: 0, False: 1]
  ------------------
  120|      0|      guard_result_ = base_internal::SchedulingGuard::DisableRescheduling();
  121|      0|    }
  122|      1|  }
_ZN4absl12lts_2026010713base_internal16SchedulingHelperD2Ev:
  124|      1|  ~SchedulingHelper() {
  125|      1|    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
  ------------------
  |  Branch (125:9): [True: 0, False: 1]
  ------------------
  126|      0|      base_internal::SchedulingGuard::EnableRescheduling(guard_result_);
  127|      0|    }
  128|      1|  }
log_sink_set.cc:_ZN4absl12lts_202601079call_onceIZNS0_12log_internal12_GLOBAL__N_113StderrLogSink4SendERKNS0_8LogEntryEEUlvE_JEEEvRNS0_9once_flagEOT_DpOT0_:
  214|    661|    call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  215|    661|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  216|    661|  uint32_t s = once->load(std::memory_order_acquire);
  217|    661|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  189|    661|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 660]
  |  |  |  Branch (189:49): [Folded, False: 661]
  |  |  |  Branch (189:58): [True: 1, False: 660]
  |  |  ------------------
  ------------------
  218|      1|    base_internal::CallOnceImpl(
  219|      1|        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
  220|      1|        std::forward<Callable>(fn), std::forward<Args>(args)...);
  221|      1|  }
  222|    661|}
log_sink_set.cc:_ZN4absl12lts_2026010713base_internal12CallOnceImplIZNS0_12log_internal12_GLOBAL__N_113StderrLogSink4SendERKNS0_8LogEntryEEUlvE_JEEEvPNSt3__16atomicIjEENS1_14SchedulingModeEOT_DpOT0_:
  155|      1|                 Args&&... args) {
  156|       |#ifndef NDEBUG
  157|       |  {
  158|       |    uint32_t old_control = control->load(std::memory_order_relaxed);
  159|       |    if (old_control != kOnceInit &&
  160|       |        old_control != kOnceRunning &&
  161|       |        old_control != kOnceWaiter &&
  162|       |        old_control != kOnceDone) {
  163|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  164|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  165|       |    }
  166|       |  }
  167|       |#endif  // NDEBUG
  168|      1|  static const base_internal::SpinLockWaitTransition trans[] = {
  169|      1|      {kOnceInit, kOnceRunning, true},
  170|      1|      {kOnceRunning, kOnceWaiter, false},
  171|      1|      {kOnceDone, kOnceDone, true}};
  172|       |
  173|       |  // Must do this before potentially modifying control word's state.
  174|      1|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  175|       |  // Short circuit the simplest case to avoid procedure call overhead.
  176|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  177|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  178|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  179|      1|  uint32_t old_control = kOnceInit;
  180|      1|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (180:7): [True: 1, False: 0]
  ------------------
  181|      1|                                       std::memory_order_relaxed) ||
  182|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   46|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (182:7): [True: 0, False: 0]
  ------------------
  183|      1|                                  scheduling_mode) == kOnceInit) {
  184|      1|    std::invoke(std::forward<Callable>(fn), std::forward<Args>(args)...);
  185|      1|    old_control =
  186|      1|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  187|      1|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (187:9): [True: 0, False: 1]
  ------------------
  188|      0|      base_internal::SpinLockWake(control, true);
  189|      0|    }
  190|      1|  }  // else *control is already kOnceDone
  191|      1|}

_ZN4absl12lts_2026010713little_endian10FromHost16Et:
  103|    661|inline uint16_t FromHost16(uint16_t x) { return x; }
_ZN4absl12lts_2026010713little_endian10FromHost64Em:
  109|  4.47k|inline uint64_t FromHost64(uint64_t x) { return x; }
_ZN4absl12lts_2026010713little_endian7Store16EPvt:
  164|    661|inline void Store16(void* absl_nonnull p, uint16_t v) {
  165|    661|  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
  ------------------
  |  |   81|    661|  (absl::base_internal::UnalignedStore16(_p, _val))
  ------------------
  166|    661|}
_ZN4absl12lts_2026010713little_endian6Load64EPKv:
  176|    732|inline uint64_t Load64(const void* absl_nonnull p) {
  177|    732|  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
  ------------------
  |  |   78|    732|  (absl::base_internal::UnalignedLoad64(_p))
  ------------------
  178|    732|}
_ZN4absl12lts_2026010713little_endian7Store64EPvm:
  180|  4.47k|inline void Store64(void* absl_nonnull p, uint64_t v) {
  181|  4.47k|  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
  ------------------
  |  |   85|  4.47k|  (absl::base_internal::UnalignedStore64(_p, _val))
  ------------------
  182|  4.47k|}

_ZN4absl12lts_2026010713base_internal10ErrnoSaverC2Ev:
   31|    661|  ErrnoSaver() : saved_errno_(errno) {}
_ZN4absl12lts_2026010713base_internal10ErrnoSaverD2Ev:
   32|    661|  ~ErrnoSaver() { errno = saved_errno_; }

_ZN4absl12lts_2026010713base_internal6GetTIDEv:
  400|      1|pid_t GetTID() {
  401|       |  return static_cast<pid_t>(syscall(SYS_gettid));
  402|      1|}
_ZN4absl12lts_2026010713base_internal12GetCachedTIDEv:
  483|    661|pid_t GetCachedTID() {
  484|    661|#ifdef ABSL_HAVE_THREAD_LOCAL
  485|    661|  static thread_local pid_t thread_id = GetTID();
  486|    661|  return thread_id;
  487|       |#else
  488|       |  return GetTID();
  489|       |#endif  // ABSL_HAVE_THREAD_LOCAL
  490|    661|}

_ZN4absl12lts_2026010713base_internal16UnalignedStore16EPvt:
   57|    661|inline void UnalignedStore16(void* absl_nonnull p, uint16_t v) {
   58|    661|  memcpy(p, &v, sizeof v);
   59|    661|}
_ZN4absl12lts_2026010713base_internal16UnalignedStore64EPvm:
   65|  4.47k|inline void UnalignedStore64(void* absl_nonnull p, uint64_t v) {
   66|  4.47k|  memcpy(p, &v, sizeof v);
   67|  4.47k|}

_ZN4absl12lts_2026010715LogSeverityNameENS0_11LogSeverityE:
  101|    661|constexpr const char* LogSeverityName(absl::LogSeverity s) {
  102|    661|  switch (s) {
  ------------------
  |  Branch (102:11): [True: 661, False: 0]
  ------------------
  103|    176|    case absl::LogSeverity::kInfo: return "INFO";
  ------------------
  |  Branch (103:5): [True: 176, False: 485]
  ------------------
  104|    485|    case absl::LogSeverity::kWarning: return "WARNING";
  ------------------
  |  Branch (104:5): [True: 485, False: 176]
  ------------------
  105|      0|    case absl::LogSeverity::kError: return "ERROR";
  ------------------
  |  Branch (105:5): [True: 0, False: 661]
  ------------------
  106|      0|    case absl::LogSeverity::kFatal: return "FATAL";
  ------------------
  |  Branch (106:5): [True: 0, False: 661]
  ------------------
  107|    661|  }
  108|      0|  return "UNKNOWN";
  109|    661|}
_ZN4absl12lts_2026010720NormalizeLogSeverityENS0_11LogSeverityE:
  115|    661|constexpr absl::LogSeverity NormalizeLogSeverity(absl::LogSeverity s) {
  116|    661|  absl::LogSeverity n = s;
  117|    661|  if (n < absl::LogSeverity::kInfo) n = absl::LogSeverity::kInfo;
  ------------------
  |  Branch (117:7): [True: 0, False: 661]
  ------------------
  118|    661|  if (n > absl::LogSeverity::kFatal) n = absl::LogSeverity::kError;
  ------------------
  |  Branch (118:7): [True: 0, False: 661]
  ------------------
  119|    661|  return n;
  120|    661|}
_ZN4absl12lts_20260107ltENS0_11LogSeverityENS0_18LogSeverityAtLeastE:
  165|  1.32k|  constexpr bool operator op2(absl::LogSeverity lhs, absl::T rhs) { \
  166|  1.32k|    return lhs op2 static_cast<absl::LogSeverity>(rhs);             \
  167|  1.32k|  }

log_sink_set.cc:_ZN4absl12lts_2026010712NoDestructorINS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSetEEC2IJETnNSt3__19enable_ifIXntsr3std7is_sameIFvDpRu7__decayIT_EEFvRS5_EEE5valueEiE4typeELi0EEEDpOS9_:
  122|      1|      : impl_(std::forward<Ts>(args)...) {}
log_sink_set.cc:_ZN4absl12lts_2026010712NoDestructorINS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSetEE13PlacementImplC2IJEEEDpOT_:
  160|      1|    explicit PlacementImpl(Args&&... args) {
  161|      1|      new (&space_) T(std::forward<Args>(args)...);
  162|      1|    }
log_sink_set.cc:_ZN4absl12lts_2026010712NoDestructorINS0_12log_internal12_GLOBAL__N_113StderrLogSinkEEC2IJETnNSt3__19enable_ifIXntsr3std7is_sameIFvDpRu7__decayIT_EEFvRS5_EEE5valueEiE4typeELi0EEEDpOS9_:
  122|      1|      : impl_(std::forward<Ts>(args)...) {}
log_sink_set.cc:_ZN4absl12lts_2026010712NoDestructorINS0_12log_internal12_GLOBAL__N_113StderrLogSinkEE13PlacementImplC2IJEEEDpOT_:
  160|      1|    explicit PlacementImpl(Args&&... args) {
  161|      1|      new (&space_) T(std::forward<Args>(args)...);
  162|      1|    }
log_sink_set.cc:_ZN4absl12lts_2026010712NoDestructorINS0_12log_internal12_GLOBAL__N_113StderrLogSinkEE3getEv:
  139|      1|  T* absl_nonnull get() { return impl_.get(); }
log_sink_set.cc:_ZN4absl12lts_2026010712NoDestructorINS0_12log_internal12_GLOBAL__N_113StderrLogSinkEE13PlacementImpl3getEv:
  166|      1|    T* absl_nonnull get() {
  167|      1|      return std::launder(reinterpret_cast<T*>(&space_));
  168|      1|    }
log_sink_set.cc:_ZN4absl12lts_2026010712NoDestructorINS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSetEEdeEv:
  137|    661|  T& operator*() { return *get(); }
log_sink_set.cc:_ZN4absl12lts_2026010712NoDestructorINS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSetEE3getEv:
  139|    661|  T* absl_nonnull get() { return impl_.get(); }
log_sink_set.cc:_ZN4absl12lts_2026010712NoDestructorINS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSetEE13PlacementImpl3getEv:
  166|    661|    T* absl_nonnull get() {
  167|    661|      return std::launder(reinterpret_cast<T*>(&space_));
  168|    661|    }

log_sink_set.cc:_ZN4absl12lts_2026010711MakeCleanupIJEZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_EENS0_7CleanupINS0_16cleanup_internal3TagET0_EESG_:
  129|    661|absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback) {
  130|    661|  static_assert(cleanup_internal::WasDeduced<cleanup_internal::Tag, Args...>(),
  131|    661|                "Explicit template parameters are not supported.");
  132|       |
  133|    661|  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
  134|    661|                "Callbacks that return values are not supported.");
  135|       |
  136|    661|  return {std::move(callback)};
  137|    661|}
log_sink_set.cc:_ZN4absl12lts_202601077CleanupINS0_16cleanup_internal3TagEZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_EC2ESE_:
   93|    661|  Cleanup(Callback callback) : storage_(std::move(callback)) {}  // NOLINT
log_sink_set.cc:_ZN4absl12lts_202601077CleanupINS0_16cleanup_internal3TagEZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_ED2Ev:
  108|    661|  ~Cleanup() {
  109|    661|    if (storage_.IsCallbackEngaged()) {
  ------------------
  |  Branch (109:9): [True: 661, False: 0]
  ------------------
  110|    661|      storage_.InvokeCallback();
  111|    661|      storage_.DestroyCallback();
  112|    661|    }
  113|    661|  }

log_sink_set.cc:_ZN4absl12lts_2026010716cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_EC2ESD_:
   49|    661|  explicit Storage(Callback callback) {
   50|       |    // Placement-new into a character buffer is used for eager destruction when
   51|       |    // the cleanup is invoked or cancelled. To ensure this optimizes well, the
   52|       |    // behavior is implemented locally instead of using an absl::optional.
   53|    661|    ::new (GetCallbackBuffer()) Callback(std::move(callback));
   54|    661|    is_callback_engaged_ = true;
   55|    661|  }
log_sink_set.cc:_ZN4absl12lts_2026010716cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E17GetCallbackBufferEv:
   72|  1.98k|  void* GetCallbackBuffer() { return static_cast<void*>(callback_buffer_); }
log_sink_set.cc:_ZNK4absl12lts_2026010716cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E17IsCallbackEngagedEv:
   78|    661|  bool IsCallbackEngaged() const { return is_callback_engaged_; }
log_sink_set.cc:_ZN4absl12lts_2026010716cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E14InvokeCallbackEv:
   85|    661|  void InvokeCallback() ABSL_NO_THREAD_SAFETY_ANALYSIS {
   86|    661|    std::move(GetCallback())();
   87|    661|  }
log_sink_set.cc:_ZN4absl12lts_2026010716cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E11GetCallbackEv:
   74|  1.32k|  Callback& GetCallback() {
   75|  1.32k|    return *reinterpret_cast<Callback*>(GetCallbackBuffer());
   76|  1.32k|  }
log_sink_set.cc:_ZN4absl12lts_2026010716cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E15DestroyCallbackEv:
   80|    661|  void DestroyCallback() {
   81|    661|    is_callback_engaged_ = false;
   82|    661|    GetCallback().~Callback();
   83|    661|  }

_ZN4absl12lts_2026010713InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS3_EEE4dataEv:
  347|    661|  pointer data() noexcept ABSL_ATTRIBUTE_LIFETIME_BOUND {
  348|    661|    return storage_.GetIsAllocated() ? storage_.GetAllocatedData()
  ------------------
  |  Branch (348:12): [True: 0, False: 661]
  ------------------
  349|    661|                                     : storage_.GetInlinedData();
  350|    661|  }
_ZNK4absl12lts_2026010713InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS3_EEE4sizeEv:
  313|    661|  size_type size() const noexcept { return storage_.GetSize(); }
_ZN4absl12lts_2026010713InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS3_EEEC2Ev:
  127|    661|  InlinedVector() noexcept(noexcept(allocator_type())) : storage_() {}
_ZN4absl12lts_2026010713InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS3_EEED2Ev:
  299|    661|  ~InlinedVector() {}

_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNSt3__19allocatorIPNS0_7LogSinkEEEmEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS8_XT_EE4typeEv:
  249|  1.32k|  constexpr const ElemT<I>& get() const& {
  250|  1.32k|    return StorageT<I>::get();
  251|  1.32k|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEELb0EE3getEv:
   91|  1.32k|  constexpr const T& get() const& { return value; }
_ZN4absl12lts_2026010718container_internal15CompressedTupleIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEC2IS7_JjETnNS3_9enable_ifIXsr4absl11conjunctionINS3_8negationINS3_7is_sameIFvS8_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS8_JSE_DpT0_EEEEE5valueEbE4typeELb1EEEOSE_DpOSL_:
  239|    661|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|    661|                                             std::forward<First>(first),
  241|    661|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEENS5_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJS9_jEEENS5_10in_place_tEDpOT_:
  126|  1.32k|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|  1.32k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIPNS0_7LogSinkEEELm0ENS2_10StorageTagIJS8_mEEELb1EEC2IS8_EENS4_10in_place_tEOT_:
  102|    661|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEELb0EEC2IjEENS5_10in_place_tEOT_:
   90|    661|      : value(std::forward<V>(v)) {}
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNSt3__19allocatorIPNS0_7LogSinkEEEmEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS8_XT_EE4typeEv:
  244|    661|  constexpr ElemT<I>& get() & {
  245|    661|    return StorageT<I>::get();
  246|    661|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEELb0EE3getEv:
   92|    661|  constexpr T& get() & { return value; }

_ZN4absl12lts_2026010718container_internal8AllocateILm8ENSt3__19allocatorIcEEEEPvPT0_m:
   62|  11.2k|void* Allocate(Alloc* alloc, size_t n) {
   63|  11.2k|  static_assert(Alignment > 0, "");
   64|  11.2k|  assert(n && "n must be positive");
   65|  11.2k|  using M = AlignedType<Alignment>;
   66|  11.2k|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   67|  11.2k|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   68|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
   69|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
   70|       |  // with the "foo(bar)" syntax.
   71|  11.2k|  A my_mem_alloc(*alloc);
   72|  11.2k|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   73|       |  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   74|  11.2k|         "allocator does not respect alignment");
   75|  11.2k|  return p;
   76|  11.2k|}
_ZN4absl12lts_2026010718container_internal10DeallocateILm8ENSt3__19allocatorIcEEEEvPT0_Pvm:
   93|  11.2k|void Deallocate(Alloc* alloc, void* p, size_t n) {
   94|  11.2k|  static_assert(Alignment > 0, "");
   95|  11.2k|  assert(n && "n must be positive");
   96|  11.2k|  using M = AlignedType<Alignment>;
   97|  11.2k|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   98|  11.2k|  using AT = typename absl::allocator_traits<Alloc>::template rebind_traits<M>;
   99|       |  // On macOS, "mem_alloc" is a #define with one argument defined in
  100|       |  // rpc/types.h, so we can't name the variable "mem_alloc" and initialize it
  101|       |  // with the "foo(bar)" syntax.
  102|  11.2k|  A my_mem_alloc(*alloc);
  103|  11.2k|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
  104|  11.2k|                 (n + sizeof(M) - 1) / sizeof(M));
  105|  11.2k|}

_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl18MaskEmptyOrDeletedEv:
  319|  7.37k|  NonIterableBitMaskType MaskEmptyOrDeleted() const {
  320|  7.37k|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  321|  7.37k|    return NonIterableBitMaskType(static_cast<uint16_t>(
  322|  7.37k|        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))));
  323|  7.37k|  }
_ZN4absl12lts_2026010718container_internal6IsFullENS1_6ctrl_tE:
  221|  26.4M|inline bool IsFull(ctrl_t c) {
  222|       |  // Cast `c` to the underlying type instead of casting `0` to `ctrl_t` as `0`
  223|       |  // is not a value in the enum. Both ways are equivalent, but this way makes
  224|       |  // linters happier.
  225|  26.4M|  return static_cast<std::underlying_type_t<ctrl_t>>(c) >= 0;
  226|  26.4M|}
_ZN4absl12lts_2026010718container_internal20_mm_cmpgt_epi8_fixedEDv2_xS2_:
  264|  7.37k|inline __m128i _mm_cmpgt_epi8_fixed(__m128i a, __m128i b) {
  265|       |#if defined(__GNUC__) && !defined(__clang__)
  266|       |  if (std::is_unsigned<char>::value) {
  267|       |    const __m128i mask = _mm_set1_epi8(0x80);
  268|       |    const __m128i diff = _mm_subs_epi8(b, a);
  269|       |    return _mm_cmpeq_epi8(_mm_and_si128(diff, mask), mask);
  270|       |  }
  271|       |#endif
  272|  7.37k|  return _mm_cmpgt_epi8(a, b);
  273|  7.37k|}

_ZNK4absl12lts_2026010718container_internal20HashtablezInfoHandle9IsSampledEv:
  220|  10.8k|  inline bool IsSampled() const { return false; }
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle20RecordStorageChangedEmm:
  221|  1.26k|  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle17RecordReservationEm:
  223|  6.00k|  inline void RecordReservation(size_t /*target_capacity*/) {}
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle16RecordInsertMissEmm:
  226|  26.4M|                               size_t /*distance_from_desired*/) {}

_ZNK4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE14GetIsAllocatedEv:
  372|    661|  bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
_ZNK4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE21GetSizeAndIsAllocatedEv:
  366|  1.32k|  const SizeType<A>& GetSizeAndIsAllocated() const {
  367|  1.32k|    return metadata_.template get<1>();
  368|  1.32k|  }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE14GetInlinedDataEv:
  396|    661|  ABSL_ATTRIBUTE_NO_SANITIZE_CFI Pointer<A> GetInlinedData() {
  397|    661|    return reinterpret_cast<Pointer<A>>(data_.inlined.inlined_data);
  398|    661|  }
_ZNK4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE7GetSizeEv:
  370|    661|  SizeType<A> GetSize() const { return GetSizeAndIsAllocated() >> 1; }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEEC2Ev:
  337|    661|  Storage() : metadata_(A(), /* size and is_allocated */ 0u) {}
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEED2Ev:
  342|    661|  ~Storage() {
  343|       |    // Fast path: if we are empty and not allocated, there's nothing to do.
  344|    661|    if (GetSizeAndIsAllocated() == 0) {
  ------------------
  |  Branch (344:9): [True: 661, False: 0]
  ------------------
  345|    661|      return;
  346|    661|    }
  347|       |
  348|       |    // Fast path: if no destructors need to be run and we know the allocator
  349|       |    // doesn't do anything fancy, then all we need to do is deallocate (and
  350|       |    // maybe not even that).
  351|      0|    if (absl::is_trivially_destructible<ValueType<A>>::value &&
  ------------------
  |  Branch (351:9): [True: 0, Folded]
  ------------------
  352|      0|        std::is_same<A, std::allocator<ValueType<A>>>::value) {
  ------------------
  |  Branch (352:9): [True: 0, Folded]
  ------------------
  353|      0|      DeallocateIfAllocated();
  354|      0|      return;
  355|      0|    }
  356|       |
  357|      0|    DestroyContents();
  358|      0|  }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE21GetSizeAndIsAllocatedEv:
  364|    661|  SizeType<A>& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }

_ZN4absl12lts_2026010718container_internal42GrowSooTableToNextCapacityAndPrepareInsertILm16ELb1EEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEEb:
 1759|    365|    absl::FunctionRef<size_t(size_t)> get_hash, bool force_sampling) {
 1760|    365|  AssertSoo(common, policy);
 1761|    365|  if (ABSL_PREDICT_FALSE(force_sampling)) {
  ------------------
  |  |  189|    365|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 365]
  |  |  |  Branch (189:49): [Folded, False: 365]
  |  |  |  Branch (189:58): [True: 0, False: 365]
  |  |  ------------------
  ------------------
 1762|       |    // The table is empty, it is only used for forced sampling of SOO tables.
 1763|      0|    return GrowEmptySooTableToNextCapacityForceSamplingAndPrepareInsert(
 1764|      0|        common, policy, get_hash);
 1765|      0|  }
 1766|    365|  ABSL_SWISSTABLE_ASSERT(common.size() == policy.soo_capacity());
  ------------------
  |  |   62|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1767|    365|  static constexpr size_t kNewCapacity = NextCapacity(SooCapacity());
 1768|    365|  const size_t slot_size = policy.slot_size;
 1769|    365|  void* alloc = policy.get_char_alloc(common);
 1770|    365|  common.set_capacity(kNewCapacity);
 1771|       |
 1772|       |  // Since the table is not empty, it will not be sampled.
 1773|       |  // The decision to sample was already made during the first insertion.
 1774|       |  //
 1775|       |  // We do not set control and slots in CommonFields yet to avoid overriding
 1776|       |  // SOO data.
 1777|    365|  const auto [new_ctrl, new_slots] = AllocBackingArray(
 1778|    365|      common, policy, kNewCapacity, /*has_infoz=*/false, alloc);
 1779|       |
 1780|    365|  PrepareInsertCommon(common);
 1781|    365|  ABSL_SWISSTABLE_ASSERT(common.size() == 2);
  ------------------
  |  |   62|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1782|    365|  GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(kNewCapacity - 2);
 1783|    365|  common.generate_new_seed(/*has_infoz=*/false);
 1784|    365|  const h2_t soo_slot_h2 = H2(policy.hash_slot(
 1785|    365|      policy.hash_fn(common), common.soo_data(), common.seed().seed()));
 1786|    365|  const size_t new_hash = get_hash(common.seed().seed());
 1787|       |
 1788|    365|  const size_t offset = Resize1To3NewOffset(new_hash, common.seed());
 1789|    365|  InitializeThreeElementsControlBytes(soo_slot_h2, H2(new_hash), offset,
 1790|    365|                                      new_ctrl);
 1791|       |
 1792|    365|  SanitizerPoisonMemoryRegion(new_slots, slot_size * kNewCapacity);
 1793|    365|  void* target_slot = SlotAddress(new_slots, SooSlotIndex(), slot_size);
 1794|    365|  SanitizerUnpoisonMemoryRegion(target_slot, slot_size);
 1795|    365|  if constexpr (TransferUsesMemcpy) {
 1796|       |    // Target slot is placed at index 1, but capacity is at
 1797|       |    // minimum 3. So we are allowed to copy at least twice as much
 1798|       |    // memory.
 1799|    365|    static_assert(SooSlotIndex() == 1);
 1800|    365|    static_assert(SooSlotMemcpySize > 0);
 1801|    365|    static_assert(SooSlotMemcpySize <= MaxSooSlotSize());
 1802|    365|    ABSL_SWISSTABLE_ASSERT(SooSlotMemcpySize <= 2 * slot_size);
  ------------------
  |  |   62|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1803|    365|    ABSL_SWISSTABLE_ASSERT(SooSlotMemcpySize >= slot_size);
  ------------------
  |  |   62|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1804|    365|    void* next_slot = SlotAddress(target_slot, 1, slot_size);
 1805|    365|    SanitizerUnpoisonMemoryRegion(next_slot, SooSlotMemcpySize - slot_size);
 1806|    365|    std::memcpy(target_slot, common.soo_data(), SooSlotMemcpySize);
 1807|    365|    SanitizerPoisonMemoryRegion(next_slot, SooSlotMemcpySize - slot_size);
 1808|       |  } else {
 1809|       |    static_assert(SooSlotMemcpySize == 0);
 1810|       |    policy.transfer_n(&common, target_slot, common.soo_data(), 1);
 1811|       |  }
 1812|    365|  common.set_control(new_ctrl);
 1813|    365|  common.set_slots(new_slots);
 1814|       |
 1815|       |  // Full SOO table couldn't be sampled. If SOO table is sampled, it would
 1816|       |  // have been resized to the next capacity.
 1817|       |  ABSL_SWISSTABLE_ASSERT(!common.infoz().IsSampled());
  ------------------
  |  |   62|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1818|    365|  SanitizerUnpoisonMemoryRegion(SlotAddress(new_slots, offset, slot_size),
 1819|    365|                                slot_size);
 1820|    365|  return offset;
 1821|    365|}
_ZN4absl12lts_2026010718container_internal13HashtableSize8NextSeedEv:
  137|  6.36k|uint16_t HashtableSize::NextSeed() {
  138|  6.36k|  static_assert(PerTableSeed::kBitCount == 16);
  139|  6.36k|  thread_local uint16_t seed =
  140|  6.36k|      static_cast<uint16_t>(reinterpret_cast<uintptr_t>(&seed));
  141|  6.36k|  seed += uint16_t{0xad53};
  142|  6.36k|  return seed;
  143|  6.36k|}
_ZN4absl12lts_2026010718container_internal17ClearBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPvbb:
  651|  1.26k|                       bool reuse, bool soo_enabled) {
  652|  1.26k|  if (reuse) {
  ------------------
  |  Branch (652:7): [True: 1.26k, False: 0]
  ------------------
  653|  1.26k|    c.set_size_to_zero();
  654|  1.26k|    ABSL_SWISSTABLE_ASSERT(!soo_enabled || c.capacity() > SooCapacity());
  ------------------
  |  |   62|  1.26k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  655|  1.26k|    ResetCtrl(c, policy.slot_size);
  656|  1.26k|    ResetGrowthLeft(c);
  657|  1.26k|    c.infoz().RecordStorageChanged(0, c.capacity());
  658|  1.26k|  } else {
  659|       |    // We need to record infoz before calling dealloc, which will unregister
  660|       |    // infoz.
  661|      0|    c.infoz().RecordClearedReservation();
  662|      0|    c.infoz().RecordStorageChanged(0, soo_enabled ? SooCapacity() : 0);
  ------------------
  |  Branch (662:39): [True: 0, False: 0]
  ------------------
  663|      0|    c.infoz().Unregister();
  664|      0|    (*policy.dealloc)(alloc, c.capacity(), c.control(), policy.slot_size,
  665|      0|                      policy.slot_align, c.has_infoz());
  666|      0|    c = soo_enabled ? CommonFields{soo_tag_t{}} : CommonFields{non_soo_tag_t{}};
  ------------------
  |  Branch (666:9): [True: 0, False: 0]
  ------------------
  667|      0|  }
  668|  1.26k|}
_ZN4absl12lts_2026010718container_internal24PrepareInsertSmallNonSooERNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEE:
 1524|  1.49k|    absl::FunctionRef<size_t(size_t)> get_hash) {
 1525|  1.49k|  ABSL_SWISSTABLE_ASSERT(common.is_small());
  ------------------
  |  |   62|  1.49k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1526|  1.49k|  ABSL_SWISSTABLE_ASSERT(!policy.soo_enabled);
  ------------------
  |  |   62|  1.49k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1527|  1.49k|  if (common.capacity() == 1) {
  ------------------
  |  Branch (1527:7): [True: 1.49k, False: 1]
  ------------------
 1528|  1.49k|    if (common.empty()) {
  ------------------
  |  Branch (1528:9): [True: 1.49k, False: 1]
  ------------------
 1529|  1.49k|      IncrementSmallSizeNonSoo(common, policy);
 1530|  1.49k|      return {SooControl(), common.slot_array()};
 1531|  1.49k|    } else {
 1532|      1|      return Grow1To3AndPrepareInsert(common, policy, get_hash);
 1533|      1|    }
 1534|  1.49k|  }
 1535|       |
 1536|       |  // Growing from 0 to 1 capacity.
 1537|      1|  ABSL_SWISSTABLE_ASSERT(common.capacity() == 0);
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1538|      1|  constexpr size_t kNewCapacity = 1;
 1539|       |
 1540|      1|  common.set_capacity(kNewCapacity);
 1541|      1|  HashtablezInfoHandle infoz;
 1542|      1|  const bool should_sample =
 1543|      1|      policy.is_hashtablez_eligible && ShouldSampleNextTable();
  ------------------
  |  Branch (1543:7): [True: 1, False: 0]
  |  Branch (1543:40): [True: 0, False: 1]
  ------------------
 1544|      1|  if (ABSL_PREDICT_FALSE(should_sample)) {
  ------------------
  |  |  189|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1]
  |  |  |  Branch (189:49): [Folded, False: 1]
  |  |  |  Branch (189:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1545|      0|    infoz = ForcedTrySample(policy.slot_size, policy.key_size,
 1546|      0|                            policy.value_size, policy.soo_capacity());
 1547|      0|  }
 1548|      1|  const bool has_infoz = infoz.IsSampled();
 1549|      1|  void* alloc = policy.get_char_alloc(common);
 1550|       |
 1551|      1|  const auto [new_ctrl, new_slots] =
 1552|      1|      AllocBackingArray(common, policy, kNewCapacity, has_infoz, alloc);
 1553|      1|  common.set_control(new_ctrl);
 1554|      1|  common.set_slots(new_slots);
 1555|       |
 1556|      1|  static_assert(NextCapacity(0) == 1);
 1557|      1|  PrepareInsertCommon(common);
 1558|       |
 1559|      1|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  189|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1]
  |  |  |  Branch (189:49): [Folded, False: 1]
  |  |  |  Branch (189:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1560|      0|    common.generate_new_seed(/*has_infoz=*/true);
 1561|      0|    ReportSingleGroupTableGrowthToInfoz(common, infoz,
 1562|      0|                                        get_hash(common.seed().seed()));
 1563|      0|  }
 1564|      1|  return {SooControl(), new_slots};
 1565|  1.49k|}
_ZN4absl12lts_2026010718container_internal19GetRefForEmptyClassERNS1_12CommonFieldsE:
 1731|  11.5k|void* GetRefForEmptyClass(CommonFields& common) {
 1732|       |  // Empty base optimization typically make the empty base class address to be
 1733|       |  // the same as the first address of the derived class object.
 1734|       |  // But we generally assume that for empty classes we can return any valid
 1735|       |  // pointer.
 1736|  11.5k|  return &common;
 1737|  11.5k|}
_ZN4absl12lts_2026010718container_internal24ReserveTableToFitNewSizeERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1946|  6.00k|                              size_t new_size) {
 1947|  6.00k|  common.reset_reserved_growth(new_size);
 1948|  6.00k|  common.set_reservation_size(new_size);
 1949|  6.00k|  ABSL_SWISSTABLE_ASSERT(new_size > policy.soo_capacity());
  ------------------
  |  |   62|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1950|  6.00k|  const size_t cap = common.capacity();
 1951|  6.00k|  if (ABSL_PREDICT_TRUE(common.empty() && cap <= policy.soo_capacity())) {
  ------------------
  |  |  190|  12.0k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 6.00k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 6.00k]
  |  |  |  Branch (190:58): [True: 6.00k, False: 0]
  |  |  |  Branch (190:58): [True: 6.00k, False: 0]
  |  |  ------------------
  ------------------
 1952|  6.00k|    return ReserveEmptyNonAllocatedTableToFitNewSize(common, policy, new_size);
 1953|  6.00k|  }
 1954|       |
 1955|      0|  ABSL_SWISSTABLE_ASSERT(!common.empty() || cap > policy.soo_capacity());
  ------------------
  |  |   62|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1956|      0|  ABSL_SWISSTABLE_ASSERT(cap > 0);
  ------------------
  |  |   62|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1957|      0|  const size_t max_size_before_growth =
 1958|      0|      IsSmallCapacity(cap) ? cap : common.size() + common.growth_left();
  ------------------
  |  Branch (1958:7): [True: 0, False: 0]
  ------------------
 1959|      0|  if (new_size <= max_size_before_growth) {
  ------------------
  |  Branch (1959:7): [True: 0, False: 0]
  ------------------
 1960|      0|    return;
 1961|      0|  }
 1962|      0|  ReserveAllocatedTable(common, policy, new_size);
 1963|      0|}
_ZN4absl12lts_2026010718container_internal18PrepareInsertLargeERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_18NonIterableBitMaskItLi16ELi0EEENS1_8FindInfoE:
 1992|  26.4M|                          FindInfo target_group) {
 1993|       |  // NOLINTNEXTLINE(misc-static-assert)
 1994|       |  ABSL_SWISSTABLE_ASSERT(!SwisstableGenerationsEnabled());
  ------------------
  |  |   62|  26.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1995|  26.4M|  return PrepareInsertLargeImpl(common, policy, hash, mask_empty, target_group);
 1996|  26.4M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119Resize1To3NewOffsetEmNS1_12PerTableSeedE:
  106|    366|size_t Resize1To3NewOffset(size_t hash, PerTableSeed seed) {
  107|       |  // After resize from capacity 1 to 3, we always have exactly the slot with
  108|       |  // index 1 occupied, so we need to insert either at index 0 or index 2.
  109|    366|  static_assert(SooSlotIndex() == 1);
  110|    366|  return SingleGroupTableH1(hash, seed) & 2;
  111|    366|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_118SingleGroupTableH1EmNS1_12PerTableSeedE:
  101|  1.09k|size_t SingleGroupTableH1(size_t hash, PerTableSeed seed) {
  102|  1.09k|  return hash ^ seed.seed();
  103|  1.09k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_111SlotAddressEPvmm:
  115|  15.6k|inline void* SlotAddress(void* slot_array, size_t slot, size_t slot_size) {
  116|  15.6k|  return static_cast<void*>(static_cast<char*>(slot_array) +
  117|  15.6k|                            (slot * slot_size));
  118|  15.6k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119PrepareInsertCommonERNS1_12CommonFieldsE:
  334|  26.4M|void PrepareInsertCommon(CommonFields& common) {
  335|  26.4M|  common.increment_size();
  336|  26.4M|  common.maybe_increment_generation_on_insert();
  337|  26.4M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_135InitializeThreeElementsControlBytesEhhmPNS1_6ctrl_tE:
  556|    366|    h2_t orig_h2, h2_t new_h2, size_t new_offset, ctrl_t* new_ctrl) {
  557|    366|  static constexpr size_t kNewCapacity = NextCapacity(SooCapacity());
  558|    366|  static_assert(kNewCapacity == 3);
  559|    366|  static_assert(is_single_group(kNewCapacity));
  560|    366|  static_assert(SooSlotIndex() == 1);
  561|    366|  ABSL_SWISSTABLE_ASSERT(new_offset == 0 || new_offset == 2);
  ------------------
  |  |   62|    366|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  562|       |
  563|    366|  static constexpr uint64_t kEmptyXorSentinel =
  564|    366|      static_cast<uint8_t>(ctrl_t::kEmpty) ^
  565|    366|      static_cast<uint8_t>(ctrl_t::kSentinel);
  566|    366|  static constexpr uint64_t kEmpty64 = static_cast<uint8_t>(ctrl_t::kEmpty);
  567|    366|  static constexpr size_t kMirroredSooSlotIndex =
  568|    366|      SooSlotIndex() + kNewCapacity + 1;
  569|       |  // The first 8 bytes, where SOO slot original and mirrored positions are
  570|       |  // replaced with 0.
  571|       |  // Result will look like: E0ESE0EE
  572|    366|  static constexpr uint64_t kFirstCtrlBytesWithZeroes =
  573|    366|      k8EmptyBytes ^ (kEmpty64 << (8 * SooSlotIndex())) ^
  574|    366|      (kEmptyXorSentinel << (8 * kNewCapacity)) ^
  575|    366|      (kEmpty64 << (8 * kMirroredSooSlotIndex));
  576|       |
  577|    366|  const uint64_t soo_h2 = static_cast<uint64_t>(orig_h2);
  578|    366|  const uint64_t new_h2_xor_empty =
  579|    366|      static_cast<uint64_t>(new_h2 ^ static_cast<uint8_t>(ctrl_t::kEmpty));
  580|       |  // Fill the original and mirrored bytes for SOO slot.
  581|       |  // Result will look like:
  582|       |  // EHESEHEE
  583|       |  // Where H = soo_h2, E = kEmpty, S = kSentinel.
  584|    366|  uint64_t first_ctrl_bytes =
  585|    366|      ((soo_h2 << (8 * SooSlotIndex())) | kFirstCtrlBytesWithZeroes) |
  586|    366|      (soo_h2 << (8 * kMirroredSooSlotIndex));
  587|       |  // Replace original and mirrored empty bytes for the new position.
  588|       |  // Result for new_offset 0 will look like:
  589|       |  // NHESNHEE
  590|       |  // Where H = soo_h2, N = H2(new_hash), E = kEmpty, S = kSentinel.
  591|       |  // Result for new_offset 2 will look like:
  592|       |  // EHNSEHNE
  593|    366|  first_ctrl_bytes ^= (new_h2_xor_empty << (8 * new_offset));
  594|    366|  size_t new_mirrored_offset = new_offset + kNewCapacity + 1;
  595|    366|  first_ctrl_bytes ^= (new_h2_xor_empty << (8 * new_mirrored_offset));
  596|       |
  597|       |  // Fill last bytes with kEmpty.
  598|    366|  std::memset(new_ctrl + kNewCapacity, static_cast<int8_t>(ctrl_t::kEmpty),
  599|    366|              Group::kWidth);
  600|       |  // Overwrite the first 8 bytes with first_ctrl_bytes.
  601|    366|  absl::little_endian::Store64(new_ctrl, first_ctrl_bytes);
  602|       |
  603|       |  // Example for group size 16:
  604|       |  // new_ctrl after 1st memset =      ???EEEEEEEEEEEEEEEE
  605|       |  // new_offset 0:
  606|       |  // new_ctrl after 2nd store  =      NHESNHEEEEEEEEEEEEE
  607|       |  // new_offset 2:
  608|       |  // new_ctrl after 2nd store  =      EHNSEHNEEEEEEEEEEEE
  609|       |
  610|       |  // Example for group size 8:
  611|       |  // new_ctrl after 1st memset =      ???EEEEEEEE
  612|       |  // new_offset 0:
  613|       |  // new_ctrl after 2nd store  =      NHESNHEEEEE
  614|       |  // new_offset 2:
  615|       |  // new_ctrl after 2nd store  =      EHNSEHNEEEE
  616|    366|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_17SetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  356|  26.4M|                    size_t slot_size) {
  357|       |  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   62|  26.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  358|  26.4M|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  359|  26.4M|  ctrl_t* ctrl = c.control();
  360|  26.4M|  ctrl[i] = h;
  361|  26.4M|  ctrl[((i - NumClonedBytes()) & c.capacity()) +
  362|  26.4M|       (NumClonedBytes() & c.capacity())] = h;
  363|  26.4M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119DoSanitizeOnSetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  341|  26.4M|                                size_t slot_size) {
  342|  26.4M|  ABSL_SWISSTABLE_ASSERT(i < c.capacity());
  ------------------
  |  |   62|  26.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  343|  26.4M|  auto* slot_i = static_cast<const char*>(c.slot_array()) + i * slot_size;
  344|  26.4M|  if (IsFull(h)) {
  ------------------
  |  Branch (344:7): [True: 26.4M, False: 0]
  ------------------
  345|  26.4M|    SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
  346|  26.4M|  } else {
  347|      0|    SanitizerPoisonMemoryRegion(slot_i, slot_size);
  348|      0|  }
  349|  26.4M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119SetCtrlInLargeTableERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  389|  11.4k|                                size_t slot_size) {
  390|       |  ABSL_SWISSTABLE_ASSERT(c.capacity() >= Group::kWidth - 1);
  ------------------
  |  |   62|  11.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  391|  11.4k|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  392|  11.4k|  ctrl_t* ctrl = c.control();
  393|  11.4k|  ctrl[i] = h;
  394|  11.4k|  ctrl[((i - NumClonedBytes()) & c.capacity()) + NumClonedBytes()] = h;
  395|  11.4k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_19ResetCtrlERNS1_12CommonFieldsEm:
  531|  7.26k|void ResetCtrl(CommonFields& common, size_t slot_size) {
  532|  7.26k|  const size_t capacity = common.capacity();
  533|  7.26k|  ctrl_t* ctrl = common.control();
  534|  7.26k|  static constexpr size_t kTwoGroupCapacity = 2 * Group::kWidth - 1;
  535|  7.26k|  if (ABSL_PREDICT_TRUE(capacity <= kTwoGroupCapacity)) {
  ------------------
  |  |  190|  7.26k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 6.53k, False: 736]
  |  |  |  Branch (190:48): [Folded, False: 7.26k]
  |  |  |  Branch (190:57): [True: 6.53k, False: 736]
  |  |  ------------------
  ------------------
  536|  6.53k|    if (IsSmallCapacity(capacity)) return;
  ------------------
  |  Branch (536:9): [True: 1.59k, False: 4.93k]
  ------------------
  537|  4.93k|    std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
  538|  4.93k|    std::memset(ctrl + capacity, static_cast<int8_t>(ctrl_t::kEmpty),
  539|  4.93k|                Group::kWidth);
  540|  4.93k|    if (capacity == kTwoGroupCapacity) {
  ------------------
  |  Branch (540:9): [True: 533, False: 4.40k]
  ------------------
  541|    533|      std::memset(ctrl + Group::kWidth, static_cast<int8_t>(ctrl_t::kEmpty),
  542|    533|                  Group::kWidth);
  543|    533|    }
  544|  4.93k|  } else {
  545|    736|    std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty),
  546|    736|                capacity + 1 + NumClonedBytes());
  547|    736|  }
  548|  5.67k|  ctrl[capacity] = ctrl_t::kSentinel;
  549|  5.67k|  SanitizerPoisonMemoryRegion(common.slot_array(), slot_size * capacity);
  550|  5.67k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_115ResetGrowthLeftERNS1_12CommonFieldsE:
  305|  1.26k|void ResetGrowthLeft(CommonFields& common) {
  306|  1.26k|  ResetGrowthLeft(common.growth_info(), common.capacity(), common.size());
  307|  1.26k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_115ResetGrowthLeftERNS1_10GrowthInfoEmm:
  301|  6.12k|void ResetGrowthLeft(GrowthInfo& growth_info, size_t capacity, size_t size) {
  302|  6.12k|  growth_info.InitGrowthLeftNoDeleted(CapacityToGrowth(capacity) - size);
  303|  6.12k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117AllocBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmbPv:
  764|  11.2k|                                   void* alloc) {
  765|  11.2k|  RawHashSetLayout layout(new_capacity, policy.slot_size, policy.slot_align,
  766|  11.2k|                          has_infoz);
  767|       |  // Perform a direct call in the common case to allow for profile-guided
  768|       |  // heap optimization (PGHO) to understand which allocation function is used.
  769|  11.2k|  constexpr size_t kDefaultAlignment = BackingArrayAlignment(alignof(size_t));
  770|  11.2k|  char* mem = static_cast<char*>(
  771|  11.2k|      ABSL_PREDICT_TRUE(
  ------------------
  |  |  190|  11.2k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 11.2k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 11.2k]
  |  |  |  Branch (190:57): [True: 11.2k, False: 0]
  |  |  ------------------
  ------------------
  772|  11.2k|          policy.alloc ==
  773|  11.2k|          (&AllocateBackingArray<kDefaultAlignment, std::allocator<char>>))
  774|  11.2k|          ? AllocateBackingArray<kDefaultAlignment, std::allocator<char>>(
  775|  11.2k|                alloc, layout.alloc_size())
  776|  11.2k|          : policy.alloc(alloc, layout.alloc_size()));
  777|  11.2k|  const GenerationType old_generation = common.generation();
  778|  11.2k|  common.set_generation_ptr(
  779|  11.2k|      reinterpret_cast<GenerationType*>(mem + layout.generation_offset()));
  780|  11.2k|  common.set_generation(NextGeneration(old_generation));
  781|       |
  782|  11.2k|  return {reinterpret_cast<ctrl_t*>(mem + layout.control_offset()),
  783|  11.2k|          mem + layout.slot_offset()};
  784|  11.2k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_19AssertSooERNS1_12CommonFieldsERKNS1_15PolicyFunctionsE:
  890|    365|               [[maybe_unused]] const PolicyFunctions& policy) {
  891|    365|  ABSL_SWISSTABLE_ASSERT(policy.soo_enabled);
  ------------------
  |  |   62|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  892|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() == policy.soo_capacity());
  ------------------
  |  |   62|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  893|    365|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_124IncrementSmallSizeNonSooERNS1_12CommonFieldsERKNS1_15PolicyFunctionsE:
 1380|  1.49k|                              const PolicyFunctions& __restrict policy) {
 1381|       |  ABSL_SWISSTABLE_ASSERT(common.is_small());
  ------------------
  |  |   62|  1.49k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1382|  1.49k|  common.increment_size();
 1383|  1.49k|  SanitizerUnpoisonMemoryRegion(common.slot_array(), policy.slot_size);
 1384|  1.49k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_124Grow1To3AndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEE:
 1398|      1|    absl::FunctionRef<size_t(size_t)> get_hash) {
 1399|       |  // TODO(b/413062340): Refactor to reuse more code with
 1400|       |  // GrowSooTableToNextCapacityAndPrepareInsert.
 1401|      1|  ABSL_SWISSTABLE_ASSERT(common.capacity() == 1);
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1402|      1|  ABSL_SWISSTABLE_ASSERT(!common.empty());
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1403|      1|  ABSL_SWISSTABLE_ASSERT(!policy.soo_enabled);
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1404|      1|  constexpr size_t kOldCapacity = 1;
 1405|      1|  constexpr size_t kNewCapacity = NextCapacity(kOldCapacity);
 1406|      1|  ctrl_t* old_ctrl = common.control();
 1407|      1|  void* old_slots = common.slot_array();
 1408|       |
 1409|      1|  const size_t slot_size = policy.slot_size;
 1410|      1|  const size_t slot_align = policy.slot_align;
 1411|      1|  void* alloc = policy.get_char_alloc(common);
 1412|      1|  HashtablezInfoHandle infoz = common.infoz();
 1413|      1|  const bool has_infoz = infoz.IsSampled();
 1414|      1|  common.set_capacity(kNewCapacity);
 1415|       |
 1416|      1|  const auto [new_ctrl, new_slots] =
 1417|      1|      AllocBackingArray(common, policy, kNewCapacity, has_infoz, alloc);
 1418|      1|  common.set_control(new_ctrl);
 1419|      1|  common.set_slots(new_slots);
 1420|      1|  SanitizerPoisonMemoryRegion(new_slots, kNewCapacity * slot_size);
 1421|       |
 1422|      1|  if (ABSL_PREDICT_TRUE(!has_infoz)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 1, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 1]
  |  |  |  Branch (190:57): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 1423|       |    // When we're sampled, we already have a seed.
 1424|      1|    common.generate_new_seed(/*has_infoz=*/false);
 1425|      1|  }
 1426|      1|  const size_t new_hash = get_hash(common.seed().seed());
 1427|      1|  h2_t new_h2 = H2(new_hash);
 1428|      1|  size_t orig_hash =
 1429|      1|      policy.hash_slot(policy.hash_fn(common), old_slots, common.seed().seed());
 1430|      1|  size_t offset = Resize1To3NewOffset(new_hash, common.seed());
 1431|      1|  InitializeThreeElementsControlBytes(H2(orig_hash), new_h2, offset, new_ctrl);
 1432|       |
 1433|      1|  void* old_element_target = NextSlot(new_slots, slot_size);
 1434|      1|  SanitizerUnpoisonMemoryRegion(old_element_target, slot_size);
 1435|      1|  policy.transfer_n(&common, old_element_target, old_slots, 1);
 1436|       |
 1437|      1|  void* new_element_target_slot = SlotAddress(new_slots, offset, slot_size);
 1438|      1|  SanitizerUnpoisonMemoryRegion(new_element_target_slot, slot_size);
 1439|       |
 1440|      1|  policy.dealloc(alloc, kOldCapacity, old_ctrl, slot_size, slot_align,
 1441|      1|                 has_infoz);
 1442|      1|  PrepareInsertCommon(common);
 1443|      1|  ABSL_SWISSTABLE_ASSERT(common.size() == 2);
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1444|      1|  GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(kNewCapacity - 2);
 1445|       |
 1446|      1|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  189|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1]
  |  |  |  Branch (189:49): [Folded, False: 1]
  |  |  |  Branch (189:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1447|      0|    ReportSingleGroupTableGrowthToInfoz(common, infoz, new_hash);
 1448|      0|  }
 1449|      1|  return {new_ctrl + offset, new_element_target_slot};
 1450|      1|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_18NextSlotEPvmm:
  122|    733|inline void* NextSlot(void* slot, size_t slot_size, size_t i = 1) {
  123|    733|  return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(slot) +
  124|    733|                                 slot_size * i);
  125|    733|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_125SetCtrlInSingleGroupTableERKNS1_12CommonFieldsEmhm:
  382|    732|                                      size_t slot_size) {
  383|    732|  SetCtrlInSingleGroupTable(c, i, static_cast<ctrl_t>(h), slot_size);
  384|    732|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_125SetCtrlInSingleGroupTableERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  372|    732|                                      size_t slot_size) {
  373|    732|  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   62|    732|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  374|       |  ABSL_SWISSTABLE_ASSERT(is_single_group(c.capacity()));
  ------------------
  |  |   62|    732|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  375|    732|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  376|    732|  ctrl_t* ctrl = c.control();
  377|    732|  ctrl[i] = h;
  378|    732|  ctrl[i + c.capacity() + 1] = h;
  379|    732|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_115ValidateMaxSizeEmm:
   69|  6.00k|void ValidateMaxSize(size_t size, size_t slot_size) {
   70|  6.00k|  if (IsAboveValidSize(size, slot_size)) {
  ------------------
  |  Branch (70:7): [True: 0, False: 6.00k]
  ------------------
   71|      0|    HashTableSizeOverflow();
   72|      0|  }
   73|  6.00k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_132ResizeEmptyNonAllocatedTableImplERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmb:
  838|  6.00k|                                      size_t new_capacity, bool force_infoz) {
  839|  6.00k|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(new_capacity));
  ------------------
  |  |   62|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  840|  6.00k|  ABSL_SWISSTABLE_ASSERT(new_capacity > policy.soo_capacity());
  ------------------
  |  |   62|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  841|  6.00k|  ABSL_SWISSTABLE_ASSERT(!force_infoz || policy.soo_enabled);
  ------------------
  |  |   62|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  842|  6.00k|  ABSL_SWISSTABLE_ASSERT(common.capacity() <= policy.soo_capacity());
  ------------------
  |  |   62|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  843|  6.00k|  ABSL_SWISSTABLE_ASSERT(common.empty());
  ------------------
  |  |   62|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  844|  6.00k|  const size_t slot_size = policy.slot_size;
  845|  6.00k|  HashtablezInfoHandle infoz;
  846|  6.00k|  const bool should_sample =
  847|  6.00k|      policy.is_hashtablez_eligible && (force_infoz || ShouldSampleNextTable());
  ------------------
  |  Branch (847:7): [True: 6.00k, False: 0]
  |  Branch (847:41): [True: 0, False: 6.00k]
  |  Branch (847:56): [True: 0, False: 6.00k]
  ------------------
  848|  6.00k|  if (ABSL_PREDICT_FALSE(should_sample)) {
  ------------------
  |  |  189|  6.00k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 6.00k]
  |  |  |  Branch (189:49): [Folded, False: 6.00k]
  |  |  |  Branch (189:58): [True: 0, False: 6.00k]
  |  |  ------------------
  ------------------
  849|      0|    infoz = ForcedTrySample(slot_size, policy.key_size, policy.value_size,
  850|      0|                            policy.soo_capacity());
  851|      0|  }
  852|  6.00k|  ResizeNonSooImpl<ResizeNonSooMode::kGuaranteedEmpty>(common, policy,
  853|  6.00k|                                                       new_capacity, infoz);
  854|  6.00k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_116ResizeNonSooImplILNS2_16ResizeNonSooModeE0EEEvRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_20HashtablezInfoHandleE:
  789|  6.00k|                      size_t new_capacity, HashtablezInfoHandle infoz) {
  790|  6.00k|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(new_capacity));
  ------------------
  |  |   62|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  791|  6.00k|  ABSL_SWISSTABLE_ASSERT(new_capacity > policy.soo_capacity());
  ------------------
  |  |   62|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  792|       |
  793|  6.00k|  [[maybe_unused]] const size_t old_capacity = common.capacity();
  794|  6.00k|  [[maybe_unused]] ctrl_t* old_ctrl;
  795|  6.00k|  [[maybe_unused]] void* old_slots;
  796|       |  if constexpr (kMode == ResizeNonSooMode::kGuaranteedAllocated) {
  797|       |    old_ctrl = common.control();
  798|       |    old_slots = common.slot_array();
  799|       |  }
  800|       |
  801|  6.00k|  const size_t slot_size = policy.slot_size;
  802|  6.00k|  [[maybe_unused]] const size_t slot_align = policy.slot_align;
  803|  6.00k|  const bool has_infoz = infoz.IsSampled();
  804|  6.00k|  void* alloc = policy.get_char_alloc(common);
  805|       |
  806|  6.00k|  common.set_capacity(new_capacity);
  807|  6.00k|  const auto [new_ctrl, new_slots] =
  808|  6.00k|      AllocBackingArray(common, policy, new_capacity, has_infoz, alloc);
  809|  6.00k|  common.set_control(new_ctrl);
  810|  6.00k|  common.set_slots(new_slots);
  811|  6.00k|  common.generate_new_seed(has_infoz);
  812|       |
  813|  6.00k|  size_t total_probe_length = 0;
  814|  6.00k|  ResetCtrl(common, slot_size);
  815|  6.00k|  ABSL_SWISSTABLE_ASSERT(kMode != ResizeNonSooMode::kGuaranteedEmpty ||
  ------------------
  |  |   62|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  816|  6.00k|                         old_capacity == policy.soo_capacity());
  817|  6.00k|  ABSL_SWISSTABLE_ASSERT(kMode != ResizeNonSooMode::kGuaranteedAllocated ||
  ------------------
  |  |   62|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  818|  6.00k|                         old_capacity > 0);
  819|       |  if constexpr (kMode == ResizeNonSooMode::kGuaranteedAllocated) {
  820|       |    total_probe_length = FindNewPositionsAndTransferSlots(
  821|       |        common, policy, old_ctrl, old_slots, old_capacity);
  822|       |    (*policy.dealloc)(alloc, old_capacity, old_ctrl, slot_size, slot_align,
  823|       |                      has_infoz);
  824|       |    ResetGrowthLeft(GetGrowthInfoFromControl(new_ctrl), new_capacity,
  825|       |                    common.size());
  826|  6.00k|  } else {
  827|  6.00k|    GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(
  828|  6.00k|        CapacityToGrowth(new_capacity));
  829|  6.00k|  }
  830|       |
  831|  6.00k|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  189|  6.00k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 6.00k]
  |  |  |  Branch (189:49): [Folded, False: 6.00k]
  |  |  |  Branch (189:58): [True: 0, False: 6.00k]
  |  |  ------------------
  ------------------
  832|      0|    ReportResizeToInfoz(common, infoz, total_probe_length);
  833|      0|  }
  834|  6.00k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_17SetCtrlERKNS1_12CommonFieldsEmhm:
  365|  26.4M|inline void SetCtrl(const CommonFields& c, size_t i, h2_t h, size_t slot_size) {
  366|  26.4M|  SetCtrl(c, i, static_cast<ctrl_t>(h), slot_size);
  367|  26.4M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_141ReserveEmptyNonAllocatedTableToFitNewSizeERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1683|  6.00k|    size_t new_size) {
 1684|  6.00k|  ValidateMaxSize(new_size, policy.slot_size);
 1685|  6.00k|  ABSL_ASSUME(new_size > 0);
  ------------------
  |  |  270|  6.00k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1686|  6.00k|  ResizeEmptyNonAllocatedTableImpl(common, policy, SizeToCapacity(new_size),
 1687|  6.00k|                                   /*force_infoz=*/false);
 1688|       |  // This is after resize, to ensure that we have completed the allocation
 1689|       |  // and have potentially sampled the hashtable.
 1690|  6.00k|  common.infoz().RecordReservation(new_size);
 1691|  6.00k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_122PrepareInsertLargeImplERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_18NonIterableBitMaskItLi16ELi0EEENS1_8FindInfoE:
 1970|  26.4M|                              FindInfo target_group) {
 1971|  26.4M|  ABSL_SWISSTABLE_ASSERT(!common.is_small());
  ------------------
  |  |   62|  26.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1972|  26.4M|  const GrowthInfo growth_info = common.growth_info();
 1973|       |  // When there are no deleted slots in the table
 1974|       |  // and growth_left is positive, we can insert at the first
 1975|       |  // empty slot in the probe sequence (target).
 1976|  26.4M|  if (ABSL_PREDICT_FALSE(!growth_info.HasNoDeletedAndGrowthLeft())) {
  ------------------
  |  |  189|  26.4M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 4.85k, False: 26.4M]
  |  |  |  Branch (189:49): [Folded, False: 26.4M]
  |  |  |  Branch (189:58): [True: 4.85k, False: 26.4M]
  |  |  ------------------
  ------------------
 1977|  4.85k|    return PrepareInsertLargeSlow(common, policy, hash);
 1978|  4.85k|  }
 1979|  26.4M|  PrepareInsertCommon(common);
 1980|  26.4M|  common.growth_info().OverwriteEmptyAsFull();
 1981|  26.4M|  target_group.offset += mask_empty.LowestBitSet();
 1982|  26.4M|  target_group.offset &= common.capacity();
 1983|  26.4M|  SetCtrl(common, target_group.offset, H2(hash), policy.slot_size);
 1984|  26.4M|  common.infoz().RecordInsertMiss(hash, target_group.probe_length);
 1985|  26.4M|  return target_group.offset;
 1986|  26.4M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_122PrepareInsertLargeSlowERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1632|  4.85k|                              size_t hash) {
 1633|  4.85k|  const GrowthInfo growth_info = common.growth_info();
 1634|  4.85k|  ABSL_SWISSTABLE_ASSERT(!growth_info.HasNoDeletedAndGrowthLeft());
  ------------------
  |  |   62|  4.85k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1635|  4.85k|  if (ABSL_PREDICT_TRUE(growth_info.HasNoGrowthLeftAndNoDeleted())) {
  ------------------
  |  |  190|  4.85k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 4.85k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 4.85k]
  |  |  |  Branch (190:57): [True: 4.85k, False: 0]
  |  |  ------------------
  ------------------
 1636|       |    // Table without deleted slots (>95% cases) that needs to be resized.
 1637|  4.85k|    ABSL_SWISSTABLE_ASSERT(growth_info.HasNoDeleted() &&
  ------------------
  |  |   62|  4.85k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1638|  4.85k|                           growth_info.GetGrowthLeft() == 0);
 1639|  4.85k|    return GrowToNextCapacityAndPrepareInsert(common, policy, hash);
 1640|  4.85k|  }
 1641|      0|  if (ABSL_PREDICT_FALSE(growth_info.HasNoGrowthLeftAssumingMayHaveDeleted())) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1642|       |    // Table with deleted slots that needs to be rehashed or resized.
 1643|      0|    return RehashOrGrowToNextCapacityAndPrepareInsert(common, policy, hash);
 1644|      0|  }
 1645|       |  // Table with deleted slots that has space for the inserting element.
 1646|      0|  FindInfo target = find_first_non_full(common, hash);
 1647|      0|  PrepareInsertCommon(common);
 1648|      0|  common.growth_info().OverwriteControlAsFull(common.control()[target.offset]);
 1649|      0|  SetCtrlInLargeTable(common, target.offset, H2(hash), policy.slot_size);
 1650|      0|  common.infoz().RecordInsertMiss(hash, target.probe_length);
 1651|      0|  return target.offset;
 1652|      0|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_134GrowToNextCapacityAndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1456|  4.85k|    size_t new_hash) {
 1457|  4.85k|  ABSL_SWISSTABLE_ASSERT(common.growth_left() == 0);
  ------------------
  |  |   62|  4.85k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1458|  4.85k|  const size_t old_capacity = common.capacity();
 1459|  4.85k|  ABSL_SWISSTABLE_ASSERT(old_capacity > policy.soo_capacity());
  ------------------
  |  |   62|  4.85k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1460|  4.85k|  ABSL_SWISSTABLE_ASSERT(!IsSmallCapacity(old_capacity));
  ------------------
  |  |   62|  4.85k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1461|       |
 1462|  4.85k|  const size_t new_capacity = NextCapacity(old_capacity);
 1463|  4.85k|  ctrl_t* old_ctrl = common.control();
 1464|  4.85k|  void* old_slots = common.slot_array();
 1465|       |
 1466|  4.85k|  common.set_capacity(new_capacity);
 1467|  4.85k|  const size_t slot_size = policy.slot_size;
 1468|  4.85k|  const size_t slot_align = policy.slot_align;
 1469|  4.85k|  void* alloc = policy.get_char_alloc(common);
 1470|  4.85k|  HashtablezInfoHandle infoz = common.infoz();
 1471|  4.85k|  const bool has_infoz = infoz.IsSampled();
 1472|       |
 1473|  4.85k|  const auto [new_ctrl, new_slots] =
 1474|  4.85k|      AllocBackingArray(common, policy, new_capacity, has_infoz, alloc);
 1475|  4.85k|  common.set_control(new_ctrl);
 1476|  4.85k|  common.set_slots(new_slots);
 1477|  4.85k|  SanitizerPoisonMemoryRegion(new_slots, new_capacity * slot_size);
 1478|       |
 1479|  4.85k|  h2_t new_h2 = H2(new_hash);
 1480|  4.85k|  size_t total_probe_length = 0;
 1481|  4.85k|  FindInfo find_info;
 1482|  4.85k|  if (ABSL_PREDICT_TRUE(is_single_group(new_capacity))) {
  ------------------
  |  |  190|  4.85k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 732, False: 4.12k]
  |  |  |  Branch (190:48): [Folded, False: 4.85k]
  |  |  |  Branch (190:57): [True: 732, False: 4.12k]
  |  |  ------------------
  ------------------
 1483|    732|    size_t offset;
 1484|    732|    GrowIntoSingleGroupShuffleControlBytes(old_ctrl, old_capacity, new_ctrl,
 1485|    732|                                           new_capacity);
 1486|       |    // We put the new element either at the beginning or at the end of the
 1487|       |    // table with approximately equal probability.
 1488|    732|    offset =
 1489|    732|        SingleGroupTableH1(new_hash, common.seed()) & 1 ? 0 : new_capacity - 1;
  ------------------
  |  Branch (1489:9): [True: 391, False: 341]
  ------------------
 1490|       |
 1491|    732|    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[offset]));
  ------------------
  |  |   62|    732|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1492|    732|    SetCtrlInSingleGroupTable(common, offset, new_h2, policy.slot_size);
 1493|    732|    find_info = FindInfo{offset, 0};
 1494|       |    // Single group tables have all slots full on resize. So we can transfer
 1495|       |    // all slots without checking the control bytes.
 1496|    732|    ABSL_SWISSTABLE_ASSERT(common.size() == old_capacity);
  ------------------
  |  |   62|    732|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1497|    732|    void* target = NextSlot(new_slots, slot_size);
 1498|    732|    SanitizerUnpoisonMemoryRegion(target, old_capacity * slot_size);
 1499|    732|    policy.transfer_n(&common, target, old_slots, old_capacity);
 1500|  4.12k|  } else {
 1501|  4.12k|    total_probe_length =
 1502|  4.12k|        GrowToNextCapacityDispatch(common, policy, old_ctrl, old_slots);
 1503|  4.12k|    find_info = find_first_non_full(common, new_hash);
 1504|  4.12k|    SetCtrlInLargeTable(common, find_info.offset, new_h2, policy.slot_size);
 1505|  4.12k|  }
 1506|  4.85k|  ABSL_SWISSTABLE_ASSERT(old_capacity > policy.soo_capacity());
  ------------------
  |  |   62|  4.85k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1507|  4.85k|  (*policy.dealloc)(alloc, old_capacity, old_ctrl, slot_size, slot_align,
 1508|  4.85k|                    has_infoz);
 1509|  4.85k|  PrepareInsertCommon(common);
 1510|  4.85k|  ResetGrowthLeft(GetGrowthInfoFromControl(new_ctrl), new_capacity,
 1511|  4.85k|                  common.size());
 1512|       |
 1513|  4.85k|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  189|  4.85k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 4.85k]
  |  |  |  Branch (189:49): [Folded, False: 4.85k]
  |  |  |  Branch (189:58): [True: 0, False: 4.85k]
  |  |  ------------------
  ------------------
 1514|      0|    ReportGrowthToInfoz(common, infoz, new_hash, total_probe_length,
 1515|      0|                        find_info.probe_length);
 1516|      0|  }
 1517|  4.85k|  return find_info.offset;
 1518|  4.85k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_138GrowIntoSingleGroupShuffleControlBytesEPNS1_6ctrl_tEmS4_m:
  941|    732|                                            size_t new_capacity) {
  942|    732|  ABSL_SWISSTABLE_ASSERT(is_single_group(new_capacity));
  ------------------
  |  |   62|    732|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  943|    732|  constexpr size_t kHalfWidth = Group::kWidth / 2;
  944|    732|  ABSL_ASSUME(old_capacity < kHalfWidth);
  ------------------
  |  |  270|    732|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  945|    732|  ABSL_ASSUME(old_capacity > 0);
  ------------------
  |  |  270|    732|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  946|    732|  static_assert(Group::kWidth == 8 || Group::kWidth == 16,
  947|    732|                "Group size is not supported.");
  948|       |
  949|       |  // NOTE: operations are done with compile time known size = 8.
  950|       |  // Compiler optimizes that into single ASM operation.
  951|       |
  952|       |  // Load the bytes from old_capacity. This contains
  953|       |  // - the sentinel byte
  954|       |  // - all the old control bytes
  955|       |  // - the rest is filled with kEmpty bytes
  956|       |  // Example:
  957|       |  // old_ctrl =     012S012EEEEEEEEE...
  958|       |  // copied_bytes = S012EEEE
  959|    732|  uint64_t copied_bytes = absl::little_endian::Load64(old_ctrl + old_capacity);
  960|       |
  961|       |  // We change the sentinel byte to kEmpty before storing to both the start of
  962|       |  // the new_ctrl, and past the end of the new_ctrl later for the new cloned
  963|       |  // bytes. Note that this is faster than setting the sentinel byte to kEmpty
  964|       |  // after the copy directly in new_ctrl because we are limited on store
  965|       |  // bandwidth.
  966|    732|  static constexpr uint64_t kEmptyXorSentinel =
  967|    732|      static_cast<uint8_t>(ctrl_t::kEmpty) ^
  968|    732|      static_cast<uint8_t>(ctrl_t::kSentinel);
  969|       |
  970|       |  // Replace the first byte kSentinel with kEmpty.
  971|       |  // Resulting bytes will be shifted by one byte old control blocks.
  972|       |  // Example:
  973|       |  // old_ctrl = 012S012EEEEEEEEE...
  974|       |  // before =   S012EEEE
  975|       |  // after  =   E012EEEE
  976|    732|  copied_bytes ^= kEmptyXorSentinel;
  977|       |
  978|    732|  if (Group::kWidth == 8) {
  ------------------
  |  Branch (978:7): [Folded, False: 732]
  ------------------
  979|       |    // With group size 8, we can grow with two write operations.
  980|      0|    ABSL_SWISSTABLE_ASSERT(old_capacity < 8 &&
  ------------------
  |  |   62|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  981|      0|                           "old_capacity is too large for group size 8");
  982|      0|    absl::little_endian::Store64(new_ctrl, copied_bytes);
  983|       |
  984|      0|    static constexpr uint64_t kSentinal64 =
  985|      0|        static_cast<uint8_t>(ctrl_t::kSentinel);
  986|       |
  987|       |    // Prepend kSentinel byte to the beginning of copied_bytes.
  988|       |    // We have maximum 3 non-empty bytes at the beginning of copied_bytes for
  989|       |    // group size 8.
  990|       |    // Example:
  991|       |    // old_ctrl = 012S012EEEE
  992|       |    // before =   E012EEEE
  993|       |    // after  =   SE012EEE
  994|      0|    copied_bytes = (copied_bytes << 8) ^ kSentinal64;
  995|      0|    absl::little_endian::Store64(new_ctrl + new_capacity, copied_bytes);
  996|       |    // Example for capacity 3:
  997|       |    // old_ctrl = 012S012EEEE
  998|       |    // After the first store:
  999|       |    //           >!
 1000|       |    // new_ctrl = E012EEEE???????
 1001|       |    // After the second store:
 1002|       |    //                  >!
 1003|       |    // new_ctrl = E012EEESE012EEE
 1004|      0|    return;
 1005|      0|  }
 1006|       |
 1007|    732|  ABSL_SWISSTABLE_ASSERT(Group::kWidth == 16);  // NOLINT(misc-static-assert)
  ------------------
  |  |   62|    732|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1008|       |
 1009|       |  // Fill the second half of the main control bytes with kEmpty.
 1010|       |  // For small capacity that may write into mirrored control bytes.
 1011|       |  // It is fine as we will overwrite all the bytes later.
 1012|    732|  std::memset(new_ctrl + kHalfWidth, static_cast<int8_t>(ctrl_t::kEmpty),
 1013|    732|              kHalfWidth);
 1014|       |  // Fill the second half of the mirrored control bytes with kEmpty.
 1015|    732|  std::memset(new_ctrl + new_capacity + kHalfWidth,
 1016|    732|              static_cast<int8_t>(ctrl_t::kEmpty), kHalfWidth);
 1017|       |  // Copy the first half of the non-mirrored control bytes.
 1018|    732|  absl::little_endian::Store64(new_ctrl, copied_bytes);
 1019|    732|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
 1020|       |  // Copy the first half of the mirrored control bytes.
 1021|    732|  absl::little_endian::Store64(new_ctrl + new_capacity + 1, copied_bytes);
 1022|       |
 1023|       |  // Example for growth capacity 1->3:
 1024|       |  // old_ctrl =                  0S0EEEEEEEEEEEEEE
 1025|       |  // new_ctrl at the end =       E0ESE0EEEEEEEEEEEEE
 1026|       |  //                                    >!
 1027|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???
 1028|       |  //                                       >!
 1029|       |  // new_ctrl after 2nd memset = ????????EEEEEEEEEEE
 1030|       |  //                            >!
 1031|       |  // new_ctrl after 1st store =  E0EEEEEEEEEEEEEEEEE
 1032|       |  // new_ctrl after kSentinel =  E0ESEEEEEEEEEEEEEEE
 1033|       |  //                                >!
 1034|       |  // new_ctrl after 2nd store =  E0ESE0EEEEEEEEEEEEE
 1035|       |
 1036|       |  // Example for growth capacity 3->7:
 1037|       |  // old_ctrl =                  012S012EEEEEEEEEEEE
 1038|       |  // new_ctrl at the end =       E012EEESE012EEEEEEEEEEE
 1039|       |  //                                    >!
 1040|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???????
 1041|       |  //                                           >!
 1042|       |  // new_ctrl after 2nd memset = ????????EEEEEEEEEEEEEEE
 1043|       |  //                            >!
 1044|       |  // new_ctrl after 1st store =  E012EEEEEEEEEEEEEEEEEEE
 1045|       |  // new_ctrl after kSentinel =  E012EEESEEEEEEEEEEEEEEE
 1046|       |  //                                >!
 1047|       |  // new_ctrl after 2nd store =  E012EEESE012EEEEEEEEEEE
 1048|       |
 1049|       |  // Example for growth capacity 7->15:
 1050|       |  // old_ctrl =                  0123456S0123456EEEEEEEE
 1051|       |  // new_ctrl at the end =       E0123456EEEEEEESE0123456EEEEEEE
 1052|       |  //                                    >!
 1053|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???????????????
 1054|       |  //                                                   >!
 1055|       |  // new_ctrl after 2nd memset = ????????EEEEEEEE???????EEEEEEEE
 1056|       |  //                            >!
 1057|       |  // new_ctrl after 1st store =  E0123456EEEEEEEE???????EEEEEEEE
 1058|       |  // new_ctrl after kSentinel =  E0123456EEEEEEES???????EEEEEEEE
 1059|       |  //                                            >!
 1060|       |  // new_ctrl after 2nd store =  E0123456EEEEEEESE0123456EEEEEEE
 1061|    732|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_126GrowToNextCapacityDispatchERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1368|  4.12k|                                  ctrl_t* old_ctrl, void* old_slots) {
 1369|  4.12k|  const size_t new_capacity = common.capacity();
 1370|  4.12k|  if (ABSL_PREDICT_TRUE(new_capacity <= kMaxLocalBufferNewCapacity)) {
  ------------------
  |  |  190|  4.12k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 1.46k, False: 2.66k]
  |  |  |  Branch (190:48): [Folded, False: 4.12k]
  |  |  |  Branch (190:57): [True: 1.46k, False: 2.66k]
  |  |  ------------------
  ------------------
 1371|  1.46k|    return GrowToNextCapacityThatFitsInLocalBuffer(common, policy, old_ctrl,
 1372|  1.46k|                                                   old_slots);
 1373|  2.66k|  } else {
 1374|  2.66k|    return GrowToNextCapacityOverflowLocalBuffer(common, policy, old_ctrl,
 1375|  2.66k|                                                 old_slots);
 1376|  2.66k|  }
 1377|  4.12k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_139GrowToNextCapacityThatFitsInLocalBufferERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1318|  1.46k|    ctrl_t* old_ctrl, void* old_slots) {
 1319|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= kMaxLocalBufferNewCapacity);
  ------------------
  |  |   62|  1.46k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1320|  1.46k|  return GrowToNextCapacity<
 1321|  1.46k|      ProbedItemEncoder<ProbedItem4Bytes, /*kGuaranteedFitToBuffer=*/true>>(
 1322|  1.46k|      common, policy, old_ctrl, old_slots);
 1323|  1.46k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1299|  1.46k|                          ctrl_t* old_ctrl, void* old_slots) {
 1300|  1.46k|  using ProbedItem = typename Encoder::ProbedItem;
 1301|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   62|  1.46k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1302|  1.46k|  Encoder encoder(old_ctrl);
 1303|  1.46k|  policy.transfer_unprobed_elements_to_next_capacity(
 1304|  1.46k|      common, old_ctrl, old_slots, &encoder,
 1305|  1.46k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|  1.46k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|  1.46k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|  1.46k|      });
 1309|  1.46k|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1310|  1.46k|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1311|  1.46k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEC2EPNS1_6ctrl_tE:
 1174|  1.46k|  explicit ProbedItemEncoder(ctrl_t* control) : control_(control) {}
raw_hash_set.cc:_ZZN4absl12lts_2026010718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPvENKUlSF_hmmE_clESF_hmm:
 1305|    804|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|    804|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|    804|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|    804|      });
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EE10EncodeItemES5_:
 1177|    804|  void EncodeItem(ProbedItem item) {
 1178|    804|    if (ABSL_PREDICT_FALSE(!kGuaranteedFitToBuffer && pos_ >= end_)) {
  ------------------
  |  |  189|    804|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [Folded, False: 804]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:59): [Folded, False: 0]
  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1179|      0|      return ProcessEncodeWithOverflow(item);
 1180|      0|    }
 1181|    804|    ABSL_SWISSTABLE_ASSERT(pos_ < end_);
  ------------------
  |  |   62|    804|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1182|    804|    *pos_ = item;
 1183|    804|    ++pos_;
 1184|    804|  }
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_130InitializeMirroredControlBytesEPNS1_6ctrl_tEm:
 1150|  4.12k|void InitializeMirroredControlBytes(ctrl_t* new_ctrl, size_t new_capacity) {
 1151|  4.12k|  std::memcpy(new_ctrl + new_capacity,
 1152|       |              // We own GrowthInfo just before control bytes. So it is ok
 1153|       |              // to read one byte from it.
 1154|  4.12k|              new_ctrl - 1, Group::kWidth);
 1155|  4.12k|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
 1156|  4.12k|}
raw_hash_set.cc:_ZNK4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1191|  1.46k|                                void* old_slots) const {
 1192|  1.46k|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1192:9): [True: 1.04k, False: 415]
  ------------------
 1193|  1.04k|      return 0;
 1194|  1.04k|    }
 1195|    415|    if constexpr (kGuaranteedFitToBuffer) {
 1196|    415|      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1197|    415|    }
 1198|      0|    size_t total_probe_length = DecodeAndInsertImpl(
 1199|    415|        common, policy, buffer_,
 1200|    415|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1200:9): [True: 0, False: 415]
  ------------------
 1201|    415|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1201:9): [True: 0, False: 415]
  ------------------
 1202|      0|      return total_probe_length;
 1203|      0|    }
 1204|    415|    total_probe_length +=
 1205|    415|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1206|    415|    return total_probe_length;
 1207|    415|  }
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119DecodeAndInsertImplINS1_14ProbedItemImplIjLm32EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPKT_SD_Pv:
 1073|  1.38k|    const ProbedItem* start, const ProbedItem* end, void* old_slots) {
 1074|  1.38k|  const size_t new_capacity = c.capacity();
 1075|       |
 1076|  1.38k|  void* new_slots = c.slot_array();
 1077|  1.38k|  ctrl_t* new_ctrl = c.control();
 1078|  1.38k|  size_t total_probe_length = 0;
 1079|       |
 1080|  1.38k|  const size_t slot_size = policy.slot_size;
 1081|  1.38k|  auto transfer_n = policy.transfer_n;
 1082|       |
 1083|  5.97k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1083:10): [True: 4.58k, False: 1.38k]
  ------------------
 1084|  4.58k|    const FindInfo target = find_first_non_full_from_h1(
 1085|  4.58k|        new_ctrl, static_cast<size_t>(start->h1), new_capacity);
 1086|  4.58k|    total_probe_length += target.probe_length;
 1087|  4.58k|    const size_t old_index = static_cast<size_t>(start->source_offset);
 1088|  4.58k|    const size_t new_i = target.offset;
 1089|  4.58k|    ABSL_SWISSTABLE_ASSERT(old_index < new_capacity / 2);
  ------------------
  |  |   62|  4.58k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1090|  4.58k|    ABSL_SWISSTABLE_ASSERT(new_i < new_capacity);
  ------------------
  |  |   62|  4.58k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1091|       |    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_i]));
  ------------------
  |  |   62|  4.58k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1092|  4.58k|    void* src_slot = SlotAddress(old_slots, old_index, slot_size);
 1093|  4.58k|    void* dst_slot = SlotAddress(new_slots, new_i, slot_size);
 1094|  4.58k|    SanitizerUnpoisonMemoryRegion(dst_slot, slot_size);
 1095|  4.58k|    transfer_n(&c, dst_slot, src_slot, 1);
 1096|  4.58k|    SetCtrlInLargeTable(c, new_i, static_cast<h2_t>(start->h2), slot_size);
 1097|  4.58k|  }
 1098|  1.38k|  return total_probe_length;
 1099|  1.38k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_127find_first_non_full_from_h1EPKNS1_6ctrl_tEmm:
  187|  11.4k|                                     size_t capacity) {
  188|  11.4k|  auto seq = probe_h1(capacity, h1);
  189|  11.4k|  if (IsEmptyOrDeleted(ctrl[seq.offset()])) {
  ------------------
  |  Branch (189:7): [True: 5.13k, False: 6.29k]
  ------------------
  190|  5.13k|    return {seq.offset(), /*probe_length=*/0};
  191|  5.13k|  }
  192|  6.29k|  auto mask = probe_till_first_non_full_group(ctrl, seq, capacity);
  193|  6.29k|  return {seq.offset(mask.LowestBitSet()), seq.index()};
  194|  11.4k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_131probe_till_first_non_full_groupEPKNS1_6ctrl_tERNS1_9probe_seqILm16EEEm:
  174|  6.29k|    [[maybe_unused]] size_t capacity) {
  175|  7.37k|  while (true) {
  ------------------
  |  Branch (175:10): [True: 7.37k, Folded]
  ------------------
  176|  7.37k|    GroupFullEmptyOrDeleted g{ctrl + seq.offset()};
  177|  7.37k|    auto mask = g.MaskEmptyOrDeleted();
  178|  7.37k|    if (mask) {
  ------------------
  |  Branch (178:9): [True: 6.29k, False: 1.08k]
  ------------------
  179|  6.29k|      return mask;
  180|  6.29k|    }
  181|  1.08k|    seq.next();
  182|       |    ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity && "full table!");
  ------------------
  |  |   62|  1.08k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  183|  1.08k|  }
  184|  6.29k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_137GrowToNextCapacityOverflowLocalBufferERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1351|  2.66k|    ctrl_t* old_ctrl, void* old_slots) {
 1352|  2.66k|  const size_t new_capacity = common.capacity();
 1353|  2.66k|  if (ABSL_PREDICT_TRUE(new_capacity <= ProbedItem4Bytes::kMaxNewCapacity)) {
  ------------------
  |  |  190|  2.66k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 1.79k, False: 870]
  |  |  |  Branch (190:48): [Folded, False: 2.66k]
  |  |  |  Branch (190:57): [True: 1.79k, False: 870]
  |  |  ------------------
  ------------------
 1354|  1.79k|    return GrowToNextCapacity4BytesEncoder(common, policy, old_ctrl, old_slots);
 1355|  1.79k|  }
 1356|    870|  if (ABSL_PREDICT_TRUE(new_capacity <= ProbedItem8Bytes::kMaxNewCapacity)) {
  ------------------
  |  |  190|    870|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 870, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 870]
  |  |  |  Branch (190:57): [True: 870, False: 0]
  |  |  ------------------
  ------------------
 1357|    870|    return GrowToNextCapacity8BytesEncoder(common, policy, old_ctrl, old_slots);
 1358|    870|  }
 1359|       |  // 16 bytes encoding supports the maximum swisstable capacity.
 1360|      0|  return GrowToNextCapacity16BytesEncoder(common, policy, old_ctrl, old_slots);
 1361|    870|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_131GrowToNextCapacity4BytesEncoderERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1329|  1.79k|                                       ctrl_t* old_ctrl, void* old_slots) {
 1330|  1.79k|  return GrowToNextCapacity<ProbedItemEncoder<ProbedItem4Bytes>>(
 1331|  1.79k|      common, policy, old_ctrl, old_slots);
 1332|  1.79k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1299|  1.79k|                          ctrl_t* old_ctrl, void* old_slots) {
 1300|  1.79k|  using ProbedItem = typename Encoder::ProbedItem;
 1301|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   62|  1.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1302|  1.79k|  Encoder encoder(old_ctrl);
 1303|  1.79k|  policy.transfer_unprobed_elements_to_next_capacity(
 1304|  1.79k|      common, old_ctrl, old_slots, &encoder,
 1305|  1.79k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|  1.79k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|  1.79k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|  1.79k|      });
 1309|  1.79k|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1310|  1.79k|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1311|  1.79k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EEC2EPNS1_6ctrl_tE:
 1174|  1.79k|  explicit ProbedItemEncoder(ctrl_t* control) : control_(control) {}
raw_hash_set.cc:_ZZN4absl12lts_2026010718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPvENKUlSF_hmmE_clESF_hmm:
 1305|  3.78k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|  3.78k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|  3.78k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|  3.78k|      });
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EE10EncodeItemES5_:
 1177|  3.78k|  void EncodeItem(ProbedItem item) {
 1178|  3.78k|    if (ABSL_PREDICT_FALSE(!kGuaranteedFitToBuffer && pos_ >= end_)) {
  ------------------
  |  |  189|  7.56k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 3.78k]
  |  |  |  Branch (189:49): [Folded, False: 3.78k]
  |  |  |  Branch (189:59): [True: 3.78k, Folded]
  |  |  |  Branch (189:59): [True: 0, False: 3.78k]
  |  |  ------------------
  ------------------
 1179|      0|      return ProcessEncodeWithOverflow(item);
 1180|      0|    }
 1181|  3.78k|    ABSL_SWISSTABLE_ASSERT(pos_ < end_);
  ------------------
  |  |   62|  3.78k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1182|  3.78k|    *pos_ = item;
 1183|  3.78k|    ++pos_;
 1184|  3.78k|  }
raw_hash_set.cc:_ZNK4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1191|  1.79k|                                void* old_slots) const {
 1192|  1.79k|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1192:9): [True: 820, False: 973]
  ------------------
 1193|    820|      return 0;
 1194|    820|    }
 1195|       |    if constexpr (kGuaranteedFitToBuffer) {
 1196|       |      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1197|       |    }
 1198|    973|    size_t total_probe_length = DecodeAndInsertImpl(
 1199|    973|        common, policy, buffer_,
 1200|    973|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1200:9): [True: 0, False: 973]
  ------------------
 1201|    973|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1201:9): [True: 973, False: 0]
  ------------------
 1202|    973|      return total_probe_length;
 1203|    973|    }
 1204|      0|    total_probe_length +=
 1205|      0|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1206|      0|    return total_probe_length;
 1207|    973|  }
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_131GrowToNextCapacity8BytesEncoderERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1335|    870|                                       ctrl_t* old_ctrl, void* old_slots) {
 1336|    870|  return GrowToNextCapacity<ProbedItemEncoder<ProbedItem8Bytes>>(
 1337|    870|      common, policy, old_ctrl, old_slots);
 1338|    870|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1299|    870|                          ctrl_t* old_ctrl, void* old_slots) {
 1300|    870|  using ProbedItem = typename Encoder::ProbedItem;
 1301|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   62|    870|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1302|    870|  Encoder encoder(old_ctrl);
 1303|    870|  policy.transfer_unprobed_elements_to_next_capacity(
 1304|    870|      common, old_ctrl, old_slots, &encoder,
 1305|    870|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|    870|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|    870|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|    870|      });
 1309|    870|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1310|    870|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1311|    870|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EEC2EPNS1_6ctrl_tE:
 1174|    870|  explicit ProbedItemEncoder(ctrl_t* control) : control_(control) {}
raw_hash_set.cc:_ZZN4absl12lts_2026010718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPvENKUlSF_hmmE_clESF_hmm:
 1305|  2.71k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|  2.71k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|  2.71k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|  2.71k|      });
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EE10EncodeItemES5_:
 1177|  2.71k|  void EncodeItem(ProbedItem item) {
 1178|  2.71k|    if (ABSL_PREDICT_FALSE(!kGuaranteedFitToBuffer && pos_ >= end_)) {
  ------------------
  |  |  189|  5.42k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 2.71k]
  |  |  |  Branch (189:49): [Folded, False: 2.71k]
  |  |  |  Branch (189:59): [True: 2.71k, Folded]
  |  |  |  Branch (189:59): [True: 0, False: 2.71k]
  |  |  ------------------
  ------------------
 1179|      0|      return ProcessEncodeWithOverflow(item);
 1180|      0|    }
 1181|  2.71k|    ABSL_SWISSTABLE_ASSERT(pos_ < end_);
  ------------------
  |  |   62|  2.71k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1182|  2.71k|    *pos_ = item;
 1183|  2.71k|    ++pos_;
 1184|  2.71k|  }
raw_hash_set.cc:_ZNK4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1191|    870|                                void* old_slots) const {
 1192|    870|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1192:9): [True: 218, False: 652]
  ------------------
 1193|    218|      return 0;
 1194|    218|    }
 1195|       |    if constexpr (kGuaranteedFitToBuffer) {
 1196|       |      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1197|       |    }
 1198|    652|    size_t total_probe_length = DecodeAndInsertImpl(
 1199|    652|        common, policy, buffer_,
 1200|    652|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1200:9): [True: 0, False: 652]
  ------------------
 1201|    652|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1201:9): [True: 652, False: 0]
  ------------------
 1202|    652|      return total_probe_length;
 1203|    652|    }
 1204|      0|    total_probe_length +=
 1205|      0|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1206|      0|    return total_probe_length;
 1207|    652|  }
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119DecodeAndInsertImplINS1_14ProbedItemImplImLm64EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPKT_SD_Pv:
 1073|    652|    const ProbedItem* start, const ProbedItem* end, void* old_slots) {
 1074|    652|  const size_t new_capacity = c.capacity();
 1075|       |
 1076|    652|  void* new_slots = c.slot_array();
 1077|    652|  ctrl_t* new_ctrl = c.control();
 1078|    652|  size_t total_probe_length = 0;
 1079|       |
 1080|    652|  const size_t slot_size = policy.slot_size;
 1081|    652|  auto transfer_n = policy.transfer_n;
 1082|       |
 1083|  3.36k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1083:10): [True: 2.71k, False: 652]
  ------------------
 1084|  2.71k|    const FindInfo target = find_first_non_full_from_h1(
 1085|  2.71k|        new_ctrl, static_cast<size_t>(start->h1), new_capacity);
 1086|  2.71k|    total_probe_length += target.probe_length;
 1087|  2.71k|    const size_t old_index = static_cast<size_t>(start->source_offset);
 1088|  2.71k|    const size_t new_i = target.offset;
 1089|  2.71k|    ABSL_SWISSTABLE_ASSERT(old_index < new_capacity / 2);
  ------------------
  |  |   62|  2.71k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1090|  2.71k|    ABSL_SWISSTABLE_ASSERT(new_i < new_capacity);
  ------------------
  |  |   62|  2.71k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1091|       |    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_i]));
  ------------------
  |  |   62|  2.71k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1092|  2.71k|    void* src_slot = SlotAddress(old_slots, old_index, slot_size);
 1093|  2.71k|    void* dst_slot = SlotAddress(new_slots, new_i, slot_size);
 1094|  2.71k|    SanitizerUnpoisonMemoryRegion(dst_slot, slot_size);
 1095|  2.71k|    transfer_n(&c, dst_slot, src_slot, 1);
 1096|  2.71k|    SetCtrlInLargeTable(c, new_i, static_cast<h2_t>(start->h2), slot_size);
 1097|  2.71k|  }
 1098|    652|  return total_probe_length;
 1099|    652|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119find_first_non_fullERKNS1_12CommonFieldsEm:
  203|  4.12k|FindInfo find_first_non_full(const CommonFields& common, size_t hash) {
  204|  4.12k|  return find_first_non_full_from_h1(common.control(), H1(hash),
  205|  4.12k|                                     common.capacity());
  206|  4.12k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119SetCtrlInLargeTableERKNS1_12CommonFieldsEmhm:
  398|  11.4k|                                size_t slot_size) {
  399|  11.4k|  SetCtrlInLargeTable(c, i, static_cast<ctrl_t>(h), slot_size);
  400|  11.4k|}

_ZN4absl12lts_2026010718container_internal13HashtableSize14increment_sizeEv:
  477|  26.4M|  void increment_size() { data_ += kSizeOneNoMetadata; }
_ZNK4absl12lts_2026010718container_internal13HashtableSize5emptyEv:
  483|  7.49k|  bool empty() const { return data_ < kSizeOneNoMetadata; }
_ZN4absl12lts_2026010718container_internal13HashtableSize30set_size_to_zero_keep_metadataEv:
  485|  1.26k|  void set_size_to_zero_keep_metadata() { data_ = data_ & kMetadataMask; }
_ZN4absl12lts_2026010718container_internal13HashtableSize17generate_new_seedEv:
  491|  6.36k|  void generate_new_seed() { set_seed(NextSeed()); }
_ZN4absl12lts_2026010718container_internal13HashtableSize8set_seedEt:
  515|  6.36k|  void set_seed(uint16_t seed) {
  516|  6.36k|    data_ = (data_ & ~kSeedMask) | (seed | PerTableSeed::kSignBit);
  517|  6.36k|  }
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled36maybe_increment_generation_on_insertEv:
  627|  26.4M|  void maybe_increment_generation_on_insert() {}
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled21reset_reserved_growthEmm:
  629|  6.00k|  void reset_reserved_growth(size_t, size_t) {}
_ZNK4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled10generationEv:
  634|  11.2k|  GenerationType generation() const { return 0; }
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled14set_generationEh:
  635|  11.2k|  void set_generation(GenerationType) {}
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled18set_generation_ptrEPh:
  637|  11.2k|  void set_generation_ptr(GenerationType*) {}
_ZN4absl12lts_2026010718container_internal10GrowthInfo23InitGrowthLeftNoDeletedEm:
  703|  12.4k|  void InitGrowthLeftNoDeleted(size_t growth_left) {
  704|  12.4k|    growth_left_info_ = growth_left;
  705|  12.4k|  }
_ZN4absl12lts_2026010718container_internal10GrowthInfo20OverwriteEmptyAsFullEv:
  711|  26.4M|  void OverwriteEmptyAsFull() {
  712|       |    ABSL_SWISSTABLE_ASSERT(GetGrowthLeft() > 0);
  ------------------
  |  |  248|  26.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  713|  26.4M|    --growth_left_info_;
  714|  26.4M|  }
_ZNK4absl12lts_2026010718container_internal10GrowthInfo25HasNoDeletedAndGrowthLeftEv:
  735|  26.4M|  bool HasNoDeletedAndGrowthLeft() const {
  736|  26.4M|    return static_cast<std::make_signed_t<size_t>>(growth_left_info_) > 0;
  737|  26.4M|  }
_ZNK4absl12lts_2026010718container_internal10GrowthInfo27HasNoGrowthLeftAndNoDeletedEv:
  742|  4.85k|  bool HasNoGrowthLeftAndNoDeleted() const { return growth_left_info_ == 0; }
_ZN4absl12lts_2026010718container_internal16RawHashSetLayoutC2Emmmb:
  809|  22.4k|      : control_offset_(ControlOffset(has_infoz)),
  810|  22.4k|        generation_offset_(control_offset_ + NumControlBytes(capacity)),
  811|       |        slot_offset_(
  812|  22.4k|            AlignUpTo(generation_offset_ + NumGenerationBytes(), slot_align)),
  813|  22.4k|        alloc_size_(slot_offset_ + capacity * slot_size) {
  814|  22.4k|    ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |  248|  22.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  815|       |    ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |  248|  22.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  816|  22.4k|        slot_size <=
  817|  22.4k|        ((std::numeric_limits<size_t>::max)() - slot_offset_) / capacity);
  818|  22.4k|  }
_ZNK4absl12lts_2026010718container_internal16RawHashSetLayout14control_offsetEv:
  822|  22.4k|  size_t control_offset() const { return control_offset_; }
_ZNK4absl12lts_2026010718container_internal16RawHashSetLayout17generation_offsetEv:
  826|  11.2k|  size_t generation_offset() const { return generation_offset_; }
_ZNK4absl12lts_2026010718container_internal16RawHashSetLayout11slot_offsetEv:
  830|  11.2k|  size_t slot_offset() const { return slot_offset_; }
_ZNK4absl12lts_2026010718container_internal16RawHashSetLayout10alloc_sizeEv:
  834|  33.6k|  size_t alloc_size() const { return alloc_size_; }
_ZN4absl12lts_2026010718container_internal9HeapOrSoo7controlEv:
  877|  11.2k|  MaybeInitializedPtr<ctrl_t>& control() {
  878|  11.2k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.control);
  ------------------
  |  |  488|  11.2k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  879|  11.2k|  }
_ZN4absl12lts_2026010718container_internal9HeapOrSoo10slot_arrayEv:
  883|  11.2k|  MaybeInitializedPtr<void>& slot_array() {
  884|  11.2k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.slot_array);
  ------------------
  |  |  488|  11.2k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  885|  11.2k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields11set_controlEPNS1_6ctrl_tE:
  960|  11.2k|  void set_control(ctrl_t* c) { heap_or_soo_.control().set(c); }
_ZN4absl12lts_2026010718container_internal12CommonFields9set_slotsEPv:
  967|  11.2k|  void set_slots(void* s) { heap_or_soo_.slot_array().set(s); }
_ZN4absl12lts_2026010718container_internal12CommonFields16set_size_to_zeroEv:
  972|  1.26k|  void set_size_to_zero() { size_.set_size_to_zero_keep_metadata(); }
_ZN4absl12lts_2026010718container_internal12CommonFields14increment_sizeEv:
  981|  26.4M|  void increment_size() {
  982|       |    ABSL_SWISSTABLE_ASSERT(size() < capacity());
  ------------------
  |  |  248|  26.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  983|  26.4M|    size_.increment_size();
  984|  26.4M|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields5emptyEv:
  993|  7.49k|  bool empty() const { return size_.empty(); }
_ZN4absl12lts_2026010718container_internal12CommonFields17generate_new_seedEb:
 1000|  6.36k|  void generate_new_seed(bool has_infoz) {
 1001|       |    // Note: we can't use has_infoz() here because we set has_infoz later than
 1002|       |    // we generate the seed.
 1003|  6.36k|    if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  189|  6.36k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 6.36k]
  |  |  |  Branch (189:49): [Folded, False: 6.36k]
  |  |  |  Branch (189:58): [True: 0, False: 6.36k]
  |  |  ------------------
  ------------------
 1004|      0|      size_.set_sampled_seed();
 1005|      0|      return;
 1006|      0|    }
 1007|  6.36k|    size_.generate_new_seed();
 1008|  6.36k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields12set_capacityEm:
 1013|  11.2k|  void set_capacity(size_t c) {
 1014|       |    // We allow setting above the max valid capacity for debugging purposes.
 1015|       |    ABSL_SWISSTABLE_ASSERT(c == 0 || IsValidCapacity(c) ||
  ------------------
  |  |  248|  11.2k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1016|  11.2k|                           c > kAboveMaxValidCapacity);
 1017|  11.2k|    capacity_ = c;
 1018|  11.2k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields11growth_infoEv:
 1027|  52.9M|  GrowthInfo& growth_info() {
 1028|       |    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  52.9M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1029|  52.9M|    return GetGrowthInfoFromControl(control());
 1030|  52.9M|  }
_ZN4absl12lts_2026010718container_internal12CommonFields21reset_reserved_growthEm:
 1072|  6.00k|  void reset_reserved_growth(size_t reservation) {
 1073|  6.00k|    CommonFieldsGenerationInfo::reset_reserved_growth(reservation, size());
 1074|  6.00k|  }
_ZNK4absl12lts_2026010718container_internal15PolicyFunctions12soo_capacityEv:
 1561|  6.00k|  uint8_t soo_capacity() const {
 1562|  6.00k|    return static_cast<uint8_t>(soo_enabled ? SooCapacity() : 0);
  ------------------
  |  Branch (1562:33): [True: 0, False: 6.00k]
  ------------------
 1563|  6.00k|  }
_ZN4absl12lts_2026010718container_internal24MaxValidSizeFor1ByteSlotILm8EEEmv:
 1570|  6.00k|constexpr size_t MaxValidSizeFor1ByteSlot() {
 1571|  6.00k|  if constexpr (kSizeOfSizeT == 8) {
 1572|  6.00k|    return CapacityToGrowth(
 1573|  6.00k|        static_cast<size_t>(uint64_t{1} << HashtableSize::kSizeBitCount) - 1);
 1574|       |  } else {
 1575|       |    static_assert(kSizeOfSizeT == 4);
 1576|       |    return CapacityToGrowth((size_t{1} << (kSizeOfSizeT * 8 - 2)) - 1);
 1577|       |  }
 1578|  6.00k|}
_ZN4absl12lts_2026010718container_internal23SentinelEmptyGenerationEv:
  256|  11.2k|constexpr GenerationType SentinelEmptyGeneration() { return 0; }
_ZN4absl12lts_2026010718container_internal14NextGenerationEh:
  258|  11.2k|constexpr GenerationType NextGeneration(GenerationType generation) {
  259|  11.2k|  return ++generation == SentinelEmptyGeneration() ? ++generation : generation;
  ------------------
  |  Branch (259:10): [True: 0, False: 11.2k]
  ------------------
  260|  11.2k|}
_ZN4absl12lts_2026010718container_internal18NumGenerationBytesEv:
  267|  22.4k|constexpr size_t NumGenerationBytes() { return 0; }
_ZN4absl12lts_2026010718container_internal9AlignUpToEmm:
  797|  22.4k|constexpr size_t AlignUpTo(size_t offset, size_t align) {
  798|  22.4k|  return (offset + align - 1) & (~align + 1);
  799|  22.4k|}
_ZN4absl12lts_2026010718container_internal24GetGrowthInfoFromControlEPNS1_6ctrl_tE:
  902|  52.9M|inline GrowthInfo& GetGrowthInfoFromControl(ctrl_t* control) {
  903|  52.9M|  auto* gl_ptr = reinterpret_cast<GrowthInfo*>(control) - 1;
  904|       |  ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |  248|  52.9M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  905|  52.9M|      reinterpret_cast<uintptr_t>(gl_ptr) % alignof(GrowthInfo) == 0);
  906|  52.9M|  return *gl_ptr;
  907|  52.9M|}
_ZN4absl12lts_2026010718container_internal12NextCapacityEm:
 1145|  4.85k|constexpr size_t NextCapacity(size_t n) {
 1146|       |  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(n) || n == 0);
  ------------------
  |  |  248|  4.85k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1147|  4.85k|  return n * 2 + 1;
 1148|  4.85k|}
_ZN4absl12lts_2026010718container_internal16CapacityToGrowthEm:
 1181|  18.1k|constexpr size_t CapacityToGrowth(size_t capacity) {
 1182|  18.1k|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |  248|  18.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1183|       |  // `capacity*7/8`
 1184|  18.1k|  if (Group::kWidth == 8 && capacity == 7) {
  ------------------
  |  Branch (1184:7): [Folded, False: 18.1k]
  |  Branch (1184:29): [True: 0, False: 0]
  ------------------
 1185|       |    // x-x/8 does not work when x==7.
 1186|      0|    return 6;
 1187|      0|  }
 1188|  18.1k|  return capacity - capacity / 8;
 1189|  18.1k|}
_ZN4absl12lts_2026010718container_internal14SizeToCapacityEm:
 1196|  6.00k|constexpr size_t SizeToCapacity(size_t size) {
 1197|  6.00k|  if (size == 0) {
  ------------------
  |  Branch (1197:7): [True: 0, False: 6.00k]
  ------------------
 1198|      0|    return 0;
 1199|      0|  }
 1200|       |  // The minimum possible capacity is NormalizeCapacity(size).
 1201|       |  // Shifting right `~size_t{}` by `leading_zeros` yields
 1202|       |  // NormalizeCapacity(size).
 1203|  6.00k|  int leading_zeros = absl::countl_zero(size);
 1204|  6.00k|  constexpr size_t kLast3Bits = size_t{7} << (sizeof(size_t) * 8 - 3);
 1205|       |  // max_size_for_next_capacity = max_load_factor * next_capacity
 1206|       |  //                            = (7/8) * (~size_t{} >> leading_zeros)
 1207|       |  //                            = (7/8*~size_t{}) >> leading_zeros
 1208|       |  //                            = kLast3Bits >> leading_zeros
 1209|  6.00k|  size_t max_size_for_next_capacity = kLast3Bits >> leading_zeros;
 1210|       |  // Decrease shift if size is too big for the minimum capacity.
 1211|  6.00k|  leading_zeros -= static_cast<int>(size > max_size_for_next_capacity);
 1212|       |  if constexpr (Group::kWidth == 8) {
 1213|       |    // Formula doesn't work when size==7 for 8-wide groups.
 1214|       |    leading_zeros -= (size == 7);
 1215|       |  }
 1216|  6.00k|  return (~size_t{}) >> leading_zeros;
 1217|  6.00k|}
_ZN4absl12lts_2026010718container_internal15is_single_groupEm:
 1393|  4.85k|constexpr bool is_single_group(size_t capacity) {
 1394|  4.85k|  return capacity <= Group::kWidth;
 1395|  4.85k|}
_ZN4absl12lts_2026010718container_internal12SooSlotIndexEv:
 1618|    731|constexpr size_t SooSlotIndex() { return 1; }
_ZN4absl12lts_2026010718container_internal19MaybeInitializedPtrINS1_6ctrl_tEE3setEPS3_:
  850|  11.2k|  void set(T* ptr) { p = ptr; }
_ZN4absl12lts_2026010718container_internal19MaybeInitializedPtrIvE3setEPv:
  850|  11.2k|  void set(T* ptr) { p = ptr; }
_ZN4absl12lts_2026010718container_internal20AllocateBackingArrayILm8ENSt3__19allocatorIcEEEEPvS6_m:
 1495|  11.2k|void* AllocateBackingArray(void* alloc, size_t n) {
 1496|  11.2k|  return Allocate<AlignOfBackingArray>(static_cast<Alloc*>(alloc), n);
 1497|  11.2k|}
_ZN4absl12lts_2026010718container_internal22DeallocateBackingArrayILm8ENSt3__19allocatorIcEEEEvPvmPNS1_6ctrl_tEmmb:
 1504|  11.2k|    size_t slot_align, bool had_infoz) {
 1505|  11.2k|  RawHashSetLayout layout(capacity, slot_size, slot_align, had_infoz);
 1506|  11.2k|  void* backing_array = ctrl - layout.control_offset();
 1507|       |  // Unpoison before returning the memory to the allocator.
 1508|  11.2k|  SanitizerUnpoisonMemoryRegion(backing_array, layout.alloc_size());
 1509|  11.2k|  Deallocate<AlignOfBackingArray>(static_cast<Alloc*>(alloc), backing_array,
 1510|  11.2k|                                  layout.alloc_size());
 1511|  11.2k|}
_ZN4absl12lts_2026010718container_internal16IsAboveValidSizeILm8EEEbmm:
 1599|  6.00k|constexpr bool IsAboveValidSize(size_t size, size_t slot_size) {
 1600|  6.00k|  if constexpr (kSizeOfSizeT == 8) {
 1601|       |    // For small slot sizes we are limited by HashtableSize::kSizeBitCount.
 1602|  6.00k|    if (ABSL_PREDICT_TRUE(slot_size <
  ------------------
  |  |  190|  6.00k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 6.00k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 6.00k]
  |  |  |  Branch (190:57): [True: 6.00k, False: 0]
  |  |  ------------------
  ------------------
 1603|  6.00k|                          (size_t{1} << (64 - HashtableSize::kSizeBitCount)))) {
 1604|  6.00k|      return size > MaxValidSizeFor1ByteSlot<kSizeOfSizeT>();
 1605|  6.00k|    }
 1606|      0|    return size > MaxValidSize<kSizeOfSizeT>(slot_size);
 1607|       |  } else {
 1608|       |    return uint64_t{size} * slot_size >
 1609|       |           MaxValidSizeFor1ByteSlot<kSizeOfSizeT>();
 1610|       |  }
 1611|  6.00k|}

_ZN4absl12lts_2026010718container_internal14ProbedItemImplIjLm32EEC2Ehmm:
   59|  4.58k|      : h2(h2_arg),
   60|  4.58k|        source_offset(static_cast<IntType>(source_offset_arg)),
   61|  4.58k|        h1(static_cast<IntType>(h1_arg)) {}
_ZN4absl12lts_2026010718container_internal14ProbedItemImplImLm64EEC2Ehmm:
   59|  2.71k|      : h2(h2_arg),
   60|  2.71k|        source_offset(static_cast<IntType>(source_offset_arg)),
   61|  2.71k|        h1(static_cast<IntType>(h1_arg)) {}

_ZNK4absl12lts_2026010711FunctionRefIFmmEEclEm:
  164|    366|  R operator()(Args... args) const {
  165|    366|    return invoker_(ptr_, std::forward<Args>(args)...);
  166|    366|  }

_ZN4absl12lts_2026010713hash_internal43CombineLargeContiguousImplOn64BitLengthGt32EmPKhm:
  299|   147k|                                                     size_t len) {
  300|   147k|  assert(len > 32);
  301|   147k|  assert(sizeof(size_t) == 8);  // NOLINT(misc-static-assert)
  302|   147k|  if (ABSL_PREDICT_TRUE(len <= PiecewiseChunkSize())) {
  ------------------
  |  |  190|   147k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 146k, False: 1.13k]
  |  |  |  Branch (190:48): [Folded, False: 147k]
  |  |  |  Branch (190:57): [True: 146k, False: 1.13k]
  |  |  ------------------
  ------------------
  303|   146k|    return HashBlockOn64Bit(state, first, len);
  304|   146k|  }
  305|  1.13k|  return SplitAndCombineOn64Bit(state, first, len);
  306|   147k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_116HashBlockOn64BitEmPKhm:
  258|   190k|    uint64_t state, const unsigned char* data, size_t len) {
  259|   190k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  260|   190k|  return LowLevelHashLenGt32(state, data, len);
  261|       |#else
  262|       |  return hash_internal::CityHash64WithSeed(reinterpret_cast<const char*>(data),
  263|       |                                           len, state);
  264|       |#endif
  265|   190k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_119LowLevelHashLenGt32EmPKvm:
  223|   190k|                                              size_t len) {
  224|   190k|  assert(len > 32);
  225|   190k|  if (ABSL_PREDICT_FALSE(len > 64)) {
  ------------------
  |  |  189|   190k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 64.7k, False: 125k]
  |  |  |  Branch (189:49): [Folded, False: 190k]
  |  |  |  Branch (189:58): [True: 64.7k, False: 125k]
  |  |  ------------------
  ------------------
  226|  64.7k|    return LowLevelHashLenGt64(seed, data, len);
  227|  64.7k|  }
  228|   125k|  return LowLevelHash33To64(seed, static_cast<const uint8_t*>(data), len);
  229|   190k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_119LowLevelHashLenGt64EmPKvm:
  173|  64.7k|LowLevelHashLenGt64(uint64_t seed, const void* data, size_t len) {
  174|  64.7k|  assert(len > 64);
  175|  64.7k|  const uint8_t* ptr = static_cast<const uint8_t*>(data);
  176|  64.7k|  uint64_t current_state = seed ^ kStaticRandomData[0] ^ len;
  177|  64.7k|  const uint8_t* last_32_ptr = ptr + len - 32;
  178|       |  // If we have more than 64 bytes, we're going to handle chunks of 64
  179|       |  // bytes at a time. We're going to build up four separate hash states
  180|       |  // which we will then hash together. This avoids short dependency chains.
  181|  64.7k|  uint64_t duplicated_state0 = current_state;
  182|  64.7k|  uint64_t duplicated_state1 = current_state;
  183|  64.7k|  uint64_t duplicated_state2 = current_state;
  184|       |
  185|   711k|  do {
  186|   711k|    PrefetchFutureDataToLocalCache(ptr);
  187|       |
  188|   711k|    uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
  189|   711k|    uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
  190|   711k|    uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
  191|   711k|    uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
  192|   711k|    uint64_t e = absl::base_internal::UnalignedLoad64(ptr + 32);
  193|   711k|    uint64_t f = absl::base_internal::UnalignedLoad64(ptr + 40);
  194|   711k|    uint64_t g = absl::base_internal::UnalignedLoad64(ptr + 48);
  195|   711k|    uint64_t h = absl::base_internal::UnalignedLoad64(ptr + 56);
  196|       |
  197|   711k|    current_state = Mix(a ^ kStaticRandomData[1], b ^ current_state);
  198|   711k|    duplicated_state0 = Mix(c ^ kStaticRandomData[2], d ^ duplicated_state0);
  199|       |
  200|   711k|    duplicated_state1 = Mix(e ^ kStaticRandomData[3], f ^ duplicated_state1);
  201|   711k|    duplicated_state2 = Mix(g ^ kStaticRandomData[4], h ^ duplicated_state2);
  202|       |
  203|   711k|    ptr += 64;
  204|   711k|    len -= 64;
  205|   711k|  } while (len > 64);
  ------------------
  |  Branch (205:12): [True: 646k, False: 64.7k]
  ------------------
  206|       |
  207|  64.7k|  current_state = (current_state ^ duplicated_state0) ^
  208|  64.7k|                  (duplicated_state1 + duplicated_state2);
  209|       |  // We now have a data `ptr` with at most 64 bytes and the current state
  210|       |  // of the hashing state machine stored in current_state.
  211|  64.7k|  if (len > 32) {
  ------------------
  |  Branch (211:7): [True: 51.3k, False: 13.4k]
  ------------------
  212|  51.3k|    current_state = Mix32Bytes(ptr, current_state);
  213|  51.3k|  }
  214|       |
  215|       |  // We now have a data `ptr` with at most 32 bytes and the current state
  216|       |  // of the hashing state machine stored in current_state. But we can
  217|       |  // safely read from `ptr + len - 32`.
  218|  64.7k|  return Mix32Bytes(last_32_ptr, current_state);
  219|  64.7k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_130PrefetchFutureDataToLocalCacheEPKh:
   48|   711k|void PrefetchFutureDataToLocalCache(const uint8_t* ptr) {
   49|   711k|  PrefetchToLocalCache(ptr + 5 * ABSL_CACHELINE_SIZE);
  ------------------
  |  |   88|   711k|#define ABSL_CACHELINE_SIZE 64
  ------------------
   50|   711k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_110Mix32BytesEPKhm:
  153|   366k|uint64_t Mix32Bytes(const uint8_t* ptr, uint64_t current_state) {
  154|   366k|  uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
  155|   366k|  uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
  156|   366k|  uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
  157|   366k|  uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
  158|       |
  159|   366k|  uint64_t cs0 = Mix(a ^ kStaticRandomData[1], b ^ current_state);
  160|   366k|  uint64_t cs1 = Mix(c ^ kStaticRandomData[2], d ^ current_state);
  161|   366k|  return cs0 ^ cs1;
  162|   366k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_118LowLevelHash33To64EmPKhm:
  164|   125k|uint64_t LowLevelHash33To64(uint64_t seed, const uint8_t* ptr, size_t len) {
  165|   125k|  assert(len > 32);
  166|       |  assert(len <= 64);
  167|   125k|  uint64_t current_state = seed ^ kStaticRandomData[0] ^ len;
  168|   125k|  const uint8_t* last_32_ptr = ptr + len - 32;
  169|   125k|  return Mix32Bytes(last_32_ptr, Mix32Bytes(ptr, current_state));
  170|   125k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_122SplitAndCombineOn64BitEmPKhm:
  268|  1.13k|SplitAndCombineOn64Bit(uint64_t state, const unsigned char* first, size_t len) {
  269|  44.7k|  while (len >= PiecewiseChunkSize()) {
  ------------------
  |  Branch (269:10): [True: 43.6k, False: 1.13k]
  ------------------
  270|  43.6k|    state = HashBlockOn64Bit(state, first, PiecewiseChunkSize());
  271|  43.6k|    len -= PiecewiseChunkSize();
  272|  43.6k|    first += PiecewiseChunkSize();
  273|  43.6k|  }
  274|       |  // Do not call CombineContiguousImpl for empty range since it is modifying
  275|       |  // state.
  276|  1.13k|  if (len == 0) {
  ------------------
  |  Branch (276:7): [True: 1, False: 1.13k]
  ------------------
  277|      1|    return state;
  278|      1|  }
  279|       |  // Handle the remainder.
  280|  1.13k|  return CombineContiguousImpl(state, first, len,
  281|  1.13k|                               std::integral_constant<int, 8>{});
  282|  1.13k|}

_ZN4absl12lts_2026010713hash_internal18PiecewiseChunkSizeEv:
  141|   323k|constexpr size_t PiecewiseChunkSize() { return 1024; }

_ZN4absl12lts_2026010711MinLogLevelEv:
   87|    661|absl::LogSeverityAtLeast MinLogLevel() {
   88|    661|  return static_cast<absl::LogSeverityAtLeast>(
   89|    661|      min_log_level.load(std::memory_order_acquire));
   90|    661|}
_ZN4absl12lts_2026010715StderrThresholdEv:
  109|    661|absl::LogSeverityAtLeast StderrThreshold() {
  110|    661|  return static_cast<absl::LogSeverityAtLeast>(
  111|    661|      stderrthreshold.load(std::memory_order_acquire));
  112|    661|}
_ZN4absl12lts_2026010722ShouldPrependLogPrefixEv:
  168|    661|bool ShouldPrependLogPrefix() {
  169|    661|  return prepend_log_prefix.load(std::memory_order_acquire);
  170|    661|}

_ZN4absl12lts_2026010712log_internal15AppendTruncatedENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEERNS0_4SpanIcEE:
   32|  4.61k|inline size_t AppendTruncated(absl::string_view src, absl::Span<char> &dst) {
   33|  4.61k|  if (src.size() > dst.size()) src = src.substr(0, dst.size());
  ------------------
  |  Branch (33:7): [True: 0, False: 4.61k]
  ------------------
   34|  4.61k|  memcpy(dst.data(), src.data(), src.size());
   35|  4.61k|  dst.remove_prefix(src.size());
   36|  4.61k|  return src.size();
   37|  4.61k|}

_ZN4absl12lts_2026010712log_internal13IsInitializedEv:
   54|  1.32k|bool IsInitialized() {
   55|  1.32k|  return logging_initialized.load(std::memory_order_acquire);
   56|  1.32k|}
_ZN4absl12lts_2026010712log_internal13WriteToStderrENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS0_11LogSeverityE:
   62|    662|void WriteToStderr(absl::string_view message, absl::LogSeverity severity) {
   63|    662|  if (message.empty()) return;
  ------------------
  |  Branch (63:7): [True: 0, False: 662]
  ------------------
   64|       |#if defined(__EMSCRIPTEN__)
   65|       |  // In WebAssembly, bypass filesystem emulation via fwrite.
   66|       |  // Skip a trailing newline character as emscripten_errn adds one itself.
   67|       |  const auto message_minus_newline = absl::StripSuffix(message, "\n");
   68|       |  // emscripten_errn was introduced in 3.1.41 but broken in standalone mode
   69|       |  // until 3.1.43.
   70|       |#if ABSL_INTERNAL_EMSCRIPTEN_VERSION >= 3001043
   71|       |  emscripten_errn(message_minus_newline.data(), message_minus_newline.size());
   72|       |#else
   73|       |  std::string null_terminated_message(message_minus_newline);
   74|       |  _emscripten_err(null_terminated_message.c_str());
   75|       |#endif
   76|       |#else
   77|       |  // Avoid using std::cerr from this module since we may get called during
   78|       |  // exit code, and cerr may be partially or fully destroyed by then.
   79|    662|  std::fwrite(message.data(), message.size(), 1, stderr);
   80|    662|#endif
   81|       |
   82|       |#if defined(_WIN64) || defined(_WIN32) || defined(_WIN16)
   83|       |  // C99 requires stderr to not be fully-buffered by default (7.19.3.7), but
   84|       |  // MS CRT buffers it anyway, so we must `fflush` to ensure the string hits
   85|       |  // the console/file before the program dies (and takes the libc buffers
   86|       |  // with it).
   87|       |  // https://docs.microsoft.com/en-us/cpp/c-runtime-library/stream-i-o
   88|       |  if (severity >= absl::LogSeverity::kWarning) {
   89|       |    std::fflush(stderr);
   90|       |  }
   91|       |#else
   92|       |  // Avoid unused parameter warning in this branch.
   93|    662|  (void)severity;
   94|    662|#endif
   95|    662|}
_ZN4absl12lts_2026010712log_internal8TimeZoneEv:
  109|    661|const absl::TimeZone* TimeZone() {
  110|    661|  return timezone_ptr.load(std::memory_order_acquire);
  111|    661|}

_ZN4absl12lts_2026010712log_internal15FormatLogPrefixENS0_11LogSeverityENS0_4TimeEiNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiNS1_12PrefixFormatERNS0_4SpanIcEE:
  194|    661|                       int line, PrefixFormat format, absl::Span<char>& buf) {
  195|    661|  auto prefix_size = FormatBoundedFields(severity, timestamp, tid, buf);
  196|    661|  prefix_size += log_internal::AppendTruncated(basename, buf);
  197|    661|  prefix_size += FormatLineNumber(line, buf);
  198|    661|  if (format == PrefixFormat::kRaw)
  ------------------
  |  Branch (198:7): [True: 0, False: 661]
  ------------------
  199|      0|    prefix_size += log_internal::AppendTruncated("RAW: ", buf);
  200|    661|  return prefix_size;
  201|    661|}
log_format.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_119FormatBoundedFieldsENS0_11LogSeverityENS0_4TimeEiRNS0_4SpanIcEE:
   78|    661|                           log_internal::Tid tid, absl::Span<char>& buf) {
   79|    661|  constexpr size_t kBoundedFieldsMaxLen =
   80|    661|      sizeof("SMMDD HH:MM:SS.NNNNNN  ") +
   81|    661|      (1 + std::numeric_limits<log_internal::Tid>::digits10 + 1) - sizeof("");
   82|    661|  if (ABSL_PREDICT_FALSE(buf.size() < kBoundedFieldsMaxLen)) {
  ------------------
  |  |  189|    661|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 661]
  |  |  |  Branch (189:49): [Folded, False: 661]
  |  |  |  Branch (189:58): [True: 0, False: 661]
  |  |  ------------------
  ------------------
   83|       |    // We don't bother trying to truncate these fields if the buffer is too
   84|       |    // short (or almost too short) because it would require doing a lot more
   85|       |    // length checking (slow) and it should never happen.  A 15kB buffer should
   86|       |    // be enough for anyone.  Instead we mark `buf` full without writing
   87|       |    // anything.
   88|      0|    buf.remove_suffix(buf.size());
   89|      0|    return 0;
   90|      0|  }
   91|       |
   92|       |  // We can't call absl::LocalTime(), localtime_r(), or anything else here that
   93|       |  // isn't async-signal-safe. We can only use the time zone if it has already
   94|       |  // been loaded.
   95|    661|  const absl::TimeZone* tz = absl::log_internal::TimeZone();
   96|    661|  if (ABSL_PREDICT_FALSE(tz == nullptr)) {
  ------------------
  |  |  189|    661|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 661, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 661]
  |  |  |  Branch (189:58): [True: 661, False: 0]
  |  |  ------------------
  ------------------
   97|       |    // If a time zone hasn't been set yet because we are logging before the
   98|       |    // logging library has been initialized, we fallback to a simpler, slower
   99|       |    // method. Just report the raw Unix time in seconds. We cram this into the
  100|       |    // normal time format for the benefit of parsers.
  101|    661|    auto tv = absl::ToTimeval(timestamp);
  102|    661|    int snprintf_result = absl::SNPrintF(
  103|    661|        buf.data(), buf.size(), "%c0000 00:00:%02d.%06d %7d ",
  104|    661|        absl::LogSeverityName(severity)[0], static_cast<int>(tv.tv_sec),
  105|    661|        static_cast<int>(tv.tv_usec), static_cast<int>(tid));
  106|    661|    if (snprintf_result >= 0) {
  ------------------
  |  Branch (106:9): [True: 661, False: 0]
  ------------------
  107|    661|      buf.remove_prefix(static_cast<size_t>(snprintf_result));
  108|    661|      return static_cast<size_t>(snprintf_result);
  109|    661|    }
  110|      0|    return 0;
  111|    661|  }
  112|       |
  113|      0|  char* p = buf.data();
  114|      0|  *p++ = absl::LogSeverityName(severity)[0];
  115|      0|  const absl::TimeZone::CivilInfo ci = tz->At(timestamp);
  116|      0|  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(ci.cs.month()), p);
  117|      0|  p += 2;
  118|      0|  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(ci.cs.day()), p);
  119|      0|  p += 2;
  120|      0|  *p++ = ' ';
  121|      0|  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(ci.cs.hour()), p);
  122|      0|  p += 2;
  123|      0|  *p++ = ':';
  124|      0|  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(ci.cs.minute()),
  125|      0|                                       p);
  126|      0|  p += 2;
  127|      0|  *p++ = ':';
  128|      0|  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(ci.cs.second()),
  129|      0|                                       p);
  130|      0|  p += 2;
  131|      0|  *p++ = '.';
  132|      0|  const int64_t usecs = absl::ToInt64Microseconds(ci.subsecond);
  133|      0|  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(usecs / 10000), p);
  134|      0|  p += 2;
  135|      0|  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(usecs / 100 % 100),
  136|      0|                                       p);
  137|      0|  p += 2;
  138|      0|  absl::numbers_internal::PutTwoDigits(static_cast<uint32_t>(usecs % 100), p);
  139|      0|  p += 2;
  140|      0|  *p++ = ' ';
  141|      0|  PutLeadingWhitespace(tid, p);
  142|      0|  p = absl::numbers_internal::FastIntToBuffer(tid, p);
  143|      0|  *p++ = ' ';
  144|      0|  const size_t bytes_formatted = static_cast<size_t>(p - buf.data());
  145|      0|  buf.remove_prefix(bytes_formatted);
  146|      0|  return bytes_formatted;
  147|    661|}
log_format.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_116FormatLineNumberEiRNS0_4SpanIcEE:
  149|    661|size_t FormatLineNumber(int line, absl::Span<char>& buf) {
  150|    661|  constexpr size_t kLineFieldMaxLen =
  151|    661|      sizeof(":] ") + (1 + std::numeric_limits<int>::digits10 + 1) - sizeof("");
  152|    661|  if (ABSL_PREDICT_FALSE(buf.size() < kLineFieldMaxLen)) {
  ------------------
  |  |  189|    661|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 661]
  |  |  |  Branch (189:49): [Folded, False: 661]
  |  |  |  Branch (189:58): [True: 0, False: 661]
  |  |  ------------------
  ------------------
  153|       |    // As above, we don't bother trying to truncate this if the buffer is too
  154|       |    // short and it should never happen.
  155|      0|    buf.remove_suffix(buf.size());
  156|      0|    return 0;
  157|      0|  }
  158|    661|  char* p = buf.data();
  159|    661|  *p++ = ':';
  160|    661|  p = absl::numbers_internal::FastIntToBuffer(line, p);
  161|    661|  *p++ = ']';
  162|    661|  *p++ = ' ';
  163|    661|  const size_t bytes_formatted = static_cast<size_t>(p - buf.data());
  164|    661|  buf.remove_prefix(bytes_formatted);
  165|    661|  return bytes_formatted;
  166|    661|}

_ZN4absl12lts_2026010712log_internal10LogMessage19CopyToEncodedBufferILNS2_10StringTypeE0EEEvNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  608|  2.15k|void LogMessage::CopyToEncodedBuffer(absl::string_view str) {
  609|  2.15k|  auto encoded_remaining_copy = data_->encoded_remaining();
  610|  2.15k|  constexpr uint8_t tag_value = str_type == StringType::kLiteral
  ------------------
  |  Branch (610:33): [True: 0, Folded]
  ------------------
  611|  2.15k|                                    ? ValueTag::kStringLiteral
  612|  2.15k|                                    : ValueTag::kString;
  613|  2.15k|  auto start = EncodeMessageStart(
  614|  2.15k|      EventTag::kValue,
  615|  2.15k|      BufferSizeFor(tag_value, WireType::kLengthDelimited) + str.size(),
  616|  2.15k|      &encoded_remaining_copy);
  617|       |  // If the `logging.proto.Event.value` field header did not fit,
  618|       |  // `EncodeMessageStart` will have zeroed `encoded_remaining_copy`'s size and
  619|       |  // `EncodeStringTruncate` will fail too.
  620|  2.15k|  if (EncodeStringTruncate(tag_value, str, &encoded_remaining_copy)) {
  ------------------
  |  Branch (620:7): [True: 2.15k, False: 0]
  ------------------
  621|       |    // The string may have been truncated, but the field header fit.
  622|  2.15k|    EncodeMessageLength(start, &encoded_remaining_copy);
  623|  2.15k|    data_->encoded_remaining() = encoded_remaining_copy;
  624|  2.15k|  } else {
  625|       |    // The field header(s) did not fit; zero `encoded_remaining()` so we don't
  626|       |    // write anything else later.
  627|      0|    data_->encoded_remaining().remove_suffix(data_->encoded_remaining().size());
  628|      0|  }
  629|  2.15k|}
_ZN4absl12lts_2026010712log_internal10LogMessage19CopyToEncodedBufferILNS2_10StringTypeE1EEEvNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  608|    368|void LogMessage::CopyToEncodedBuffer(absl::string_view str) {
  609|    368|  auto encoded_remaining_copy = data_->encoded_remaining();
  610|    368|  constexpr uint8_t tag_value = str_type == StringType::kLiteral
  ------------------
  |  Branch (610:33): [Folded, False: 368]
  ------------------
  611|    368|                                    ? ValueTag::kStringLiteral
  612|    368|                                    : ValueTag::kString;
  613|    368|  auto start = EncodeMessageStart(
  614|    368|      EventTag::kValue,
  615|    368|      BufferSizeFor(tag_value, WireType::kLengthDelimited) + str.size(),
  616|    368|      &encoded_remaining_copy);
  617|       |  // If the `logging.proto.Event.value` field header did not fit,
  618|       |  // `EncodeMessageStart` will have zeroed `encoded_remaining_copy`'s size and
  619|       |  // `EncodeStringTruncate` will fail too.
  620|    368|  if (EncodeStringTruncate(tag_value, str, &encoded_remaining_copy)) {
  ------------------
  |  Branch (620:7): [True: 368, False: 0]
  ------------------
  621|       |    // The string may have been truncated, but the field header fit.
  622|    368|    EncodeMessageLength(start, &encoded_remaining_copy);
  623|    368|    data_->encoded_remaining() = encoded_remaining_copy;
  624|    368|  } else {
  625|       |    // The field header(s) did not fit; zero `encoded_remaining()` so we don't
  626|       |    // write anything else later.
  627|      0|    data_->encoded_remaining().remove_suffix(data_->encoded_remaining().size());
  628|      0|  }
  629|    368|}
_ZN4absl12lts_2026010712log_internal10LogMessage14LogMessageDataC2ENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiNS0_11LogSeverityENS0_4TimeE:
  208|    661|    : extra_sinks_only(false), manipulated(nullptr) {
  209|       |  // Legacy defaults for LOG's ostream:
  210|    661|  manipulated.setf(std::ios_base::showbase | std::ios_base::boolalpha);
  211|    661|  entry.full_filename_ = file;
  212|    661|  entry.base_filename_ = Basename(file);
  213|    661|  entry.line_ = line;
  214|    661|  entry.prefix_ = absl::ShouldPrependLogPrefix();
  215|    661|  entry.severity_ = absl::NormalizeLogSeverity(severity);
  216|    661|  entry.verbose_level_ = absl::LogEntry::kNoVerbosityLevel;
  217|    661|  entry.timestamp_ = timestamp;
  218|    661|  entry.tid_ = absl::base_internal::GetCachedTID();
  219|    661|}
_ZN4absl12lts_2026010712log_internal10LogMessage14LogMessageData27InitializeEncodingAndFormatEv:
  221|    661|void LogMessage::LogMessageData::InitializeEncodingAndFormat() {
  222|    661|  EncodeStringTruncate(EventTag::kFileName, entry.source_filename(),
  223|    661|                       &encoded_remaining());
  224|    661|  EncodeVarint(EventTag::kFileLine, entry.source_line(), &encoded_remaining());
  225|    661|  EncodeVarint(EventTag::kTimeNsecs, absl::ToUnixNanos(entry.timestamp()),
  226|    661|               &encoded_remaining());
  227|    661|  EncodeVarint(EventTag::kSeverity,
  228|    661|               ProtoSeverity(entry.log_severity(), entry.verbosity()),
  229|    661|               &encoded_remaining());
  230|    661|  EncodeVarint(EventTag::kThreadId, entry.tid(), &encoded_remaining());
  231|    661|}
_ZN4absl12lts_2026010712log_internal10LogMessage14LogMessageData25FinalizeEncodingAndFormatEv:
  233|    661|void LogMessage::LogMessageData::FinalizeEncodingAndFormat() {
  234|       |  // Note that `encoded_remaining()` may have zero size without pointing past
  235|       |  // the end of `encoded_buf`, so the difference between `data()` pointers is
  236|       |  // used to compute the size of `encoded_data`.
  237|    661|  absl::Span<const char> encoded_data(
  238|    661|      encoded_buf.data(),
  239|    661|      static_cast<size_t>(encoded_remaining().data() - encoded_buf.data()));
  240|       |  // `string_remaining` is the suffix of `string_buf` that has not been filled
  241|       |  // yet.
  242|    661|  absl::Span<char> string_remaining(string_buf);
  243|       |  // We may need to write a newline and nul-terminator at the end of the decoded
  244|       |  // string data.  Rather than worry about whether those should overwrite the
  245|       |  // end of the string (if the buffer is full) or be appended, we avoid writing
  246|       |  // into the last two bytes so we always have space to append.
  247|    661|  string_remaining.remove_suffix(2);
  248|    661|  entry.prefix_len_ =
  249|    661|      entry.prefix() ? log_internal::FormatLogPrefix(
  ------------------
  |  Branch (249:7): [True: 661, False: 0]
  ------------------
  250|    661|                           entry.log_severity(), entry.timestamp(), entry.tid(),
  251|    661|                           entry.source_basename(), entry.source_line(),
  252|    661|                           log_internal::ThreadIsLoggingToLogSink()
  ------------------
  |  Branch (252:28): [True: 0, False: 661]
  ------------------
  253|    661|                               ? PrefixFormat::kRaw
  254|    661|                               : PrefixFormat::kNotRaw,
  255|    661|                           string_remaining)
  256|    661|                     : 0;
  257|       |  // Decode data from `encoded_buf` until we run out of data or we run out of
  258|       |  // `string_remaining`.
  259|    661|  ProtoField field;
  260|  7.92k|  while (field.DecodeFrom(&encoded_data)) {
  ------------------
  |  Branch (260:10): [True: 7.26k, False: 661]
  ------------------
  261|  7.26k|    switch (field.tag()) {
  ------------------
  |  Branch (261:13): [True: 3.95k, False: 3.30k]
  ------------------
  262|  3.95k|      case EventTag::kValue:
  ------------------
  |  Branch (262:7): [True: 3.95k, False: 3.30k]
  ------------------
  263|  3.95k|        if (field.type() != WireType::kLengthDelimited) continue;
  ------------------
  |  Branch (263:13): [True: 0, False: 3.95k]
  ------------------
  264|  3.95k|        if (PrintValue(string_remaining, field.bytes_value())) continue;
  ------------------
  |  Branch (264:13): [True: 3.95k, False: 0]
  ------------------
  265|      0|        break;
  266|  7.26k|    }
  267|  7.26k|  }
  268|    661|  auto chars_written =
  269|    661|      static_cast<size_t>(string_remaining.data() - string_buf.data());
  270|    661|    string_buf[chars_written++] = '\n';
  271|    661|  string_buf[chars_written++] = '\0';
  272|    661|  entry.text_message_with_prefix_and_newline_and_nul_ =
  273|    661|      absl::MakeSpan(string_buf).subspan(0, chars_written);
  274|    661|}
_ZN4absl12lts_2026010712log_internal10LogMessageC2EPKciNS0_11LogSeverityE:
  278|    661|  : LogMessage(absl::string_view(file), line, severity) {}
_ZN4absl12lts_2026010712log_internal10LogMessageC2ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiNS0_11LogSeverityE:
  281|    661|    : data_(absl::make_unique<LogMessageData>(file, line, severity,
  282|    661|                                              absl::Now())) {
  283|    661|  data_->first_fatal = false;
  284|    661|  data_->is_perror = false;
  285|    661|  data_->fail_quietly = false;
  286|       |
  287|       |  // This logs a backtrace even if the location is subsequently changed using
  288|       |  // AtLocation.  This quirk, and the behavior when AtLocation is called twice,
  289|       |  // are fixable but probably not worth fixing.
  290|    661|  LogBacktraceIfNeeded();
  291|    661|}
_ZN4absl12lts_2026010712log_internal10LogMessageC2EPKciNS2_7InfoTagE:
  294|    176|    : LogMessage(file, line, absl::LogSeverity::kInfo) {}
_ZN4absl12lts_2026010712log_internal10LogMessageC2EPKciNS2_10WarningTagE:
  296|    485|    : LogMessage(file, line, absl::LogSeverity::kWarning) {}
_ZN4absl12lts_2026010712log_internal10LogMessageD2Ev:
  301|    661|LogMessage::~LogMessage() = default;
_ZN4absl12lts_2026010712log_internal10LogMessagelsERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  403|    128|LogMessage& LogMessage::operator<<(const std::string& v) {
  404|    128|  CopyToEncodedBuffer<StringType::kNotLiteral>(v);
  405|    128|  return *this;
  406|    128|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  408|    240|LogMessage& LogMessage::operator<<(absl::string_view v) {
  409|    240|  CopyToEncodedBuffer<StringType::kNotLiteral>(v);
  410|    240|  return *this;
  411|    240|}
_ZN4absl12lts_2026010712log_internal10LogMessage5FlushEv:
  471|    661|void LogMessage::Flush() {
  472|    661|  if (data_->entry.log_severity() < absl::MinLogLevel()) return;
  ------------------
  |  Branch (472:7): [True: 0, False: 661]
  ------------------
  473|       |
  474|    661|  if (data_->is_perror) {
  ------------------
  |  Branch (474:7): [True: 0, False: 661]
  ------------------
  475|      0|    InternalStream() << ": " << absl::base_internal::StrError(errno_saver_())
  476|      0|                     << " [" << errno_saver_() << "]";
  477|      0|  }
  478|       |
  479|       |  // Have we already seen a fatal message?
  480|    661|  ABSL_CONST_INIT static std::atomic<bool> seen_fatal(false);
  ------------------
  |  |  760|    661|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
  481|    661|  if (data_->entry.log_severity() == absl::LogSeverity::kFatal &&
  ------------------
  |  Branch (481:7): [True: 0, False: 661]
  ------------------
  482|      0|      absl::log_internal::ExitOnDFatal()) {
  ------------------
  |  Branch (482:7): [True: 0, False: 0]
  ------------------
  483|       |    // Exactly one LOG(FATAL) message is responsible for aborting the process,
  484|       |    // even if multiple threads LOG(FATAL) concurrently.
  485|      0|    bool expected_seen_fatal = false;
  486|      0|    if (seen_fatal.compare_exchange_strong(expected_seen_fatal, true,
  ------------------
  |  Branch (486:9): [True: 0, False: 0]
  ------------------
  487|      0|                                           std::memory_order_relaxed)) {
  488|      0|      data_->first_fatal = true;
  489|      0|    }
  490|      0|  }
  491|       |
  492|    661|  data_->FinalizeEncodingAndFormat();
  493|    661|  data_->entry.encoding_ =
  494|    661|      absl::string_view(data_->encoded_buf.data(),
  495|    661|                        static_cast<size_t>(data_->encoded_remaining().data() -
  496|    661|                                            data_->encoded_buf.data()));
  497|    661|  SendToLog();
  498|    661|}
_ZN4absl12lts_2026010712log_internal10LogMessage11OstreamViewC2ERNS2_14LogMessageDataE:
  503|  1.43k|    : data_(message_data), encoded_remaining_copy_(data_.encoded_remaining()) {
  504|       |  // This constructor sets the `streambuf` up so that streaming into an attached
  505|       |  // ostream encodes string data in-place.  To do that, we write appropriate
  506|       |  // headers into the buffer using a copy of the buffer view so that we can
  507|       |  // decide not to keep them later if nothing is ever streamed in.  We don't
  508|       |  // know how much data we'll get, but we can use the size of the remaining
  509|       |  // buffer as an upper bound and fill in the right size once we know it.
  510|  1.43k|  message_start_ =
  511|  1.43k|      EncodeMessageStart(EventTag::kValue, encoded_remaining_copy_.size(),
  512|  1.43k|                         &encoded_remaining_copy_);
  513|  1.43k|  string_start_ =
  514|  1.43k|      EncodeMessageStart(ValueTag::kString, encoded_remaining_copy_.size(),
  515|  1.43k|                         &encoded_remaining_copy_);
  516|  1.43k|  setp(encoded_remaining_copy_.data(),
  517|  1.43k|       encoded_remaining_copy_.data() + encoded_remaining_copy_.size());
  518|  1.43k|  data_.manipulated.rdbuf(this);
  519|  1.43k|}
_ZN4absl12lts_2026010712log_internal10LogMessage11OstreamViewD2Ev:
  521|  1.43k|LogMessage::OstreamView::~OstreamView() {
  522|  1.43k|  data_.manipulated.rdbuf(nullptr);
  523|  1.43k|  if (!string_start_.data()) {
  ------------------
  |  Branch (523:7): [True: 0, False: 1.43k]
  ------------------
  524|       |    // The second field header didn't fit.  Whether the first one did or not, we
  525|       |    // shouldn't commit `encoded_remaining_copy_`, and we also need to zero the
  526|       |    // size of `data_->encoded_remaining()` so that no more data are encoded.
  527|      0|    data_.encoded_remaining().remove_suffix(data_.encoded_remaining().size());
  528|      0|    return;
  529|      0|  }
  530|  1.43k|  const absl::Span<const char> contents(pbase(),
  531|  1.43k|                                        static_cast<size_t>(pptr() - pbase()));
  532|  1.43k|  if (contents.empty()) return;
  ------------------
  |  Branch (532:7): [True: 0, False: 1.43k]
  ------------------
  533|  1.43k|  encoded_remaining_copy_.remove_prefix(contents.size());
  534|  1.43k|  EncodeMessageLength(string_start_, &encoded_remaining_copy_);
  535|  1.43k|  EncodeMessageLength(message_start_, &encoded_remaining_copy_);
  536|  1.43k|  data_.encoded_remaining() = encoded_remaining_copy_;
  537|  1.43k|}
_ZN4absl12lts_2026010712log_internal10LogMessage11OstreamView6streamEv:
  539|  1.43k|std::ostream& LogMessage::OstreamView::stream() { return data_.manipulated; }
_ZNK4absl12lts_2026010712log_internal10LogMessage7IsFatalEv:
  541|  1.32k|bool LogMessage::IsFatal() const {
  542|  1.32k|  return data_->entry.log_severity() == absl::LogSeverity::kFatal &&
  ------------------
  |  Branch (542:10): [True: 0, False: 1.32k]
  ------------------
  543|      0|         absl::log_internal::ExitOnDFatal();
  ------------------
  |  Branch (543:10): [True: 0, False: 0]
  ------------------
  544|  1.32k|}
_ZN4absl12lts_2026010712log_internal10LogMessage9SendToLogEv:
  580|    661|void LogMessage::SendToLog() {
  581|    661|  if (IsFatal()) PrepareToDie();
  ------------------
  |  Branch (581:7): [True: 0, False: 661]
  ------------------
  582|       |  // Also log to all registered sinks, even if OnlyLogToStderr() is set.
  583|    661|  log_internal::LogToSinks(data_->entry, absl::MakeSpan(data_->extra_sinks),
  584|    661|                           data_->extra_sinks_only);
  585|    661|  if (IsFatal()) Die();
  ------------------
  |  Branch (585:7): [True: 0, False: 661]
  ------------------
  586|    661|}
_ZN4absl12lts_2026010712log_internal10LogMessage20LogBacktraceIfNeededEv:
  588|    661|void LogMessage::LogBacktraceIfNeeded() {
  589|    661|  if (!absl::log_internal::IsInitialized()) return;
  ------------------
  |  Branch (589:7): [True: 661, False: 0]
  ------------------
  590|       |
  591|      0|  if (!absl::log_internal::ShouldLogBacktraceAt(data_->entry.source_basename(),
  ------------------
  |  Branch (591:7): [True: 0, False: 0]
  ------------------
  592|      0|                                                data_->entry.source_line()))
  593|      0|    return;
  594|      0|  OstreamView view(*data_);
  595|      0|  view.stream() << " (stacktrace:\n";
  596|      0|  debugging_internal::DumpStackTrace(
  597|      0|      1, log_internal::MaxFramesInLogStackTrace(),
  598|      0|      log_internal::ShouldSymbolizeLogStackTrace(), WriteToStream,
  599|      0|      &view.stream());
  600|      0|  view.stream() << ") ";
  601|      0|}
_ZN4absl12lts_2026010712log_internal10LogMessage14LogMessageData17encoded_remainingEv:
  188|  12.5k|  absl::Span<char>& encoded_remaining() {
  189|  12.5k|    if (encoded_remaining_actual_do_not_use_directly.data() == nullptr) {
  ------------------
  |  Branch (189:9): [True: 661, False: 11.8k]
  ------------------
  190|    661|      encoded_remaining_actual_do_not_use_directly =
  191|    661|          absl::MakeSpan(encoded_buf);
  192|    661|      InitializeEncodingAndFormat();
  193|    661|    }
  194|  12.5k|    return encoded_remaining_actual_do_not_use_directly;
  195|  12.5k|  }
log_message.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_18BasenameENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  133|    661|absl::string_view Basename(absl::string_view filepath) {
  134|       |#ifdef _WIN32
  135|       |  size_t path = filepath.find_last_of("/\\");
  136|       |#else
  137|    661|  size_t path = filepath.find_last_of('/');
  138|    661|#endif
  139|    661|  if (path != filepath.npos) filepath.remove_prefix(path + 1);
  ------------------
  |  Branch (139:7): [True: 661, False: 0]
  ------------------
  140|    661|  return filepath;
  141|    661|}
log_message.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_113ProtoSeverityENS0_11LogSeverityEi:
  117|    661|int32_t ProtoSeverity(absl::LogSeverity severity, int verbose_level) {
  118|    661|  switch (severity) {
  119|    176|    case absl::LogSeverity::kInfo:
  ------------------
  |  Branch (119:5): [True: 176, False: 485]
  ------------------
  120|    176|      if (verbose_level == absl::LogEntry::kNoVerbosityLevel) return 800;
  ------------------
  |  Branch (120:11): [True: 176, False: 0]
  ------------------
  121|      0|      return 600 - verbose_level;
  122|    485|    case absl::LogSeverity::kWarning:
  ------------------
  |  Branch (122:5): [True: 485, False: 176]
  ------------------
  123|    485|      return 900;
  124|      0|    case absl::LogSeverity::kError:
  ------------------
  |  Branch (124:5): [True: 0, False: 661]
  ------------------
  125|      0|      return 950;
  126|      0|    case absl::LogSeverity::kFatal:
  ------------------
  |  Branch (126:5): [True: 0, False: 661]
  ------------------
  127|      0|      return 1100;
  128|      0|    default:
  ------------------
  |  Branch (128:5): [True: 0, False: 661]
  ------------------
  129|      0|      return 800;
  130|    661|  }
  131|    661|}
log_message.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_110PrintValueERNS0_4SpanIcEENS3_IKcEE:
  100|  3.95k|bool PrintValue(absl::Span<char>& dst, absl::Span<const char> buf) {
  101|  3.95k|  if (dst.size() <= 1) return false;
  ------------------
  |  Branch (101:7): [True: 0, False: 3.95k]
  ------------------
  102|  3.95k|  ProtoField field;
  103|  7.91k|  while (field.DecodeFrom(&buf)) {
  ------------------
  |  Branch (103:10): [True: 3.95k, False: 3.95k]
  ------------------
  104|  3.95k|    switch (field.tag()) {
  ------------------
  |  Branch (104:13): [True: 3.95k, False: 0]
  ------------------
  105|  1.79k|      case ValueTag::kString:
  ------------------
  |  Branch (105:7): [True: 1.79k, False: 2.15k]
  ------------------
  106|  3.95k|      case ValueTag::kStringLiteral:
  ------------------
  |  Branch (106:7): [True: 2.15k, False: 1.79k]
  ------------------
  107|  3.95k|        if (field.type() == WireType::kLengthDelimited)
  ------------------
  |  Branch (107:13): [True: 3.95k, False: 0]
  ------------------
  108|  3.95k|          if (log_internal::AppendTruncated(field.string_value(), dst) <
  ------------------
  |  Branch (108:15): [True: 0, False: 3.95k]
  ------------------
  109|  3.95k|              field.string_value().size())
  110|      0|            return false;
  111|  3.95k|    }
  112|  3.95k|  }
  113|  3.95k|  return true;
  114|  3.95k|}

_ZN4absl12lts_2026010712log_internal10LogMessagelsIiEERS2_RKT_:
  337|    413|LogMessage& LogMessage::operator<<(const T& v) {
  338|       |  if constexpr (absl::HasAbslStringify<T>::value) {
  339|       |    StringifySink sink(*this);
  340|       |    // Replace with public API.
  341|       |    AbslStringify(sink, v);
  342|    413|  } else {
  343|    413|    OstreamView view(*data_);
  344|    413|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  345|    413|  }
  346|    413|  return *this;
  347|    413|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsImEERS2_RKT_:
  337|    778|LogMessage& LogMessage::operator<<(const T& v) {
  338|       |  if constexpr (absl::HasAbslStringify<T>::value) {
  339|       |    StringifySink sink(*this);
  340|       |    // Replace with public API.
  341|       |    AbslStringify(sink, v);
  342|    778|  } else {
  343|    778|    OstreamView view(*data_);
  344|    778|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  345|    778|  }
  346|    778|  return *this;
  347|    778|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsIfEERS2_RKT_:
  337|    240|LogMessage& LogMessage::operator<<(const T& v) {
  338|       |  if constexpr (absl::HasAbslStringify<T>::value) {
  339|       |    StringifySink sink(*this);
  340|       |    // Replace with public API.
  341|       |    AbslStringify(sink, v);
  342|    240|  } else {
  343|    240|    OstreamView view(*data_);
  344|    240|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  345|    240|  }
  346|    240|  return *this;
  347|    240|}

_ZN4absl12lts_2026010712log_internal24ThreadIsLoggingToLogSinkEv:
  277|  1.32k|bool ThreadIsLoggingToLogSink() { return ThreadIsLoggingStatus(); }
_ZN4absl12lts_2026010712log_internal10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEb:
  280|    661|                absl::Span<absl::LogSink*> extra_sinks, bool extra_sinks_only) {
  281|    661|  log_internal::GlobalSinks().LogToSinks(entry, extra_sinks, extra_sinks_only);
  282|    661|}
log_sink_set.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_121ThreadIsLoggingStatusEv:
   58|  2.64k|bool& ThreadIsLoggingStatus() {
   59|  2.64k|#ifdef ABSL_HAVE_THREAD_LOCAL
   60|  2.64k|  ABSL_CONST_INIT thread_local bool thread_is_logging = false;
  ------------------
  |  |  760|  2.64k|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
   61|  2.64k|  return thread_is_logging;
   62|       |#else
   63|       |  ABSL_CONST_INIT static pthread_key_t thread_is_logging_key;
   64|       |  static const bool unused = [] {
   65|       |    if (pthread_key_create(&thread_is_logging_key, [](void* data) {
   66|       |          delete reinterpret_cast<bool*>(data);
   67|       |        })) {
   68|       |      perror("pthread_key_create failed!");
   69|       |      abort();
   70|       |    }
   71|       |    return true;
   72|       |  }();
   73|       |  (void)unused;  // Fixes -wunused-variable warning
   74|       |  bool* thread_is_logging_ptr =
   75|       |      reinterpret_cast<bool*>(pthread_getspecific(thread_is_logging_key));
   76|       |
   77|       |  if (ABSL_PREDICT_FALSE(!thread_is_logging_ptr)) {
   78|       |    thread_is_logging_ptr = new bool{false};
   79|       |    if (pthread_setspecific(thread_is_logging_key, thread_is_logging_ptr)) {
   80|       |      perror("pthread_setspecific failed");
   81|       |      abort();
   82|       |    }
   83|       |  }
   84|       |  return *thread_is_logging_ptr;
   85|       |#endif
   86|  2.64k|}
log_sink_set.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_111GlobalSinksEv:
  270|    661|GlobalLogSinkSet& GlobalSinks() {
  271|    661|  static absl::NoDestructor<GlobalLogSinkSet> global_sinks;
  272|    661|  return *global_sinks;
  273|    661|}
log_sink_set.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_116GlobalLogSinkSetC2Ev:
  168|      1|  GlobalLogSinkSet() {
  169|       |#if defined(__myriad2__) || defined(__Fuchsia__)
  170|       |    // myriad2 and Fuchsia do not log to stderr by default.
  171|       |#else
  172|      1|    static absl::NoDestructor<StderrLogSink> stderr_log_sink;
  173|      1|    AddLogSink(stderr_log_sink.get());
  174|      1|#endif
  175|       |#ifdef __ANDROID__
  176|       |    static absl::NoDestructor<AndroidLogSink> android_log_sink;
  177|       |    AddLogSink(android_log_sink.get());
  178|       |#endif
  179|       |#if defined(_WIN32)
  180|       |    static absl::NoDestructor<WindowsDebuggerLogSink> debugger_log_sink;
  181|       |    AddLogSink(debugger_log_sink.get());
  182|       |#endif  // !defined(_WIN32)
  183|      1|  }
log_sink_set.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_113StderrLogSink4SendERKNS0_8LogEntryE:
   92|    661|  void Send(const absl::LogEntry& entry) override {
   93|    661|    if (entry.log_severity() < absl::StderrThreshold() &&
  ------------------
  |  Branch (93:9): [True: 661, False: 0]
  ------------------
   94|    661|        absl::log_internal::IsInitialized()) {
  ------------------
  |  Branch (94:9): [True: 0, False: 661]
  ------------------
   95|      0|      return;
   96|      0|    }
   97|       |
   98|    661|    ABSL_CONST_INIT static absl::once_flag warn_if_not_initialized;
  ------------------
  |  |  760|    661|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
   99|    661|    absl::call_once(warn_if_not_initialized, []() {
  100|    661|      if (absl::log_internal::IsInitialized()) return;
  101|    661|      const char w[] =
  102|    661|          "WARNING: All log messages before absl::InitializeLog() is called"
  103|    661|          " are written to STDERR\n";
  104|    661|      absl::log_internal::WriteToStderr(w, absl::LogSeverity::kWarning);
  105|    661|    });
  106|       |
  107|    661|    if (!entry.stacktrace().empty()) {
  ------------------
  |  Branch (107:9): [True: 0, False: 661]
  ------------------
  108|      0|      absl::log_internal::WriteToStderr(entry.stacktrace(),
  109|      0|                                        entry.log_severity());
  110|    661|    } else {
  111|       |      // TODO(b/226937039): do this outside else condition once we avoid
  112|       |      // ReprintFatalMessage
  113|    661|      absl::log_internal::WriteToStderr(
  114|    661|          entry.text_message_with_prefix_and_newline(), entry.log_severity());
  115|    661|    }
  116|    661|  }
log_sink_set.cc:_ZZN4absl12lts_2026010712log_internal12_GLOBAL__N_113StderrLogSink4SendERKNS0_8LogEntryEENKUlvE_clEv:
   99|      1|    absl::call_once(warn_if_not_initialized, []() {
  100|      1|      if (absl::log_internal::IsInitialized()) return;
  ------------------
  |  Branch (100:11): [True: 0, False: 1]
  ------------------
  101|      1|      const char w[] =
  102|      1|          "WARNING: All log messages before absl::InitializeLog() is called"
  103|      1|          " are written to STDERR\n";
  104|      1|      absl::log_internal::WriteToStderr(w, absl::LogSeverity::kWarning);
  105|      1|    });
log_sink_set.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEb:
  187|    661|      ABSL_LOCKS_EXCLUDED(guard_) {
  188|    661|    SendToSinks(entry, extra_sinks);
  189|       |
  190|    661|    if (!extra_sinks_only) {
  ------------------
  |  Branch (190:9): [True: 661, False: 0]
  ------------------
  191|    661|      if (ThreadIsLoggingToLogSink()) {
  ------------------
  |  Branch (191:11): [True: 0, False: 661]
  ------------------
  192|      0|        absl::log_internal::WriteToStderr(
  193|      0|            entry.text_message_with_prefix_and_newline(), entry.log_severity());
  194|    661|      } else {
  195|    661|        absl::ReaderMutexLock global_sinks_lock(guard_);
  196|    661|        ThreadIsLoggingStatus() = true;
  197|       |        // Ensure the "thread is logging" status is reverted upon leaving the
  198|       |        // scope even in case of exceptions.
  199|    661|        auto status_cleanup =
  200|    661|            absl::MakeCleanup([] { ThreadIsLoggingStatus() = false; });
  201|    661|        SendToSinks(entry, absl::MakeSpan(sinks_));
  202|    661|      }
  203|    661|    }
  204|    661|  }
log_sink_set.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_116GlobalLogSinkSet11SendToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEE:
  258|  1.32k|                          absl::Span<absl::LogSink*> sinks) {
  259|  1.32k|    for (absl::LogSink* sink : sinks) {
  ------------------
  |  Branch (259:30): [True: 661, False: 1.32k]
  ------------------
  260|    661|      sink->Send(entry);
  261|    661|    }
  262|  1.32k|  }
log_sink_set.cc:_ZZN4absl12lts_2026010712log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbENKUlvE_clEv:
  200|    661|            absl::MakeCleanup([] { ThreadIsLoggingStatus() = false; });
log_sink_set.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_116GlobalLogSinkSet10AddLogSinkEPNS0_7LogSinkE:
  206|      1|  void AddLogSink(absl::LogSink* sink) ABSL_LOCKS_EXCLUDED(guard_) {
  207|      1|    {
  208|      1|      absl::WriterMutexLock global_sinks_lock(guard_);
  209|      1|      auto pos = std::find(sinks_.begin(), sinks_.end(), sink);
  210|      1|      if (pos == sinks_.end()) {
  ------------------
  |  Branch (210:11): [True: 1, False: 0]
  ------------------
  211|      1|        sinks_.push_back(sink);
  212|      1|        return;
  213|      1|      }
  214|      1|    }
  215|      0|    ABSL_INTERNAL_LOG(FATAL, "Duplicate log sinks are not supported");
  ------------------
  |  |   76|      0|  do {                                                                    \
  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   80|      0|        __LINE__, message);                                               \
  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  216|      0|  }

_ZN4absl12lts_2026010712log_internal9NullGuardImE5GuardERKm:
   45|    778|  static const T& Guard(const T& v) { return v; }
_ZN4absl12lts_2026010712log_internal9NullGuardIfE5GuardERKf:
   45|    240|  static const T& Guard(const T& v) { return v; }
_ZN4absl12lts_2026010712log_internal9NullGuardIiE5GuardERKi:
   45|    413|  static const T& Guard(const T& v) { return v; }

_ZN4absl12lts_2026010712log_internal12EncodeVarintEmmPNS0_4SpanIcEE:
   40|  2.64k|bool EncodeVarint(uint64_t tag, uint64_t value, absl::Span<char> *buf) {
   41|  2.64k|  const uint64_t tag_type = MakeTagType(tag, WireType::kVarint);
   42|  2.64k|  const size_t tag_type_size = VarintSize(tag_type);
   43|  2.64k|  const size_t value_size = VarintSize(value);
   44|  2.64k|  if (tag_type_size + value_size > buf->size()) {
  ------------------
  |  Branch (44:7): [True: 0, False: 2.64k]
  ------------------
   45|      0|    buf->remove_suffix(buf->size());
   46|      0|    return false;
   47|      0|  }
   48|  2.64k|  EncodeRawVarint(tag_type, tag_type_size, buf);
   49|  2.64k|  EncodeRawVarint(value, value_size, buf);
   50|  2.64k|  return true;
   51|  2.64k|}
_ZN4absl12lts_2026010712log_internal19EncodeBytesTruncateEmNS0_4SpanIKcEEPNS2_IcEE:
  103|  3.18k|                         absl::Span<char> *buf) {
  104|  3.18k|  const uint64_t tag_type = MakeTagType(tag, WireType::kLengthDelimited);
  105|  3.18k|  const size_t tag_type_size = VarintSize(tag_type);
  106|  3.18k|  uint64_t length = value.size();
  107|  3.18k|  const size_t length_size =
  108|  3.18k|      VarintSize(std::min<uint64_t>(length, buf->size()));
  109|  3.18k|  if (tag_type_size + length_size <= buf->size() &&
  ------------------
  |  Branch (109:7): [True: 3.18k, False: 0]
  ------------------
  110|  3.18k|      tag_type_size + length_size + value.size() > buf->size()) {
  ------------------
  |  Branch (110:7): [True: 0, False: 3.18k]
  ------------------
  111|      0|    value.remove_suffix(tag_type_size + length_size + value.size() -
  112|      0|                        buf->size());
  113|      0|    length = value.size();
  114|      0|  }
  115|  3.18k|  if (tag_type_size + length_size + value.size() > buf->size()) {
  ------------------
  |  Branch (115:7): [True: 0, False: 3.18k]
  ------------------
  116|      0|    buf->remove_suffix(buf->size());
  117|      0|    return false;
  118|      0|  }
  119|  3.18k|  EncodeRawVarint(tag_type, tag_type_size, buf);
  120|  3.18k|  EncodeRawVarint(length, length_size, buf);
  121|  3.18k|  memcpy(buf->data(), value.data(), value.size());
  122|  3.18k|  buf->remove_prefix(value.size());
  123|  3.18k|  return true;
  124|  3.18k|}
_ZN4absl12lts_2026010712log_internal18EncodeMessageStartEmmPNS0_4SpanIcEE:
  128|  5.38k|                                                  absl::Span<char> *buf) {
  129|  5.38k|  const uint64_t tag_type = MakeTagType(tag, WireType::kLengthDelimited);
  130|  5.38k|  const size_t tag_type_size = VarintSize(tag_type);
  131|  5.38k|  max_size = std::min<uint64_t>(max_size, buf->size());
  132|  5.38k|  const size_t length_size = VarintSize(max_size);
  133|  5.38k|  if (tag_type_size + length_size > buf->size()) {
  ------------------
  |  Branch (133:7): [True: 0, False: 5.38k]
  ------------------
  134|      0|    buf->remove_suffix(buf->size());
  135|      0|    return absl::Span<char>();
  136|      0|  }
  137|  5.38k|  EncodeRawVarint(tag_type, tag_type_size, buf);
  138|  5.38k|  const absl::Span<char> ret = buf->subspan(0, length_size);
  139|  5.38k|  EncodeRawVarint(0, length_size, buf);
  140|  5.38k|  return ret;
  141|  5.38k|}
_ZN4absl12lts_2026010712log_internal19EncodeMessageLengthENS0_4SpanIcEEPKS3_:
  143|  5.38k|void EncodeMessageLength(absl::Span<char> msg, const absl::Span<char> *buf) {
  144|  5.38k|  if (!msg.data()) return;
  ------------------
  |  Branch (144:7): [True: 0, False: 5.38k]
  ------------------
  145|  5.38k|  assert(buf->data() >= msg.data());
  146|  5.38k|  if (buf->data() < msg.data()) return;
  ------------------
  |  Branch (146:7): [True: 0, False: 5.38k]
  ------------------
  147|  5.38k|  EncodeRawVarint(
  148|  5.38k|      static_cast<uint64_t>(buf->data() - (msg.data() + msg.size())),
  149|  5.38k|      msg.size(), &msg);
  150|  5.38k|}
_ZN4absl12lts_2026010712log_internal10ProtoField10DecodeFromEPNS0_4SpanIKcEE:
  190|  15.8k|bool ProtoField::DecodeFrom(absl::Span<const char> *data) {
  191|  15.8k|  if (data->empty()) return false;
  ------------------
  |  Branch (191:7): [True: 4.61k, False: 11.2k]
  ------------------
  192|  11.2k|  const uint64_t tag_type = DecodeVarint(data);
  193|  11.2k|  tag_ = tag_type >> 3;
  194|  11.2k|  type_ = static_cast<WireType>(tag_type & 0x07);
  195|  11.2k|  switch (type_) {
  ------------------
  |  Branch (195:11): [True: 11.2k, False: 0]
  ------------------
  196|  2.64k|    case WireType::kVarint:
  ------------------
  |  Branch (196:5): [True: 2.64k, False: 8.57k]
  ------------------
  197|  2.64k|      value_ = DecodeVarint(data);
  198|  2.64k|      break;
  199|      0|    case WireType::k64Bit:
  ------------------
  |  Branch (199:5): [True: 0, False: 11.2k]
  ------------------
  200|      0|      value_ = Decode64Bit(data);
  201|      0|      break;
  202|  8.57k|    case WireType::kLengthDelimited: {
  ------------------
  |  Branch (202:5): [True: 8.57k, False: 2.64k]
  ------------------
  203|  8.57k|      value_ = DecodeVarint(data);
  204|  8.57k|      data_ = data->subspan(
  205|  8.57k|          0, static_cast<size_t>(std::min<uint64_t>(value_, data->size())));
  206|  8.57k|      data->remove_prefix(data_.size());
  207|  8.57k|      break;
  208|      0|    }
  209|      0|    case WireType::k32Bit:
  ------------------
  |  Branch (209:5): [True: 0, False: 11.2k]
  ------------------
  210|      0|      value_ = Decode32Bit(data);
  211|      0|      break;
  212|  11.2k|  }
  213|  11.2k|  return true;
  214|  11.2k|}
proto.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_115EncodeRawVarintEmmPNS0_4SpanIcEE:
   31|  27.8k|void EncodeRawVarint(uint64_t value, size_t size, absl::Span<char> *buf) {
   32|  67.9k|  for (size_t s = 0; s < size; s++) {
  ------------------
  |  Branch (32:22): [True: 40.1k, False: 27.8k]
  ------------------
   33|  40.1k|    (*buf)[s] = static_cast<char>((value & 0x7f) | (s + 1 == size ? 0 : 0x80));
  ------------------
  |  Branch (33:53): [True: 27.8k, False: 12.3k]
  ------------------
   34|  40.1k|    value >>= 7;
   35|  40.1k|  }
   36|  27.8k|  buf->remove_prefix(size);
   37|  27.8k|}
proto.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_112DecodeVarintEPNS0_4SpanIKcEE:
  153|  22.4k|uint64_t DecodeVarint(absl::Span<const char> *buf) {
  154|  22.4k|  uint64_t value = 0;
  155|  22.4k|  size_t s = 0;
  156|  31.9k|  while (s < buf->size()) {
  ------------------
  |  Branch (156:10): [True: 31.9k, False: 0]
  ------------------
  157|  31.9k|    value |= static_cast<uint64_t>(static_cast<unsigned char>((*buf)[s]) & 0x7f)
  158|  31.9k|             << 7 * s;
  159|  31.9k|    if (!((*buf)[s++] & 0x80)) break;
  ------------------
  |  Branch (159:9): [True: 22.4k, False: 9.47k]
  ------------------
  160|  31.9k|  }
  161|  22.4k|  buf->remove_prefix(s);
  162|  22.4k|  return value;
  163|  22.4k|}

_ZNK4absl12lts_2026010712log_internal10ProtoField3tagEv:
  245|  11.2k|  uint64_t tag() const { return tag_; }
_ZNK4absl12lts_2026010712log_internal10ProtoField4typeEv:
  246|  7.91k|  WireType type() const { return type_; }
_ZNK4absl12lts_2026010712log_internal10ProtoField11bytes_valueEv:
  275|  11.8k|  absl::Span<const char> bytes_value() const { return data_; }
_ZNK4absl12lts_2026010712log_internal10ProtoField12string_valueEv:
  276|  7.91k|  absl::string_view string_value() const {
  277|  7.91k|    const auto data = bytes_value();
  278|  7.91k|    return absl::string_view(data.data(), data.size());
  279|  7.91k|  }
_ZN4absl12lts_2026010712log_internal12EncodeVarintEmlPNS0_4SpanIcEE:
   73|    661|inline bool EncodeVarint(uint64_t tag, int64_t value, absl::Span<char> *buf) {
   74|    661|  return EncodeVarint(tag, static_cast<uint64_t>(value), buf);
   75|    661|}
_ZN4absl12lts_2026010712log_internal12EncodeVarintEmiPNS0_4SpanIcEE:
   79|  1.98k|inline bool EncodeVarint(uint64_t tag, int32_t value, absl::Span<char> *buf) {
   80|  1.98k|  return EncodeVarint(tag, static_cast<uint64_t>(value), buf);
   81|  1.98k|}
_ZN4absl12lts_2026010712log_internal20EncodeStringTruncateEmNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS0_4SpanIcEE:
  160|  3.18k|                                 absl::Span<char> *buf) {
  161|  3.18k|  return EncodeBytesTruncate(tag, value, buf);
  162|  3.18k|}
_ZN4absl12lts_2026010712log_internal10VarintSizeEm:
  188|  59.6k|constexpr size_t VarintSize(uint64_t value) {
  189|  59.6k|  return value < 128 ? 1 : 1 + VarintSize(value >> 7);
  ------------------
  |  Branch (189:10): [True: 27.4k, False: 32.1k]
  ------------------
  190|  59.6k|}
_ZN4absl12lts_2026010712log_internal13MaxVarintSizeEv:
  194|  2.52k|constexpr size_t MaxVarintSize() {
  195|  2.52k|  return VarintSize((std::numeric_limits<uint64_t>::max)());
  196|  2.52k|}
_ZN4absl12lts_2026010712log_internal11MakeTagTypeEmNS1_8WireTypeE:
  202|  13.7k|constexpr uint64_t MakeTagType(uint64_t tag, WireType type) {
  203|  13.7k|  return tag << 3 | static_cast<uint64_t>(type);
  204|  13.7k|}
_ZN4absl12lts_2026010712log_internal13BufferSizeForEmNS1_8WireTypeE:
  212|  2.52k|constexpr size_t BufferSizeFor(uint64_t tag, WireType type) {
  213|  2.52k|  size_t buffer_size = VarintSize(MakeTagType(tag, type));
  214|  2.52k|  switch (type) {
  ------------------
  |  Branch (214:11): [True: 2.52k, False: 0]
  ------------------
  215|      0|    case WireType::kVarint:
  ------------------
  |  Branch (215:5): [True: 0, False: 2.52k]
  ------------------
  216|      0|      buffer_size += MaxVarintSize();
  217|      0|      break;
  218|      0|    case WireType::k64Bit:
  ------------------
  |  Branch (218:5): [True: 0, False: 2.52k]
  ------------------
  219|      0|      buffer_size += size_t{8};
  220|      0|      break;
  221|  2.52k|    case WireType::kLengthDelimited:
  ------------------
  |  Branch (221:5): [True: 2.52k, False: 0]
  ------------------
  222|  2.52k|      buffer_size += MaxVarintSize();
  223|  2.52k|      break;
  224|      0|    case WireType::k32Bit:
  ------------------
  |  Branch (224:5): [True: 0, False: 2.52k]
  ------------------
  225|      0|      buffer_size += size_t{4};
  226|      0|      break;
  227|  2.52k|  }
  228|  2.52k|  return buffer_size;
  229|  2.52k|}

_ZNK4absl12lts_202601078LogEntry15source_filenameEv:
   76|    661|  absl::string_view source_filename() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   77|    661|    return full_filename_;
   78|    661|  }
_ZNK4absl12lts_202601078LogEntry15source_basenameEv:
   79|    661|  absl::string_view source_basename() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   80|    661|    return base_filename_;
   81|    661|  }
_ZNK4absl12lts_202601078LogEntry11source_lineEv:
   82|  1.32k|  int source_line() const { return line_; }
_ZNK4absl12lts_202601078LogEntry6prefixEv:
   89|    661|  bool prefix() const { return prefix_; }
_ZNK4absl12lts_202601078LogEntry12log_severityEv:
   95|  5.28k|  absl::LogSeverity log_severity() const { return severity_; }
_ZNK4absl12lts_202601078LogEntry9verbosityEv:
  102|    661|  int verbosity() const { return verbose_level_; }
_ZNK4absl12lts_202601078LogEntry9timestampEv:
  113|  1.32k|  absl::Time timestamp() const { return timestamp_; }
_ZNK4absl12lts_202601078LogEntry3tidEv:
  122|  1.32k|  tid_t tid() const { return tid_; }
_ZNK4absl12lts_202601078LogEntry36text_message_with_prefix_and_newlineEv:
  147|    661|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  148|    661|    return absl::string_view(
  149|    661|        text_message_with_prefix_and_newline_and_nul_.data(),
  150|    661|        text_message_with_prefix_and_newline_and_nul_.size() - 1);
  151|    661|  }
_ZNK4absl12lts_202601078LogEntry10stacktraceEv:
  195|    661|  absl::string_view stacktrace() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  196|    661|    return stacktrace_;
  197|    661|  }
_ZN4absl12lts_202601078LogEntryC2Ev:
  200|    661|  LogEntry() = default;

_ZN4absl12lts_202601077LogSinkC2Ev:
   58|      1|  LogSink() = default;

_ZN4absl12lts_2026010711countl_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  108|  6.00k|    countl_zero(T x) noexcept {
  109|  6.00k|  return numeric_internal::CountLeadingZeroes(x);
  110|  6.00k|}
_ZN4absl12lts_2026010711countr_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  123|  1.98k|    countr_zero(T x) noexcept {
  124|  1.98k|  return numeric_internal::CountTrailingZeroes(x);
  125|  1.98k|}

_ZN4absl12lts_2026010716numeric_internal20CountLeadingZeroes64Em:
  214|  6.00k|CountLeadingZeroes64(uint64_t x) {
  215|  6.00k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clzll)
  216|       |  // Use __builtin_clzll, which uses the following instructions:
  217|       |  //  x86: bsr, lzcnt
  218|       |  //  ARM64: clz
  219|       |  //  PPC: cntlzd
  220|  6.00k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  221|  6.00k|                "__builtin_clzll does not take 64-bit arg");
  222|       |
  223|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  224|  6.00k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (224:10): [True: 0, False: 6.00k]
  ------------------
  225|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  226|       |    (defined(_M_X64) || defined(_M_ARM64))
  227|       |  // MSVC does not have __buitin_clzll. Use _BitScanReverse64.
  228|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  229|       |  if (_BitScanReverse64(&result, x)) {
  230|       |    return 63 - result;
  231|       |  }
  232|       |  return 64;
  233|       |#elif defined(_MSC_VER) && !defined(__clang__)
  234|       |  // MSVC does not have __buitin_clzll. Compose two calls to _BitScanReverse
  235|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  236|       |  if ((x >> 32) &&
  237|       |      _BitScanReverse(&result, static_cast<unsigned long>(x >> 32))) {
  238|       |    return 31 - result;
  239|       |  }
  240|       |  if (_BitScanReverse(&result, static_cast<unsigned long>(x))) {
  241|       |    return 63 - result;
  242|       |  }
  243|       |  return 64;
  244|       |#else
  245|       |  int zeroes = 60;
  246|       |  if (x >> 32) {
  247|       |    zeroes -= 32;
  248|       |    x >>= 32;
  249|       |  }
  250|       |  if (x >> 16) {
  251|       |    zeroes -= 16;
  252|       |    x >>= 16;
  253|       |  }
  254|       |  if (x >> 8) {
  255|       |    zeroes -= 8;
  256|       |    x >>= 8;
  257|       |  }
  258|       |  if (x >> 4) {
  259|       |    zeroes -= 4;
  260|       |    x >>= 4;
  261|       |  }
  262|       |  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
  263|       |#endif
  264|  6.00k|}
_ZN4absl12lts_2026010716numeric_internal28CountTrailingZeroesNonzero64Em:
  307|  1.98k|CountTrailingZeroesNonzero64(uint64_t x) {
  308|  1.98k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
  309|  1.98k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  310|  1.98k|                "__builtin_ctzll does not take 64-bit arg");
  311|  1.98k|  return __builtin_ctzll(x);
  312|       |#elif defined(_MSC_VER) && !defined(__clang__) && \
  313|       |    (defined(_M_X64) || defined(_M_ARM64))
  314|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  315|       |  _BitScanForward64(&result, x);
  316|       |  return result;
  317|       |#elif defined(_MSC_VER) && !defined(__clang__)
  318|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  319|       |  if (static_cast<uint32_t>(x) == 0) {
  320|       |    _BitScanForward(&result, static_cast<unsigned long>(x >> 32));
  321|       |    return result + 32;
  322|       |  }
  323|       |  _BitScanForward(&result, static_cast<unsigned long>(x));
  324|       |  return result;
  325|       |#else
  326|       |  int c = 63;
  327|       |  x &= ~x + 1;
  328|       |  if (x & 0x00000000FFFFFFFF) c -= 32;
  329|       |  if (x & 0x0000FFFF0000FFFF) c -= 16;
  330|       |  if (x & 0x00FF00FF00FF00FF) c -= 8;
  331|       |  if (x & 0x0F0F0F0F0F0F0F0F) c -= 4;
  332|       |  if (x & 0x3333333333333333) c -= 2;
  333|       |  if (x & 0x5555555555555555) c -= 1;
  334|       |  return c;
  335|       |#endif
  336|  1.98k|}
_ZN4absl12lts_2026010716numeric_internal18CountLeadingZeroesImEEiT_:
  268|  6.00k|CountLeadingZeroes(T x) {
  269|  6.00k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  270|  6.00k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  271|  6.00k|                "T must have a power-of-2 size");
  272|  6.00k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  273|  6.00k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (273:10): [Folded, False: 6.00k]
  ------------------
  274|  6.00k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  275|      0|                   (std::numeric_limits<uint16_t>::digits -
  276|      0|                    std::numeric_limits<T>::digits)
  277|  6.00k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (277:17): [Folded, False: 6.00k]
  ------------------
  278|  6.00k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  279|      0|                          (std::numeric_limits<uint32_t>::digits -
  280|      0|                           std::numeric_limits<T>::digits)
  281|  6.00k|                    : CountLeadingZeroes64(x));
  282|  6.00k|}
_ZN4absl12lts_2026010716numeric_internal19CountTrailingZeroesImEEiT_:
  353|  1.98k|CountTrailingZeroes(T x) noexcept {
  354|  1.98k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  355|  1.98k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  356|  1.98k|                "T must have a power-of-2 size");
  357|  1.98k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  358|  1.98k|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (358:10): [True: 0, False: 1.98k]
  ------------------
  359|  1.98k|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (359:20): [Folded, False: 1.98k]
  ------------------
  360|  1.98k|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  361|  1.98k|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (361:27): [Folded, False: 1.98k]
  ------------------
  362|  1.98k|                              ? CountTrailingZeroesNonzero32(
  363|      0|                                    static_cast<uint32_t>(x))
  364|  1.98k|                              : CountTrailingZeroesNonzero64(x)));
  365|  1.98k|}

str_cat.cc:_ZN4absl12lts_2026010716strings_internal24StringAppendAndOverwriteINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS0_9StrAppendEPS9_RKNS0_8AlphaNumEE3$_0EEvRT_NSF_9size_typeET0_:
   47|  3.13M|                              Op append_op) {
   48|  3.13M|  if (ABSL_PREDICT_FALSE(append_n > str.max_size() - str.size())) {
  ------------------
  |  |  189|  3.13M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 3.13M]
  |  |  |  Branch (189:49): [Folded, False: 3.13M]
  |  |  |  Branch (189:58): [True: 0, False: 3.13M]
  |  |  ------------------
  ------------------
   49|      0|    absl::base_internal::ThrowStdLengthError(
   50|      0|        "absl::strings_internal::StringAppendAndOverwrite");
   51|      0|  }
   52|       |
   53|  3.13M|  auto old_size = str.size();
   54|  3.13M|  auto resize = old_size + append_n;
   55|       |
   56|  3.13M|  if (resize > str.capacity()) {
  ------------------
  |  Branch (56:7): [True: 9.21k, False: 3.12M]
  ------------------
   57|       |    // Make sure to always grow by at least a factor of 2x.
   58|  9.21k|    const auto min_growth = str.capacity();
   59|  9.21k|    if (ABSL_PREDICT_FALSE(str.capacity() > str.max_size() - min_growth)) {
  ------------------
  |  |  189|  9.21k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 9.21k]
  |  |  |  Branch (189:49): [Folded, False: 9.21k]
  |  |  |  Branch (189:58): [True: 0, False: 9.21k]
  |  |  ------------------
  ------------------
   60|      0|      resize = str.max_size();
   61|  9.21k|    } else if (resize < str.capacity() + min_growth) {
  ------------------
  |  Branch (61:16): [True: 7.91k, False: 1.30k]
  ------------------
   62|  7.91k|      resize = str.capacity() + min_growth;
   63|  7.91k|    }
   64|  3.12M|  } else {
   65|  3.12M|    resize = str.capacity();
   66|  3.12M|  }
   67|       |
   68|       |  // Avoid calling StringResizeAndOverwrite() here since it does an MSAN
   69|       |  // verification on the entire string. StringResizeAndOverwriteImpl() is
   70|       |  // StringResizeAndOverwrite() without the MSAN verification.
   71|  3.13M|  StringResizeAndOverwriteImpl(
   72|  3.13M|      str, resize,
   73|  3.13M|      [old_size, append_n, do_append = std::move(append_op)](
   74|  3.13M|          typename T::value_type* data_ptr, typename T::size_type) mutable {
   75|  3.13M|        auto num_appended =
   76|  3.13M|            std::move(do_append)(data_ptr + old_size, append_n);
   77|  3.13M|        ABSL_HARDENING_ASSERT(num_appended >= 0 && num_appended <= append_n);
   78|  3.13M|        return old_size + num_appended;
   79|  3.13M|      });
   80|       |
   81|       |#if defined(ABSL_HAVE_MEMORY_SANITIZER)
   82|       |  // Only check the region appended to. Checking the entire string would cause
   83|       |  // pathological quadratic verfication on repeated small appends.
   84|       |  __msan_check_mem_is_initialized(str.data() + old_size, str.size() - old_size);
   85|       |#endif
   86|  3.13M|}
str_cat.cc:_ZZN4absl12lts_2026010716strings_internal24StringAppendAndOverwriteINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS0_9StrAppendEPS9_RKNS0_8AlphaNumEE3$_0EEvRT_NSF_9size_typeET0_ENUlPcmE_clESJ_m:
   74|  3.13M|          typename T::value_type* data_ptr, typename T::size_type) mutable {
   75|  3.13M|        auto num_appended =
   76|  3.13M|            std::move(do_append)(data_ptr + old_size, append_n);
   77|  3.13M|        ABSL_HARDENING_ASSERT(num_appended >= 0 && num_appended <= append_n);
  ------------------
  |  |  140|  3.13M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  3.13M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 3.13M]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   78|  3.13M|        return old_size + num_appended;
   79|  3.13M|      });
str_cat.cc:_ZN4absl12lts_2026010716strings_internal24StringAppendAndOverwriteINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS0_9StrAppendEPS9_RKNS0_8AlphaNumESD_E3$_0EEvRT_NSF_9size_typeET0_:
   47|   108k|                              Op append_op) {
   48|   108k|  if (ABSL_PREDICT_FALSE(append_n > str.max_size() - str.size())) {
  ------------------
  |  |  189|   108k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 108k]
  |  |  |  Branch (189:49): [Folded, False: 108k]
  |  |  |  Branch (189:58): [True: 0, False: 108k]
  |  |  ------------------
  ------------------
   49|      0|    absl::base_internal::ThrowStdLengthError(
   50|      0|        "absl::strings_internal::StringAppendAndOverwrite");
   51|      0|  }
   52|       |
   53|   108k|  auto old_size = str.size();
   54|   108k|  auto resize = old_size + append_n;
   55|       |
   56|   108k|  if (resize > str.capacity()) {
  ------------------
  |  Branch (56:7): [True: 0, False: 108k]
  ------------------
   57|       |    // Make sure to always grow by at least a factor of 2x.
   58|      0|    const auto min_growth = str.capacity();
   59|      0|    if (ABSL_PREDICT_FALSE(str.capacity() > str.max_size() - min_growth)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
   60|      0|      resize = str.max_size();
   61|      0|    } else if (resize < str.capacity() + min_growth) {
  ------------------
  |  Branch (61:16): [True: 0, False: 0]
  ------------------
   62|      0|      resize = str.capacity() + min_growth;
   63|      0|    }
   64|   108k|  } else {
   65|   108k|    resize = str.capacity();
   66|   108k|  }
   67|       |
   68|       |  // Avoid calling StringResizeAndOverwrite() here since it does an MSAN
   69|       |  // verification on the entire string. StringResizeAndOverwriteImpl() is
   70|       |  // StringResizeAndOverwrite() without the MSAN verification.
   71|   108k|  StringResizeAndOverwriteImpl(
   72|   108k|      str, resize,
   73|   108k|      [old_size, append_n, do_append = std::move(append_op)](
   74|   108k|          typename T::value_type* data_ptr, typename T::size_type) mutable {
   75|   108k|        auto num_appended =
   76|   108k|            std::move(do_append)(data_ptr + old_size, append_n);
   77|   108k|        ABSL_HARDENING_ASSERT(num_appended >= 0 && num_appended <= append_n);
   78|   108k|        return old_size + num_appended;
   79|   108k|      });
   80|       |
   81|       |#if defined(ABSL_HAVE_MEMORY_SANITIZER)
   82|       |  // Only check the region appended to. Checking the entire string would cause
   83|       |  // pathological quadratic verfication on repeated small appends.
   84|       |  __msan_check_mem_is_initialized(str.data() + old_size, str.size() - old_size);
   85|       |#endif
   86|   108k|}
str_cat.cc:_ZZN4absl12lts_2026010716strings_internal24StringAppendAndOverwriteINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS0_9StrAppendEPS9_RKNS0_8AlphaNumESD_E3$_0EEvRT_NSF_9size_typeET0_ENUlPcmE_clESJ_m:
   74|   108k|          typename T::value_type* data_ptr, typename T::size_type) mutable {
   75|   108k|        auto num_appended =
   76|   108k|            std::move(do_append)(data_ptr + old_size, append_n);
   77|   108k|        ABSL_HARDENING_ASSERT(num_appended >= 0 && num_appended <= append_n);
  ------------------
  |  |  140|   108k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|   108k|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 108k]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   78|   108k|        return old_size + num_appended;
   79|   108k|      });

_ZN4absl12lts_2026010719str_format_internal13ConvertIntArgIcEEbT_NS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  349|    661|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  350|    661|  using U = typename MakeUnsigned<T>::type;
  351|    661|  IntDigits as_digits;
  352|       |
  353|       |  // This odd casting is due to a bug in -Wswitch behavior in gcc49 which causes
  354|       |  // it to complain about a switch/case type mismatch, even though both are
  355|       |  // FormatConversionChar.  Likely this is because at this point
  356|       |  // FormatConversionChar is declared, but not defined.
  357|    661|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  358|    661|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (358:5): [True: 661, False: 0]
  ------------------
  359|    661|      return (std::is_same<T, wchar_t>::value ||
  ------------------
  |  Branch (359:15): [Folded, False: 661]
  ------------------
  360|    661|              (conv.length_mod() == LengthMod::l))
  ------------------
  |  Branch (360:15): [True: 0, False: 661]
  ------------------
  361|    661|                 ? ConvertWCharTImpl(static_cast<wchar_t>(v), conv, sink)
  362|    661|                 : ConvertCharImpl(static_cast<char>(v), conv, sink);
  363|       |
  364|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::o):
  ------------------
  |  Branch (364:5): [True: 0, False: 661]
  ------------------
  365|      0|      as_digits.PrintAsOct(static_cast<U>(v));
  366|      0|      break;
  367|       |
  368|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::x):
  ------------------
  |  Branch (368:5): [True: 0, False: 661]
  ------------------
  369|      0|      as_digits.PrintAsHexLower(static_cast<U>(v));
  370|      0|      break;
  371|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::X):
  ------------------
  |  Branch (371:5): [True: 0, False: 661]
  ------------------
  372|      0|      as_digits.PrintAsHexUpper(static_cast<U>(v));
  373|      0|      break;
  374|       |
  375|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::u):
  ------------------
  |  Branch (375:5): [True: 0, False: 661]
  ------------------
  376|      0|      as_digits.PrintAsDec(static_cast<U>(v));
  377|      0|      break;
  378|       |
  379|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::d):
  ------------------
  |  Branch (379:5): [True: 0, False: 661]
  ------------------
  380|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (380:5): [True: 0, False: 661]
  ------------------
  381|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (381:5): [True: 0, False: 661]
  ------------------
  382|      0|      as_digits.PrintAsDec(v);
  383|      0|      break;
  384|       |
  385|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::a):
  ------------------
  |  Branch (385:5): [True: 0, False: 661]
  ------------------
  386|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (386:5): [True: 0, False: 661]
  ------------------
  387|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (387:5): [True: 0, False: 661]
  ------------------
  388|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (388:5): [True: 0, False: 661]
  ------------------
  389|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (389:5): [True: 0, False: 661]
  ------------------
  390|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (390:5): [True: 0, False: 661]
  ------------------
  391|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (391:5): [True: 0, False: 661]
  ------------------
  392|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (392:5): [True: 0, False: 661]
  ------------------
  393|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  394|       |
  395|      0|    default:
  ------------------
  |  Branch (395:5): [True: 0, False: 661]
  ------------------
  396|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  270|      0|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  397|    661|  }
  398|       |
  399|      0|  if (conv.is_basic()) {
  ------------------
  |  Branch (399:7): [True: 0, False: 0]
  ------------------
  400|      0|    sink->Append(as_digits.with_neg_and_zero());
  401|      0|    return true;
  402|      0|  }
  403|      0|  return ConvertIntImplInnerSlow(as_digits, conv, sink);
  404|      0|}
_ZN4absl12lts_2026010719str_format_internal13ConvertIntArgIhEEbT_NS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  349|  1.62k|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  350|  1.62k|  using U = typename MakeUnsigned<T>::type;
  351|  1.62k|  IntDigits as_digits;
  352|       |
  353|       |  // This odd casting is due to a bug in -Wswitch behavior in gcc49 which causes
  354|       |  // it to complain about a switch/case type mismatch, even though both are
  355|       |  // FormatConversionChar.  Likely this is because at this point
  356|       |  // FormatConversionChar is declared, but not defined.
  357|  1.62k|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  358|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (358:5): [True: 0, False: 1.62k]
  ------------------
  359|      0|      return (std::is_same<T, wchar_t>::value ||
  ------------------
  |  Branch (359:15): [Folded, False: 0]
  ------------------
  360|      0|              (conv.length_mod() == LengthMod::l))
  ------------------
  |  Branch (360:15): [True: 0, False: 0]
  ------------------
  361|      0|                 ? ConvertWCharTImpl(static_cast<wchar_t>(v), conv, sink)
  362|      0|                 : ConvertCharImpl(static_cast<char>(v), conv, sink);
  363|       |
  364|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::o):
  ------------------
  |  Branch (364:5): [True: 0, False: 1.62k]
  ------------------
  365|      0|      as_digits.PrintAsOct(static_cast<U>(v));
  366|      0|      break;
  367|       |
  368|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::x):
  ------------------
  |  Branch (368:5): [True: 0, False: 1.62k]
  ------------------
  369|      0|      as_digits.PrintAsHexLower(static_cast<U>(v));
  370|      0|      break;
  371|  1.62k|    case static_cast<uint8_t>(FormatConversionCharInternal::X):
  ------------------
  |  Branch (371:5): [True: 1.62k, False: 0]
  ------------------
  372|  1.62k|      as_digits.PrintAsHexUpper(static_cast<U>(v));
  373|  1.62k|      break;
  374|       |
  375|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::u):
  ------------------
  |  Branch (375:5): [True: 0, False: 1.62k]
  ------------------
  376|      0|      as_digits.PrintAsDec(static_cast<U>(v));
  377|      0|      break;
  378|       |
  379|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::d):
  ------------------
  |  Branch (379:5): [True: 0, False: 1.62k]
  ------------------
  380|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (380:5): [True: 0, False: 1.62k]
  ------------------
  381|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (381:5): [True: 0, False: 1.62k]
  ------------------
  382|      0|      as_digits.PrintAsDec(v);
  383|      0|      break;
  384|       |
  385|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::a):
  ------------------
  |  Branch (385:5): [True: 0, False: 1.62k]
  ------------------
  386|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (386:5): [True: 0, False: 1.62k]
  ------------------
  387|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (387:5): [True: 0, False: 1.62k]
  ------------------
  388|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (388:5): [True: 0, False: 1.62k]
  ------------------
  389|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (389:5): [True: 0, False: 1.62k]
  ------------------
  390|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (390:5): [True: 0, False: 1.62k]
  ------------------
  391|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (391:5): [True: 0, False: 1.62k]
  ------------------
  392|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (392:5): [True: 0, False: 1.62k]
  ------------------
  393|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  394|       |
  395|      0|    default:
  ------------------
  |  Branch (395:5): [True: 0, False: 1.62k]
  ------------------
  396|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  270|      0|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  397|  1.62k|  }
  398|       |
  399|  1.62k|  if (conv.is_basic()) {
  ------------------
  |  Branch (399:7): [True: 0, False: 1.62k]
  ------------------
  400|      0|    sink->Append(as_digits.with_neg_and_zero());
  401|      0|    return true;
  402|      0|  }
  403|  1.62k|  return ConvertIntImplInnerSlow(as_digits, conv, sink);
  404|  1.62k|}
_ZN4absl12lts_2026010719str_format_internal13ConvertIntArgIiEEbT_NS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  349|  1.98k|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  350|  1.98k|  using U = typename MakeUnsigned<T>::type;
  351|  1.98k|  IntDigits as_digits;
  352|       |
  353|       |  // This odd casting is due to a bug in -Wswitch behavior in gcc49 which causes
  354|       |  // it to complain about a switch/case type mismatch, even though both are
  355|       |  // FormatConversionChar.  Likely this is because at this point
  356|       |  // FormatConversionChar is declared, but not defined.
  357|  1.98k|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  358|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (358:5): [True: 0, False: 1.98k]
  ------------------
  359|      0|      return (std::is_same<T, wchar_t>::value ||
  ------------------
  |  Branch (359:15): [Folded, False: 0]
  ------------------
  360|      0|              (conv.length_mod() == LengthMod::l))
  ------------------
  |  Branch (360:15): [True: 0, False: 0]
  ------------------
  361|      0|                 ? ConvertWCharTImpl(static_cast<wchar_t>(v), conv, sink)
  362|      0|                 : ConvertCharImpl(static_cast<char>(v), conv, sink);
  363|       |
  364|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::o):
  ------------------
  |  Branch (364:5): [True: 0, False: 1.98k]
  ------------------
  365|      0|      as_digits.PrintAsOct(static_cast<U>(v));
  366|      0|      break;
  367|       |
  368|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::x):
  ------------------
  |  Branch (368:5): [True: 0, False: 1.98k]
  ------------------
  369|      0|      as_digits.PrintAsHexLower(static_cast<U>(v));
  370|      0|      break;
  371|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::X):
  ------------------
  |  Branch (371:5): [True: 0, False: 1.98k]
  ------------------
  372|      0|      as_digits.PrintAsHexUpper(static_cast<U>(v));
  373|      0|      break;
  374|       |
  375|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::u):
  ------------------
  |  Branch (375:5): [True: 0, False: 1.98k]
  ------------------
  376|      0|      as_digits.PrintAsDec(static_cast<U>(v));
  377|      0|      break;
  378|       |
  379|  1.98k|    case static_cast<uint8_t>(FormatConversionCharInternal::d):
  ------------------
  |  Branch (379:5): [True: 1.98k, False: 0]
  ------------------
  380|  1.98k|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (380:5): [True: 0, False: 1.98k]
  ------------------
  381|  1.98k|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (381:5): [True: 0, False: 1.98k]
  ------------------
  382|  1.98k|      as_digits.PrintAsDec(v);
  383|  1.98k|      break;
  384|       |
  385|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::a):
  ------------------
  |  Branch (385:5): [True: 0, False: 1.98k]
  ------------------
  386|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (386:5): [True: 0, False: 1.98k]
  ------------------
  387|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (387:5): [True: 0, False: 1.98k]
  ------------------
  388|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (388:5): [True: 0, False: 1.98k]
  ------------------
  389|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (389:5): [True: 0, False: 1.98k]
  ------------------
  390|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (390:5): [True: 0, False: 1.98k]
  ------------------
  391|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (391:5): [True: 0, False: 1.98k]
  ------------------
  392|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (392:5): [True: 0, False: 1.98k]
  ------------------
  393|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  394|       |
  395|      0|    default:
  ------------------
  |  Branch (395:5): [True: 0, False: 1.98k]
  ------------------
  396|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  270|      0|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  397|  1.98k|  }
  398|       |
  399|  1.98k|  if (conv.is_basic()) {
  ------------------
  |  Branch (399:7): [True: 0, False: 1.98k]
  ------------------
  400|      0|    sink->Append(as_digits.with_neg_and_zero());
  401|      0|    return true;
  402|      0|  }
  403|  1.98k|  return ConvertIntImplInnerSlow(as_digits, conv, sink);
  404|  1.98k|}
_ZN4absl12lts_2026010719str_format_internal17FormatConvertImplEcNS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  537|    661|                                    FormatSinkImpl *sink) {
  538|    661|  return {ConvertIntArg(v, conv, sink)};
  539|    661|}
_ZN4absl12lts_2026010719str_format_internal17FormatConvertImplEhNS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  554|  1.62k|                                        FormatSinkImpl *sink) {
  555|  1.62k|  return {ConvertIntArg(v, conv, sink)};
  556|  1.62k|}
_ZN4absl12lts_2026010719str_format_internal17FormatConvertImplEiNS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  569|  1.98k|                                        FormatSinkImpl *sink) {
  570|  1.98k|  return {ConvertIntArg(v, conv, sink)};
  571|  1.98k|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_115ConvertCharImplEcNS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  225|    661|                     FormatSinkImpl* sink) {
  226|    661|  size_t fill = 0;
  227|    661|  if (conv.width() >= 0)
  ------------------
  |  Branch (227:7): [True: 0, False: 661]
  ------------------
  228|      0|    fill = static_cast<size_t>(conv.width());
  229|    661|  ReducePadding(1, &fill);
  230|    661|  if (!conv.has_left_flag()) sink->Append(fill, ' ');
  ------------------
  |  Branch (230:7): [True: 661, False: 0]
  ------------------
  231|    661|  sink->Append(1, v);
  232|    661|  if (conv.has_left_flag()) sink->Append(fill, ' ');
  ------------------
  |  Branch (232:7): [True: 0, False: 661]
  ------------------
  233|    661|  return true;
  234|    661|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_113ReducePaddingEmPm:
   53|  4.26k|void ReducePadding(size_t n, size_t *capacity) {
   54|  4.26k|  *capacity = Excess(n, *capacity);
   55|  4.26k|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_123ConvertIntImplInnerSlowERKNS2_9IntDigitsENS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  238|  3.60k|                             FormatSinkImpl *sink) {
  239|       |  // Print as a sequence of Substrings:
  240|       |  //   [left_spaces][sign][base_indicator][zeroes][formatted][right_spaces]
  241|  3.60k|  size_t fill = 0;
  242|  3.60k|  if (conv.width() >= 0)
  ------------------
  |  Branch (242:7): [True: 3.60k, False: 0]
  ------------------
  243|  3.60k|    fill = static_cast<size_t>(conv.width());
  244|       |
  245|  3.60k|  string_view formatted = as_digits.without_neg_or_zero();
  246|  3.60k|  ReducePadding(formatted, &fill);
  247|       |
  248|  3.60k|  string_view sign = SignColumn(as_digits.is_negative(), conv);
  249|  3.60k|  ReducePadding(sign, &fill);
  250|       |
  251|  3.60k|  string_view base_indicator = BaseIndicator(as_digits, conv);
  252|  3.60k|  ReducePadding(base_indicator, &fill);
  253|       |
  254|  3.60k|  bool precision_specified = conv.precision() >= 0;
  255|  3.60k|  size_t precision =
  256|  3.60k|      precision_specified ? static_cast<size_t>(conv.precision()) : size_t{1};
  ------------------
  |  Branch (256:7): [True: 0, False: 3.60k]
  ------------------
  257|       |
  258|  3.60k|  if (conv.has_alt_flag() &&
  ------------------
  |  Branch (258:7): [True: 0, False: 3.60k]
  ------------------
  259|      0|      conv.conversion_char() == FormatConversionCharInternal::o) {
  ------------------
  |  Branch (259:7): [True: 0, False: 0]
  ------------------
  260|       |    // From POSIX description of the '#' (alt) flag:
  261|       |    //   "For o conversion, it increases the precision (if necessary) to
  262|       |    //   force the first digit of the result to be zero."
  263|      0|    if (formatted.empty() || *formatted.begin() != '0') {
  ------------------
  |  Branch (263:9): [True: 0, False: 0]
  |  Branch (263:30): [True: 0, False: 0]
  ------------------
  264|      0|      size_t needed = formatted.size() + 1;
  265|      0|      precision = std::max(precision, needed);
  266|      0|    }
  267|      0|  }
  268|       |
  269|  3.60k|  size_t num_zeroes = Excess(formatted.size(), precision);
  270|  3.60k|  ReducePadding(num_zeroes, &fill);
  271|       |
  272|  3.60k|  size_t num_left_spaces = !conv.has_left_flag() ? fill : 0;
  ------------------
  |  Branch (272:28): [True: 3.60k, False: 0]
  ------------------
  273|  3.60k|  size_t num_right_spaces = conv.has_left_flag() ? fill : 0;
  ------------------
  |  Branch (273:29): [True: 0, False: 3.60k]
  ------------------
  274|       |
  275|       |  // From POSIX description of the '0' (zero) flag:
  276|       |  //   "For d, i, o, u, x, and X conversion specifiers, if a precision
  277|       |  //   is specified, the '0' flag is ignored."
  278|  3.60k|  if (!precision_specified && conv.has_zero_flag()) {
  ------------------
  |  Branch (278:7): [True: 3.60k, False: 0]
  |  Branch (278:31): [True: 2.94k, False: 661]
  ------------------
  279|  2.94k|    num_zeroes += num_left_spaces;
  280|  2.94k|    num_left_spaces = 0;
  281|  2.94k|  }
  282|       |
  283|  3.60k|  sink->Append(num_left_spaces, ' ');
  284|  3.60k|  sink->Append(sign);
  285|  3.60k|  sink->Append(base_indicator);
  286|  3.60k|  sink->Append(num_zeroes, '0');
  287|  3.60k|  sink->Append(formatted);
  288|  3.60k|  sink->Append(num_right_spaces, ' ');
  289|  3.60k|  return true;
  290|  3.60k|}
arg.cc:_ZNK4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits19without_neg_or_zeroEv:
  178|  3.60k|  string_view without_neg_or_zero() const {
  179|  3.60k|    static_assert('-' < '0', "The check below verifies both.");
  180|  3.60k|    size_t advance = start_[0] <= '0' ? 1 : 0;
  ------------------
  |  Branch (180:22): [True: 22, False: 3.58k]
  ------------------
  181|  3.60k|    return {start_ + advance, size_ - advance};
  182|  3.60k|  }
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_113ReducePaddingENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPm:
   48|  10.8k|void ReducePadding(string_view s, size_t *capacity) {
   49|  10.8k|  *capacity = Excess(s.size(), *capacity);
   50|  10.8k|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_110SignColumnEbNS1_24FormatConversionSpecImplE:
  213|  3.60k|string_view SignColumn(bool neg, const FormatConversionSpecImpl conv) {
  214|  3.60k|  if (conv.conversion_char() == FormatConversionCharInternal::d ||
  ------------------
  |  Branch (214:7): [True: 1.98k, False: 1.62k]
  ------------------
  215|  1.98k|      conv.conversion_char() == FormatConversionCharInternal::i) {
  ------------------
  |  Branch (215:7): [True: 0, False: 1.62k]
  ------------------
  216|  1.98k|    if (neg) return "-";
  ------------------
  |  Branch (216:9): [True: 0, False: 1.98k]
  ------------------
  217|  1.98k|    if (conv.has_show_pos_flag()) return "+";
  ------------------
  |  Branch (217:9): [True: 0, False: 1.98k]
  ------------------
  218|  1.98k|    if (conv.has_sign_col_flag()) return " ";
  ------------------
  |  Branch (218:9): [True: 0, False: 1.98k]
  ------------------
  219|  1.98k|  }
  220|  3.60k|  return {};
  221|  3.60k|}
arg.cc:_ZNK4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits11is_negativeEv:
  184|  3.60k|  bool is_negative() const { return start_[0] == '-'; }
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_113BaseIndicatorERKNS2_9IntDigitsENS1_24FormatConversionSpecImplE:
  196|  3.60k|                          const FormatConversionSpecImpl conv) {
  197|       |  // always show 0x for %p.
  198|  3.60k|  bool alt = conv.has_alt_flag() ||
  ------------------
  |  Branch (198:14): [True: 0, False: 3.60k]
  ------------------
  199|  3.60k|             conv.conversion_char() == FormatConversionCharInternal::p;
  ------------------
  |  Branch (199:14): [True: 0, False: 3.60k]
  ------------------
  200|  3.60k|  bool hex = (conv.conversion_char() == FormatConversionCharInternal::x ||
  ------------------
  |  Branch (200:15): [True: 0, False: 3.60k]
  ------------------
  201|  3.60k|              conv.conversion_char() == FormatConversionCharInternal::X ||
  ------------------
  |  Branch (201:15): [True: 1.62k, False: 1.98k]
  ------------------
  202|  1.98k|              conv.conversion_char() == FormatConversionCharInternal::p);
  ------------------
  |  Branch (202:15): [True: 0, False: 1.98k]
  ------------------
  203|       |  // From the POSIX description of '#' flag:
  204|       |  //   "For x or X conversion specifiers, a non-zero result shall have
  205|       |  //   0x (or 0X) prefixed to it."
  206|  3.60k|  if (alt && hex && !as_digits.without_neg_or_zero().empty()) {
  ------------------
  |  Branch (206:7): [True: 0, False: 3.60k]
  |  Branch (206:7): [True: 0, False: 3.60k]
  |  Branch (206:14): [True: 0, False: 0]
  |  Branch (206:21): [True: 0, False: 0]
  ------------------
  207|      0|    return conv.conversion_char() == FormatConversionCharInternal::X ? "0X"
  ------------------
  |  Branch (207:12): [True: 0, False: 0]
  ------------------
  208|      0|                                                                     : "0x";
  209|      0|  }
  210|  3.60k|  return {};
  211|  3.60k|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits15PrintAsHexUpperIhEEvT_:
  159|  1.62k|  void PrintAsHexUpper(T v) {
  160|  1.62k|    static_assert(!IsSigned<T>::value, "");
  161|  1.62k|    char *p = storage_ + sizeof(storage_);
  162|       |
  163|       |    // kHexTable is only lowercase, so do it manually for uppercase.
  164|  3.02k|    do {
  165|  3.02k|      *--p = "0123456789ABCDEF"[static_cast<size_t>(v) & 15];
  166|  3.02k|      v >>= 4;
  167|  3.02k|    } while (v);
  ------------------
  |  Branch (167:14): [True: 1.40k, False: 1.62k]
  ------------------
  168|  1.62k|    start_ = p;
  169|  1.62k|    size_ = static_cast<size_t>(storage_ + sizeof(storage_) - p);
  170|  1.62k|  }
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits10PrintAsDecIiEEvT_:
   97|  1.98k|  void PrintAsDec(T v) {
   98|  1.98k|    static_assert(std::is_integral<T>::value, "");
   99|  1.98k|    start_ = storage_;
  100|  1.98k|    size_ = static_cast<size_t>(numbers_internal::FastIntToBuffer(v, storage_) -
  101|  1.98k|                                storage_);
  102|  1.98k|  }

_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl8DispatchIcEEbNS2_4DataENS1_24FormatConversionSpecImplEPv:
  594|    661|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  595|       |    // A `none` conv indicates that we want the `int` conversion.
  596|    661|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  189|    661|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 661]
  |  |  |  Branch (189:49): [Folded, False: 661]
  |  |  |  Branch (189:58): [True: 0, False: 661]
  |  |  ------------------
  ------------------
  597|    661|                           FormatConversionCharInternal::kNone)) {
  598|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  599|      0|                      std::is_enum<T>());
  600|      0|    }
  601|    661|    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
  ------------------
  |  |  189|    661|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 661]
  |  |  |  Branch (189:49): [Folded, False: 661]
  |  |  |  Branch (189:58): [True: 0, False: 661]
  |  |  ------------------
  ------------------
  602|    661|                                     spec.conversion_char()))) {
  603|      0|      return false;
  604|      0|    }
  605|    661|    return str_format_internal::FormatConvertImpl(
  606|    661|               Manager<T>::Value(arg), spec,
  607|    661|               static_cast<FormatSinkImpl*>(out))
  608|    661|        .value;
  609|    661|  }
_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl8DispatchIiEEbNS2_4DataENS1_24FormatConversionSpecImplEPv:
  594|  1.98k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  595|       |    // A `none` conv indicates that we want the `int` conversion.
  596|  1.98k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  189|  1.98k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1.98k]
  |  |  |  Branch (189:49): [Folded, False: 1.98k]
  |  |  |  Branch (189:58): [True: 0, False: 1.98k]
  |  |  ------------------
  ------------------
  597|  1.98k|                           FormatConversionCharInternal::kNone)) {
  598|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  599|      0|                      std::is_enum<T>());
  600|      0|    }
  601|  1.98k|    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
  ------------------
  |  |  189|  1.98k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1.98k]
  |  |  |  Branch (189:49): [Folded, False: 1.98k]
  |  |  |  Branch (189:58): [True: 0, False: 1.98k]
  |  |  ------------------
  ------------------
  602|  1.98k|                                     spec.conversion_char()))) {
  603|      0|      return false;
  604|      0|    }
  605|  1.98k|    return str_format_internal::FormatConvertImpl(
  606|  1.98k|               Manager<T>::Value(arg), spec,
  607|  1.98k|               static_cast<FormatSinkImpl*>(out))
  608|  1.98k|        .value;
  609|  1.98k|  }
_ZN4absl12lts_2026010719str_format_internal14ArgumentToConvIcEENS0_23FormatConversionCharSetEv:
  425|    661|constexpr FormatConversionCharSet ArgumentToConv() {
  426|    661|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  427|    661|      std::declval<const Arg&>(),
  428|    661|      std::declval<const FormatConversionSpecImpl&>(),
  429|    661|      std::declval<FormatSinkImpl*>()));
  430|    661|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  431|    661|}
_ZN4absl12lts_2026010719str_format_internal14ExtractCharSetILNS0_23FormatConversionCharSetE131067EEES3_NS1_16ArgConvertResultIXT_EEE:
  208|    661|constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
  209|    661|  return C;
  210|    661|}
_ZN4absl12lts_2026010719str_format_internal14ArgumentToConvIiEENS0_23FormatConversionCharSetEv:
  425|  1.98k|constexpr FormatConversionCharSet ArgumentToConv() {
  426|  1.98k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  427|  1.98k|      std::declval<const Arg&>(),
  428|  1.98k|      std::declval<const FormatConversionSpecImpl&>(),
  429|  1.98k|      std::declval<FormatSinkImpl*>()));
  430|  1.98k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  431|  1.98k|}
_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl7ManagerIcLNS2_13StoragePolicyE2EE5ValueENS2_4DataE:
  545|    661|    static T Value(Data arg) {
  546|    661|      T value;
  547|    661|      memcpy(&value, arg.buf, sizeof(T));
  548|    661|      return value;
  549|    661|    }
_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl7ManagerIiLNS2_13StoragePolicyE2EE5ValueENS2_4DataE:
  545|  1.98k|    static T Value(Data arg) {
  546|  1.98k|      T value;
  547|  1.98k|      memcpy(&value, arg.buf, sizeof(T));
  548|  1.98k|      return value;
  549|  1.98k|    }
_ZN4absl12lts_2026010719str_format_internal19FormatArgImplFriend7ConvertINS1_13FormatArgImplEEEbT_NS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  414|  4.26k|                      FormatSinkImpl* out) {
  415|  4.26k|    return arg.dispatcher_(arg.data_, conv, out);
  416|  4.26k|  }
_ZN4absl12lts_2026010719str_format_internal13FormatArgImplC2IcEERKT_:
  500|    661|  explicit FormatArgImpl(const T& value) {
  501|    661|    using D = typename DecayType<T>::type;
  502|    661|    static_assert(
  503|    661|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  504|    661|        "Decayed types must be stored by value");
  505|    661|    Init(static_cast<D>(value));
  506|    661|  }
_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl4InitIcEEvRKT_:
  553|    661|  void Init(const T& value) {
  554|    661|    data_ = Manager<T>::SetValue(value);
  555|    661|    dispatcher_ = &Dispatch<T>;
  556|    661|  }
_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl7ManagerIcLNS2_13StoragePolicyE2EE8SetValueERKc:
  539|    661|    static Data SetValue(const T& value) {
  540|    661|      Data data;
  541|    661|      memcpy(data.buf, &value, sizeof(value));
  542|    661|      return data;
  543|    661|    }
_ZN4absl12lts_2026010719str_format_internal13FormatArgImplC2IiEERKT_:
  500|  1.98k|  explicit FormatArgImpl(const T& value) {
  501|  1.98k|    using D = typename DecayType<T>::type;
  502|  1.98k|    static_assert(
  503|  1.98k|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  504|  1.98k|        "Decayed types must be stored by value");
  505|  1.98k|    Init(static_cast<D>(value));
  506|  1.98k|  }
_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl4InitIiEEvRKT_:
  553|  1.98k|  void Init(const T& value) {
  554|  1.98k|    data_ = Manager<T>::SetValue(value);
  555|  1.98k|    dispatcher_ = &Dispatch<T>;
  556|  1.98k|  }
_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl7ManagerIiLNS2_13StoragePolicyE2EE8SetValueERKi:
  539|  1.98k|    static Data SetValue(const T& value) {
  540|  1.98k|      Data data;
  541|  1.98k|      memcpy(data.buf, &value, sizeof(value));
  542|  1.98k|      return data;
  543|  1.98k|    }

_ZN4absl12lts_2026010719str_format_internal13FormatUntypedENS1_17FormatRawSinkImplENS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  214|  2.28k|                   absl::Span<const FormatArgImpl> args) {
  215|  2.28k|  FormatSinkImpl sink(raw_sink);
  216|  2.28k|  using Converter = DefaultConverter;
  217|  2.28k|  return ConvertAll(format, args, Converter(&sink));
  218|  2.28k|}
_ZN4absl12lts_2026010719str_format_internal10FormatPackENS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  235|  1.62k|                       absl::Span<const FormatArgImpl> args) {
  236|  1.62k|  std::string out;
  237|  1.62k|  if (ABSL_PREDICT_FALSE(!FormatUntyped(&out, format, args))) {
  ------------------
  |  |  189|  1.62k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1.62k]
  |  |  |  Branch (189:49): [Folded, False: 1.62k]
  |  |  |  Branch (189:58): [True: 0, False: 1.62k]
  |  |  ------------------
  ------------------
  238|      0|    out.clear();
  239|      0|  }
  240|  1.62k|  return out;
  241|  1.62k|}
_ZN4absl12lts_2026010719str_format_internal8SnprintFEPcmNS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  262|    661|             absl::Span<const FormatArgImpl> args) {
  263|    661|  BufferRawSink sink(output, size ? size - 1 : 0);
  ------------------
  |  Branch (263:30): [True: 661, False: 0]
  ------------------
  264|    661|  if (!FormatUntyped(&sink, format, args)) {
  ------------------
  |  Branch (264:7): [True: 0, False: 661]
  ------------------
  265|      0|    errno = EINVAL;
  266|      0|    return -1;
  267|      0|  }
  268|    661|  size_t total = sink.total_written();
  269|    661|  if (size) output[std::min(total, size - 1)] = 0;
  ------------------
  |  Branch (269:7): [True: 661, False: 0]
  ------------------
  270|    661|  return static_cast<int>(total);
  271|    661|}
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_110ArgContextC2ENS0_4SpanIKNS1_13FormatArgImplEEE:
   55|  2.28k|  explicit ArgContext(absl::Span<const FormatArgImpl> pack) : pack_(pack) {}
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_110ArgContext4BindEPKNS1_17UnboundConversionEPNS1_15BoundConversionE:
   70|  4.26k|                             BoundConversion* bound) {
   71|  4.26k|  const FormatArgImpl* arg = nullptr;
   72|  4.26k|  int arg_position = unbound->arg_position;
   73|  4.26k|  if (static_cast<size_t>(arg_position - 1) >= pack_.size()) return false;
  ------------------
  |  Branch (73:7): [True: 0, False: 4.26k]
  ------------------
   74|  4.26k|  arg = &pack_[static_cast<size_t>(arg_position - 1)];  // 1-based
   75|       |
   76|  4.26k|  if (unbound->flags != Flags::kBasic) {
  ------------------
  |  Branch (76:7): [True: 3.60k, False: 661]
  ------------------
   77|  3.60k|    int width = unbound->width.value();
   78|  3.60k|    bool force_left = false;
   79|  3.60k|    if (unbound->width.is_from_arg()) {
  ------------------
  |  Branch (79:9): [True: 0, False: 3.60k]
  ------------------
   80|      0|      if (!BindFromPosition(unbound->width.get_from_arg(), &width, pack_))
  ------------------
  |  Branch (80:11): [True: 0, False: 0]
  ------------------
   81|      0|        return false;
   82|      0|      if (width < 0) {
  ------------------
  |  Branch (82:11): [True: 0, False: 0]
  ------------------
   83|       |        // "A negative field width is taken as a '-' flag followed by a
   84|       |        // positive field width."
   85|      0|        force_left = true;
   86|       |        // Make sure we don't overflow the width when negating it.
   87|      0|        width = -std::max(width, -std::numeric_limits<int>::max());
   88|      0|      }
   89|      0|    }
   90|       |
   91|  3.60k|    int precision = unbound->precision.value();
   92|  3.60k|    if (unbound->precision.is_from_arg()) {
  ------------------
  |  Branch (92:9): [True: 0, False: 3.60k]
  ------------------
   93|      0|      if (!BindFromPosition(unbound->precision.get_from_arg(), &precision,
  ------------------
  |  Branch (93:11): [True: 0, False: 0]
  ------------------
   94|      0|                            pack_))
   95|      0|        return false;
   96|      0|    }
   97|       |
   98|  3.60k|    FormatConversionSpecImplFriend::SetWidth(width, bound);
   99|  3.60k|    FormatConversionSpecImplFriend::SetPrecision(precision, bound);
  100|       |
  101|  3.60k|    if (force_left) {
  ------------------
  |  Branch (101:9): [True: 0, False: 3.60k]
  ------------------
  102|      0|      FormatConversionSpecImplFriend::SetFlags(unbound->flags | Flags::kLeft,
  103|      0|                                               bound);
  104|  3.60k|    } else {
  105|  3.60k|      FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
  106|  3.60k|    }
  107|       |
  108|  3.60k|    FormatConversionSpecImplFriend::SetLengthMod(unbound->length_mod, bound);
  109|  3.60k|  } else {
  110|    661|    FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
  111|    661|    FormatConversionSpecImplFriend::SetWidth(-1, bound);
  112|    661|    FormatConversionSpecImplFriend::SetPrecision(-1, bound);
  113|    661|  }
  114|  4.26k|  FormatConversionSpecImplFriend::SetConversionChar(unbound->conv, bound);
  115|  4.26k|  bound->set_arg(arg);
  116|  4.26k|  return true;
  117|  4.26k|}
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_116DefaultConverterC2EPNS1_14FormatSinkImplE:
  154|  2.28k|  explicit DefaultConverter(FormatSinkImpl* sink) : sink_(sink) {}
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_110ConvertAllINS2_16DefaultConverterEEEbNS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEET_:
  142|  2.28k|                absl::Span<const FormatArgImpl> args, Converter converter) {
  143|  2.28k|  if (format.has_parsed_conversion()) {
  ------------------
  |  Branch (143:7): [True: 0, False: 2.28k]
  ------------------
  144|      0|    return format.parsed_conversion()->ProcessFormat(
  145|      0|        ConverterConsumer<Converter>(converter, args));
  146|  2.28k|  } else {
  147|  2.28k|    return ParseFormatString(format.str(),
  148|  2.28k|                             ConverterConsumer<Converter>(converter, args));
  149|  2.28k|  }
  150|  2.28k|}
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEE10ConvertOneERKNS1_17UnboundConversionENSt3__117basic_string_viewIcNS9_11char_traitsIcEEEE:
  129|  4.26k|  bool ConvertOne(const UnboundConversion& conv, string_view conv_string) {
  130|  4.26k|    BoundConversion bound;
  131|  4.26k|    if (!arg_context_.Bind(&conv, &bound)) return false;
  ------------------
  |  Branch (131:9): [True: 0, False: 4.26k]
  ------------------
  132|  4.26k|    return converter_.ConvertOne(bound, conv_string);
  133|  4.26k|  }
bind.cc:_ZNK4absl12lts_2026010719str_format_internal12_GLOBAL__N_116DefaultConverter10ConvertOneERKNS1_15BoundConversionENSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
  158|  4.26k|  bool ConvertOne(const BoundConversion& bound, string_view /*conv*/) const {
  159|  4.26k|    return FormatArgImplFriend::Convert(*bound.arg(), bound, sink_);
  160|  4.26k|  }
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEE6AppendENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
  125|  6.54k|  bool Append(string_view s) {
  126|  6.54k|    converter_.Append(s);
  127|  6.54k|    return true;
  128|  6.54k|  }
bind.cc:_ZNK4absl12lts_2026010719str_format_internal12_GLOBAL__N_116DefaultConverter6AppendENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  156|  6.54k|  void Append(string_view s) const { sink_->Append(s); }
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEEC2ES4_NS0_4SpanIKNS1_13FormatArgImplEEE:
  123|  2.28k|      : converter_(converter), arg_context_(pack) {}

_ZNK4absl12lts_2026010719str_format_internal15BoundConversion3argEv:
   43|  4.26k|  const FormatArgImpl* arg() const { return arg_; }
_ZN4absl12lts_2026010719str_format_internal15BoundConversion7set_argEPKNS1_13FormatArgImplE:
   44|  4.26k|  void set_arg(const FormatArgImpl* a) { arg_ = a; }
_ZNK4absl12lts_2026010719str_format_internal21UntypedFormatSpecImpl21has_parsed_conversionEv:
   61|  2.28k|  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
_ZNK4absl12lts_2026010719str_format_internal21UntypedFormatSpecImpl3strEv:
   63|  2.28k|  string_view str() const {
   64|       |    assert(!has_parsed_conversion());
   65|  2.28k|    return string_view(static_cast<const char*>(data_), size_);
   66|  2.28k|  }
_ZN4absl12lts_2026010719str_format_internal21UntypedFormatSpecImpl7ExtractINS1_18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE131067ELS5_655355ELS5_655355ELS5_655355EEEEEERKS2_RKT_:
   73|    661|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|    661|    return s.spec_;
   75|    661|  }
_ZN4absl12lts_2026010719str_format_internal18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE131067ELS3_655355ELS3_655355ELS3_655355EEEC2EUa9enable_ifIXclL_ZNS1_15ValidFormatImplIJLS3_131067ELS3_655355ELS3_655355ELS3_655355EEEEbNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEfL0p_EEEPKc:
  159|    661|      : Base(s) {}

_ZN4absl12lts_2026010719str_format_internal17UnboundConversionC2Ev:
   36|  4.26k|  UnboundConversion() {}  // NOLINT
_ZN4absl12lts_2026010719str_format_internal17UnboundConversion10InputValue9set_valueEi:
   45|  3.60k|    constexpr void set_value(int value) {
   46|       |      assert(value >= 0);
   47|  3.60k|      value_ = value;
   48|  3.60k|    }
_ZNK4absl12lts_2026010719str_format_internal17UnboundConversion10InputValue5valueEv:
   49|  7.20k|    constexpr int value() const { return value_; }
_ZNK4absl12lts_2026010719str_format_internal17UnboundConversion10InputValue11is_from_argEv:
   60|  7.20k|    constexpr bool is_from_arg() const { return value_ < -1; }
_ZNK4absl12lts_2026010719str_format_internal7ConvTag7is_convEv:
   94|  7.86k|  constexpr bool is_conv() const { return (tag_ & 0x80) == 0; }
_ZNK4absl12lts_2026010719str_format_internal7ConvTag8is_flagsEv:
   96|  2.94k|  constexpr bool is_flags() const { return (tag_ & 0xE0) == 0xC0; }
_ZNK4absl12lts_2026010719str_format_internal7ConvTag7as_convEv:
   98|  4.26k|  constexpr FormatConversionChar as_conv() const {
   99|  4.26k|    assert(is_conv());
  100|  4.26k|    assert(!is_length());
  101|       |    assert(!is_flags());
  102|  4.26k|    return static_cast<FormatConversionChar>(tag_);
  103|  4.26k|  }
_ZNK4absl12lts_2026010719str_format_internal7ConvTag8as_flagsEv:
  110|  2.94k|  constexpr Flags as_flags() const {
  111|  2.94k|    assert(!is_conv());
  112|  2.94k|    assert(!is_length());
  113|       |    assert(is_flags());
  114|  2.94k|    return static_cast<Flags>(tag_ & 0x1F);
  115|  2.94k|  }
_ZN4absl12lts_2026010719str_format_internal17ConsumeConversionILb0EEEPKcS4_S4_PNS1_17UnboundConversionEPi:
  216|  3.60k|                                        int* next_arg) {
  217|  3.60k|  const char* const original_pos = pos;
  218|  3.60k|  char c = 0;
  219|       |  // Read the next char into `c` and update `pos`. Returns false if there are
  220|       |  // no more chars to read.
  221|  3.60k|#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR()          \
  222|  3.60k|  do {                                                  \
  223|  3.60k|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  224|  3.60k|    c = *pos++;                                         \
  225|  3.60k|  } while (0)
  226|       |
  227|  3.60k|  if (is_positional) {
  ------------------
  |  Branch (227:7): [Folded, False: 3.60k]
  ------------------
  228|      0|    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  229|      0|    if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  230|      0|    conv->arg_position = ParseDigits(c, pos, end);
  231|      0|    assert(conv->arg_position > 0);
  232|      0|    if (ABSL_PREDICT_FALSE(c != '$')) return nullptr;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  233|      0|  }
  234|       |
  235|  3.60k|  ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|  3.60k|  do {                                                  \
  |  |  223|  3.60k|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|  3.60k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 3.60k]
  |  |  |  |  |  Branch (189:49): [Folded, False: 3.60k]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 3.60k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|  3.60k|    c = *pos++;                                         \
  |  |  225|  3.60k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 3.60k]
  |  |  ------------------
  ------------------
  236|       |
  237|       |  // We should start with the basic flag on.
  238|  3.60k|  assert(conv->flags == Flags::kBasic);
  239|       |
  240|       |  // Any non alpha character makes this conversion not basic.
  241|       |  // This includes flags (-+ #0), width (1-9, *) or precision (.).
  242|       |  // All conversion characters and length modifiers are alpha characters.
  243|  3.60k|  if (c < 'A') {
  ------------------
  |  Branch (243:7): [True: 3.60k, False: 0]
  ------------------
  244|  6.54k|    while (c <= '0') {
  ------------------
  |  Branch (244:12): [True: 2.94k, False: 3.60k]
  ------------------
  245|  2.94k|      auto tag = GetTagForChar(c);
  246|  2.94k|      if (tag.is_flags()) {
  ------------------
  |  Branch (246:11): [True: 2.94k, False: 0]
  ------------------
  247|  2.94k|        conv->flags = conv->flags | tag.as_flags();
  248|  2.94k|        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|  2.94k|  do {                                                  \
  |  |  223|  2.94k|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|  2.94k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 2.94k]
  |  |  |  |  |  Branch (189:49): [Folded, False: 2.94k]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 2.94k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|  2.94k|    c = *pos++;                                         \
  |  |  225|  2.94k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 2.94k]
  |  |  ------------------
  ------------------
  249|  2.94k|      } else {
  250|      0|        break;
  251|      0|      }
  252|  2.94k|    }
  253|       |
  254|  3.60k|    if (c <= '9') {
  ------------------
  |  Branch (254:9): [True: 3.60k, False: 0]
  ------------------
  255|  3.60k|      if (c >= '0') {
  ------------------
  |  Branch (255:11): [True: 3.60k, False: 0]
  ------------------
  256|  3.60k|        int maybe_width = ParseDigits(c, pos, end);
  257|  3.60k|        if (!is_positional && c == '$') {
  ------------------
  |  Branch (257:13): [True: 3.60k, Folded]
  |  Branch (257:31): [True: 0, False: 3.60k]
  ------------------
  258|      0|          if (ABSL_PREDICT_FALSE(*next_arg != 0)) return nullptr;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  259|       |          // Positional conversion.
  260|      0|          *next_arg = -1;
  261|      0|          return ConsumeConversion<true>(original_pos, end, conv, next_arg);
  262|      0|        }
  263|  3.60k|        conv->flags = conv->flags | Flags::kNonBasic;
  264|  3.60k|        conv->width.set_value(maybe_width);
  265|  3.60k|      } else if (c == '*') {
  ------------------
  |  Branch (265:18): [True: 0, False: 0]
  ------------------
  266|      0|        conv->flags = conv->flags | Flags::kNonBasic;
  267|      0|        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  268|      0|        if (is_positional) {
  ------------------
  |  Branch (268:13): [Folded, False: 0]
  ------------------
  269|      0|          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  270|      0|          conv->width.set_from_arg(ParseDigits(c, pos, end));
  271|      0|          if (ABSL_PREDICT_FALSE(c != '$')) return nullptr;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  272|      0|          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  273|      0|        } else {
  274|      0|          conv->width.set_from_arg(++*next_arg);
  275|      0|        }
  276|      0|      }
  277|  3.60k|    }
  278|       |
  279|  3.60k|    if (c == '.') {
  ------------------
  |  Branch (279:9): [True: 0, False: 3.60k]
  ------------------
  280|      0|      conv->flags = conv->flags | Flags::kNonBasic;
  281|      0|      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  282|      0|      if ('0' <= c && c <= '9') {
  ------------------
  |  Branch (282:11): [True: 0, False: 0]
  |  Branch (282:23): [True: 0, False: 0]
  ------------------
  283|      0|        conv->precision.set_value(ParseDigits(c, pos, end));
  284|      0|      } else if (c == '*') {
  ------------------
  |  Branch (284:18): [True: 0, False: 0]
  ------------------
  285|      0|        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  286|      0|        if (is_positional) {
  ------------------
  |  Branch (286:13): [Folded, False: 0]
  ------------------
  287|      0|          if (ABSL_PREDICT_FALSE(c < '1' || c > '9')) return nullptr;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  288|      0|          conv->precision.set_from_arg(ParseDigits(c, pos, end));
  289|      0|          if (c != '$') return nullptr;
  ------------------
  |  Branch (289:15): [True: 0, False: 0]
  ------------------
  290|      0|          ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  291|      0|        } else {
  292|      0|          conv->precision.set_from_arg(++*next_arg);
  293|      0|        }
  294|      0|      } else {
  295|      0|        conv->precision.set_value(0);
  296|      0|      }
  297|      0|    }
  298|  3.60k|  }
  299|       |
  300|  3.60k|  auto tag = GetTagForChar(c);
  301|       |
  302|  3.60k|  if (ABSL_PREDICT_FALSE(c == 'v' && conv->flags != Flags::kBasic)) {
  ------------------
  |  |  189|  3.60k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 3.60k]
  |  |  |  Branch (189:49): [Folded, False: 3.60k]
  |  |  |  Branch (189:59): [True: 0, False: 3.60k]
  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  303|      0|    return nullptr;
  304|      0|  }
  305|       |
  306|  3.60k|  if (ABSL_PREDICT_FALSE(!tag.is_conv())) {
  ------------------
  |  |  189|  3.60k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 3.60k]
  |  |  |  Branch (189:49): [Folded, False: 3.60k]
  |  |  |  Branch (189:58): [True: 0, False: 3.60k]
  |  |  ------------------
  ------------------
  307|      0|    if (ABSL_PREDICT_FALSE(!tag.is_length())) return nullptr;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  308|       |
  309|       |    // It is a length modifier.
  310|      0|    LengthMod length_mod = tag.as_length();
  311|      0|    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  312|      0|    if (c == 'h' && length_mod == LengthMod::h) {
  ------------------
  |  Branch (312:9): [True: 0, False: 0]
  |  Branch (312:21): [True: 0, False: 0]
  ------------------
  313|      0|      conv->length_mod = LengthMod::hh;
  314|      0|      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  315|      0|    } else if (c == 'l' && length_mod == LengthMod::l) {
  ------------------
  |  Branch (315:16): [True: 0, False: 0]
  |  Branch (315:28): [True: 0, False: 0]
  ------------------
  316|      0|      conv->length_mod = LengthMod::ll;
  317|      0|      ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|      0|    c = *pos++;                                         \
  |  |  225|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  318|      0|    } else {
  319|      0|      conv->length_mod = length_mod;
  320|      0|    }
  321|      0|    tag = GetTagForChar(c);
  322|       |
  323|      0|    if (ABSL_PREDICT_FALSE(c == 'v')) return nullptr;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  324|      0|    if (ABSL_PREDICT_FALSE(!tag.is_conv())) return nullptr;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  325|       |
  326|       |    // `wchar_t` args are marked non-basic so `Bind()` will copy the length mod.
  327|      0|    if (conv->length_mod == LengthMod::l && c == 'c') {
  ------------------
  |  Branch (327:9): [True: 0, False: 0]
  |  Branch (327:45): [True: 0, False: 0]
  ------------------
  328|      0|      conv->flags = conv->flags | Flags::kNonBasic;
  329|      0|    }
  330|      0|  }
  331|  3.60k|#undef ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR
  332|       |
  333|  3.60k|  assert(CheckFastPathSetting(*conv));
  334|  3.60k|  (void)(&CheckFastPathSetting);
  335|       |
  336|  3.60k|  conv->conv = tag.as_conv();
  337|  3.60k|  if (!is_positional) conv->arg_position = ++*next_arg;
  ------------------
  |  Branch (337:7): [True: 3.60k, Folded]
  ------------------
  338|  3.60k|  return pos;
  339|  3.60k|}
_ZN4absl12lts_2026010719str_format_internal13GetTagForCharEc:
  169|  10.8k|constexpr ConvTag GetTagForChar(char c) {
  170|  10.8k|  return ConvTagHolder::value[static_cast<unsigned char>(c)];
  171|  10.8k|}
_ZN4absl12lts_2026010719str_format_internal11ParseDigitsERcRPKcS4_:
  196|  3.60k|constexpr int ParseDigits(char& c, const char*& pos, const char* const end) {
  197|  3.60k|  int digits = c - '0';
  198|       |  // We do not want to overflow `digits` so we consume at most digits10
  199|       |  // digits. If there are more digits the parsing will fail later on when the
  200|       |  // digit doesn't match the expected characters.
  201|  3.60k|  int num_digits = std::numeric_limits<int>::digits10;
  202|  3.60k|  for (;;) {
  203|  3.60k|    if (ABSL_PREDICT_FALSE(pos == end)) break;
  ------------------
  |  |  189|  3.60k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 3.60k]
  |  |  |  Branch (189:49): [Folded, False: 3.60k]
  |  |  |  Branch (189:58): [True: 0, False: 3.60k]
  |  |  ------------------
  ------------------
  204|  3.60k|    c = *pos++;
  205|  3.60k|    if ('0' > c || c > '9') break;
  ------------------
  |  Branch (205:9): [True: 0, False: 3.60k]
  |  Branch (205:20): [True: 3.60k, False: 0]
  ------------------
  206|      0|    --num_digits;
  207|      0|    if (ABSL_PREDICT_FALSE(!num_digits)) break;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  208|      0|    digits = 10 * digits + c - '0';
  209|      0|  }
  210|  3.60k|  return digits;
  211|  3.60k|}
_ZN4absl12lts_2026010719str_format_internal24ConsumeUnboundConversionEPKcS3_PNS1_17UnboundConversionEPi:
  348|  3.60k|                                               int* next_arg) {
  349|  3.60k|  if (*next_arg < 0) return ConsumeConversion<true>(p, end, conv, next_arg);
  ------------------
  |  Branch (349:7): [True: 0, False: 3.60k]
  ------------------
  350|  3.60k|  return ConsumeConversion<false>(p, end, conv, next_arg);
  351|  3.60k|}

_ZN4absl12lts_2026010719str_format_internal17FormatRawSinkImpl5WriteENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   48|  2.28k|  void Write(string_view s) { write_(sink_, s); }
_ZN4absl12lts_2026010719str_format_internal14FormatSinkImplC2ENS1_17FormatRawSinkImplE:
   68|  2.28k|  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
_ZN4absl12lts_2026010719str_format_internal14FormatSinkImplD2Ev:
   70|  2.28k|  ~FormatSinkImpl() { Flush(); }
_ZN4absl12lts_2026010719str_format_internal14FormatSinkImpl5FlushEv:
   72|  2.28k|  void Flush() {
   73|  2.28k|    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
   74|  2.28k|    pos_ = buf_;
   75|  2.28k|  }
_ZN4absl12lts_2026010719str_format_internal14FormatSinkImpl6AppendEmc:
   77|  12.1k|  void Append(size_t n, char c) {
   78|  12.1k|    if (n == 0) return;
  ------------------
  |  Branch (78:9): [True: 10.2k, False: 1.85k]
  ------------------
   79|  1.85k|    size_ += n;
   80|  1.85k|    auto raw_append = [&](size_t count) {
   81|  1.85k|      memset(pos_, c, count);
   82|  1.85k|      pos_ += count;
   83|  1.85k|    };
   84|  1.85k|    while (n > Avail()) {
  ------------------
  |  Branch (84:12): [True: 0, False: 1.85k]
  ------------------
   85|      0|      n -= Avail();
   86|      0|      if (Avail() > 0) {
  ------------------
  |  Branch (86:11): [True: 0, False: 0]
  ------------------
   87|      0|        raw_append(Avail());
   88|      0|      }
   89|      0|      Flush();
   90|      0|    }
   91|  1.85k|    raw_append(n);
   92|  1.85k|  }
_ZN4absl12lts_2026010719str_format_internal14FormatSinkImpl6AppendENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   94|  17.3k|  void Append(string_view v) {
   95|  17.3k|    size_t n = v.size();
   96|  17.3k|    if (n == 0) return;
  ------------------
  |  Branch (96:9): [True: 7.88k, False: 9.46k]
  ------------------
   97|  9.46k|    size_ += n;
   98|  9.46k|    if (n >= Avail()) {
  ------------------
  |  Branch (98:9): [True: 0, False: 9.46k]
  ------------------
   99|      0|      Flush();
  100|      0|      raw_.Write(v);
  101|      0|      return;
  102|      0|    }
  103|  9.46k|    memcpy(pos_, v.data(), n);
  104|  9.46k|    pos_ += n;
  105|  9.46k|  }
_ZNK4absl12lts_2026010719str_format_internal14FormatSinkImpl5AvailEv:
  123|  11.3k|  size_t Avail() const {
  124|  11.3k|    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
  125|  11.3k|  }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl8is_basicEv:
  277|  3.60k|  bool is_basic() const { return flags_ == Flags::kBasic; }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl13has_left_flagEv:
  278|  8.52k|  bool has_left_flag() const { return FlagsContains(flags_, Flags::kLeft); }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl17has_show_pos_flagEv:
  279|  1.98k|  bool has_show_pos_flag() const {
  280|  1.98k|    return FlagsContains(flags_, Flags::kShowPos);
  281|  1.98k|  }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl17has_sign_col_flagEv:
  282|  1.98k|  bool has_sign_col_flag() const {
  283|  1.98k|    return FlagsContains(flags_, Flags::kSignCol);
  284|  1.98k|  }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl12has_alt_flagEv:
  285|  7.20k|  bool has_alt_flag() const { return FlagsContains(flags_, Flags::kAlt); }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl13has_zero_flagEv:
  286|  3.60k|  bool has_zero_flag() const { return FlagsContains(flags_, Flags::kZero); }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl10length_modEv:
  288|    661|  LengthMod length_mod() const { return length_mod_; }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl5widthEv:
  301|  7.86k|  int width() const { return width_; }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl9precisionEv:
  304|  3.60k|  int precision() const { return precision_; }
_ZN4absl12lts_2026010719str_format_internal30FormatConversionSpecImplFriend8SetFlagsENS1_5FlagsEPNS1_24FormatConversionSpecImplE:
  321|  4.26k|  static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
  322|  4.26k|    conv->flags_ = f;
  323|  4.26k|  }
_ZN4absl12lts_2026010719str_format_internal30FormatConversionSpecImplFriend12SetLengthModENS0_9LengthModEPNS1_24FormatConversionSpecImplE:
  324|  3.60k|  static void SetLengthMod(LengthMod l, FormatConversionSpecImpl* conv) {
  325|  3.60k|    conv->length_mod_ = l;
  326|  3.60k|  }
_ZN4absl12lts_2026010719str_format_internal30FormatConversionSpecImplFriend17SetConversionCharENS0_20FormatConversionCharEPNS1_24FormatConversionSpecImplE:
  328|  4.26k|                                FormatConversionSpecImpl* conv) {
  329|  4.26k|    conv->conv_ = c;
  330|  4.26k|  }
_ZN4absl12lts_2026010719str_format_internal30FormatConversionSpecImplFriend8SetWidthEiPNS1_24FormatConversionSpecImplE:
  331|  4.26k|  static void SetWidth(int w, FormatConversionSpecImpl* conv) {
  332|  4.26k|    conv->width_ = w;
  333|  4.26k|  }
_ZN4absl12lts_2026010719str_format_internal30FormatConversionSpecImplFriend12SetPrecisionEiPNS1_24FormatConversionSpecImplE:
  334|  4.26k|  static void SetPrecision(int p, FormatConversionSpecImpl* conv) {
  335|  4.26k|    conv->precision_ = p;
  336|  4.26k|  }
_ZN4absl12lts_2026010719str_format_internalorENS1_5FlagsES2_:
  146|  6.54k|constexpr Flags operator|(Flags a, Flags b) {
  147|  6.54k|  return static_cast<Flags>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
  148|  6.54k|}
_ZN4absl12lts_2026010719str_format_internal13FlagsContainsENS1_5FlagsES2_:
  150|  23.3k|constexpr bool FlagsContains(Flags haystack, Flags needle) {
  151|  23.3k|  return (static_cast<uint8_t>(haystack) & static_cast<uint8_t>(needle)) ==
  152|  23.3k|         static_cast<uint8_t>(needle);
  153|  23.3k|}
_ZN4absl12lts_2026010719str_format_internal6ExcessEmm:
  447|  18.6k|inline size_t Excess(size_t used, size_t capacity) {
  448|  18.6k|  return used < capacity ? capacity - used : 0;
  ------------------
  |  Branch (448:10): [True: 4.79k, False: 13.8k]
  ------------------
  449|  18.6k|}
_ZZN4absl12lts_2026010719str_format_internal14FormatSinkImpl6AppendEmcENKUlmE_clEm:
   80|  1.85k|    auto raw_append = [&](size_t count) {
   81|  1.85k|      memset(pos_, c, count);
   82|  1.85k|      pos_ += count;
   83|  1.85k|    };
_ZN4absl12lts_2026010719str_format_internal17FormatRawSinkImplC2INSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETnPDTclsr19str_format_internalE11InvokeFlushclsr3stdE7declvalIPT_EEcvNS4_17basic_string_viewIcS7_EE_EEELPv0EEESC_:
   46|  1.62k|      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
_ZN4absl12lts_2026010719str_format_internal17FormatRawSinkImpl5FlushINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvPvNS4_17basic_string_viewIcS7_EE:
   57|  1.62k|  static void Flush(void* r, string_view s) {
   58|  1.62k|    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
   59|  1.62k|  }
_ZN4absl12lts_2026010719str_format_internal17FormatRawSinkImplC2INS1_13BufferRawSinkETnPDTclsr19str_format_internalE11InvokeFlushclsr3stdE7declvalIPT_EEcvNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE_EEELPv0EEES6_:
   46|    661|      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
_ZN4absl12lts_2026010719str_format_internal17FormatRawSinkImpl5FlushINS1_13BufferRawSinkEEEvPvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
   57|    661|  static void Flush(void* r, string_view s) {
   58|    661|    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
   59|    661|  }

_ZN4absl12lts_2026010719str_format_internal13BufferRawSink5WriteENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   34|    661|void BufferRawSink::Write(string_view v) {
   35|    661|  size_t to_write = std::min(v.size(), size_);
   36|    661|  if (to_write > 0) {
  ------------------
  |  Branch (36:7): [True: 661, False: 0]
  ------------------
   37|    661|    std::memcpy(buffer_, v.data(), to_write);
   38|    661|    buffer_ += to_write;
   39|    661|    size_ -= to_write;
   40|    661|  }
   41|    661|  total_written_ += v.size();
   42|    661|}

_ZN4absl12lts_2026010719str_format_internal13BufferRawSinkC2EPcm:
   41|    661|  BufferRawSink(char* buffer, size_t size) : buffer_(buffer), size_(size) {}
_ZNK4absl12lts_2026010719str_format_internal13BufferRawSink13total_writtenEv:
   43|    661|  size_t total_written() const { return total_written_; }
_ZN4absl12lts_2026010719str_format_internal15AbslFormatFlushEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EE:
   71|  1.62k|inline void AbslFormatFlush(std::string* out, string_view s) {
   72|  1.62k|  out->append(s.data(), s.size());
   73|  1.62k|}
_ZN4absl12lts_2026010719str_format_internal15AbslFormatFlushEPNS1_13BufferRawSinkENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
   82|    661|inline void AbslFormatFlush(BufferRawSink* sink, string_view v) {
   83|    661|  sink->Write(v);
   84|    661|}
_ZN4absl12lts_2026010719str_format_internal11InvokeFlushINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEDTcl15AbslFormatFlushfp_fp0_EEPT_NS3_17basic_string_viewIcS6_EE:
   89|  1.62k|auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
   90|  1.62k|  AbslFormatFlush(out, s);
   91|  1.62k|}
_ZN4absl12lts_2026010719str_format_internal11InvokeFlushINS1_13BufferRawSinkEEEDTcl15AbslFormatFlushfp_fp0_EEPT_NSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
   89|    661|auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
   90|    661|  AbslFormatFlush(out, s);
   91|    661|}

_ZN4absl12lts_2026010719str_format_internal32ConsumeUnboundConversionNoInlineEPKcS3_PNS1_17UnboundConversionEPi:
   38|  3.60k|    const char* p, const char* end, UnboundConversion* conv, int* next_arg) {
   39|  3.60k|  return ConsumeUnboundConversion(p, end, conv, next_arg);
   40|  3.60k|}

bind.cc:_ZN4absl12lts_2026010719str_format_internal17ParseFormatStringINS1_12_GLOBAL__N_117ConverterConsumerINS3_16DefaultConverterEEEEEbNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEET_:
   57|  2.28k|bool ParseFormatString(string_view src, Consumer consumer) {
   58|  2.28k|  int next_arg = 0;
   59|  2.28k|  const char* p = src.data();
   60|  2.28k|  const char* const end = p + src.size();
   61|  6.54k|  while (p != end) {
  ------------------
  |  Branch (61:10): [True: 6.54k, False: 0]
  ------------------
   62|  6.54k|    const char* percent =
   63|  6.54k|        static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
   64|  6.54k|    if (!percent) {
  ------------------
  |  Branch (64:9): [True: 2.28k, False: 4.26k]
  ------------------
   65|       |      // We found the last substring.
   66|  2.28k|      return consumer.Append(string_view(p, static_cast<size_t>(end - p)));
   67|  2.28k|    }
   68|       |    // We found a percent, so push the text run then process the percent.
   69|  4.26k|    if (ABSL_PREDICT_FALSE(!consumer.Append(
  ------------------
  |  |  189|  4.26k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 4.26k]
  |  |  |  Branch (189:49): [Folded, False: 4.26k]
  |  |  |  Branch (189:58): [True: 0, False: 4.26k]
  |  |  ------------------
  ------------------
   70|  4.26k|            string_view(p, static_cast<size_t>(percent - p))))) {
   71|      0|      return false;
   72|      0|    }
   73|  4.26k|    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
  ------------------
  |  |  189|  4.26k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 4.26k]
  |  |  |  Branch (189:49): [Folded, False: 4.26k]
  |  |  |  Branch (189:58): [True: 0, False: 4.26k]
  |  |  ------------------
  ------------------
   74|       |
   75|  4.26k|    auto tag = GetTagForChar(percent[1]);
   76|  4.26k|    if (tag.is_conv()) {
  ------------------
  |  Branch (76:9): [True: 661, False: 3.60k]
  ------------------
   77|    661|      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
  ------------------
  |  |  189|    661|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 661]
  |  |  |  Branch (189:49): [Folded, False: 661]
  |  |  |  Branch (189:58): [True: 0, False: 661]
  |  |  ------------------
  ------------------
   78|       |        // This indicates an error in the format string.
   79|       |        // The only way to get `next_arg < 0` here is to have a positional
   80|       |        // argument first which sets next_arg to -1 and then a non-positional
   81|       |        // argument.
   82|      0|        return false;
   83|      0|      }
   84|    661|      p = percent + 2;
   85|       |
   86|       |      // Keep this case separate from the one below.
   87|       |      // ConvertOne is more efficient when the compiler can see that the `basic`
   88|       |      // flag is set.
   89|    661|      UnboundConversion conv;
   90|    661|      conv.conv = tag.as_conv();
   91|    661|      conv.arg_position = ++next_arg;
   92|    661|      if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  189|    661|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 661]
  |  |  |  Branch (189:49): [Folded, False: 661]
  |  |  |  Branch (189:58): [True: 0, False: 661]
  |  |  ------------------
  ------------------
   93|    661|              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
   94|      0|        return false;
   95|      0|      }
   96|  3.60k|    } else if (percent[1] != '%') {
  ------------------
  |  Branch (96:16): [True: 3.60k, False: 0]
  ------------------
   97|  3.60k|      UnboundConversion conv;
   98|  3.60k|      p = ConsumeUnboundConversionNoInline(percent + 1, end, &conv, &next_arg);
   99|  3.60k|      if (ABSL_PREDICT_FALSE(p == nullptr)) return false;
  ------------------
  |  |  189|  3.60k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 3.60k]
  |  |  |  Branch (189:49): [Folded, False: 3.60k]
  |  |  |  Branch (189:58): [True: 0, False: 3.60k]
  |  |  ------------------
  ------------------
  100|  3.60k|      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
  ------------------
  |  |  189|  3.60k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 3.60k]
  |  |  |  Branch (189:49): [Folded, False: 3.60k]
  |  |  |  Branch (189:58): [True: 0, False: 3.60k]
  |  |  ------------------
  ------------------
  101|  3.60k|              conv, string_view(percent + 1,
  102|  3.60k|                                static_cast<size_t>(p - (percent + 1)))))) {
  103|      0|        return false;
  104|      0|      }
  105|  3.60k|    } else {
  106|      0|      if (ABSL_PREDICT_FALSE(!consumer.Append("%"))) return false;
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  107|      0|      p = percent + 2;
  108|      0|      continue;
  109|      0|    }
  110|  4.26k|  }
  111|      0|  return true;
  112|  2.28k|}

_ZN4absl12lts_2026010716numbers_internal15FastIntToBufferEiPc:
  348|  2.64k|    int32_t i, char* absl_nonnull buffer) {
  349|  2.64k|  uint32_t u = static_cast<uint32_t>(i);
  350|  2.64k|  if (i < 0) {
  ------------------
  |  Branch (350:7): [True: 0, False: 2.64k]
  ------------------
  351|      0|    *buffer++ = '-';
  352|       |    // We need to do the negation in modular (i.e., "unsigned")
  353|       |    // arithmetic; MSVC++ apparently warns for plain "-u", so
  354|       |    // we write the equivalent expression "0 - u" instead.
  355|      0|    u = 0 - u;
  356|      0|  }
  357|  2.64k|  buffer = EncodeFullU32(u, buffer);
  358|  2.64k|  *buffer = '\0';
  359|  2.64k|  return buffer;
  360|  2.64k|}
numbers.cc:_ZN4absl12lts_2026010712_GLOBAL__N_113EncodeFullU32EjPc:
  258|  2.64k|    uint32_t n, char* absl_nonnull out_str) {
  259|  2.64k|  if (n < 10) {
  ------------------
  |  Branch (259:7): [True: 0, False: 2.64k]
  ------------------
  260|      0|    *out_str = static_cast<char>('0' + n);
  261|      0|    return out_str + 1;
  262|      0|  }
  263|  2.64k|  if (n < 100'000'000) {
  ------------------
  |  Branch (263:7): [True: 1.98k, False: 661]
  ------------------
  264|  1.98k|    uint64_t bottom = PrepareEightDigits(n);
  265|  1.98k|    ABSL_ASSUME(bottom != 0);
  ------------------
  |  |  270|  1.98k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  266|       |    // 0 minus 8 to make MSVC happy.
  267|  1.98k|    uint32_t zeroes =
  268|  1.98k|        static_cast<uint32_t>(absl::countr_zero(bottom)) & (0 - 8u);
  269|  1.98k|    little_endian::Store64(out_str, (bottom + kEightZeroBytes) >> zeroes);
  270|  1.98k|    return out_str + sizeof(bottom) - zeroes / 8;
  271|  1.98k|  }
  272|    661|  uint32_t div08 = n / 100'000'000;
  273|    661|  uint32_t mod08 = n % 100'000'000;
  274|    661|  uint64_t bottom = PrepareEightDigits(mod08) + kEightZeroBytes;
  275|    661|  out_str = EncodeHundred(div08, out_str);
  276|    661|  little_endian::Store64(out_str, bottom);
  277|    661|  return out_str + sizeof(bottom);
  278|  2.64k|}
numbers.cc:_ZN4absl12lts_2026010712_GLOBAL__N_118PrepareEightDigitsEj:
  229|  2.64k|inline uint64_t PrepareEightDigits(uint32_t i) {
  230|  2.64k|  ABSL_ASSUME(i < 10000'0000);
  ------------------
  |  |  270|  2.64k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  231|       |  // Prepare 2 blocks of 4 digits "in parallel".
  232|  2.64k|  uint32_t hi = i / 10000;
  233|  2.64k|  uint32_t lo = i % 10000;
  234|  2.64k|  uint64_t merged = hi | (uint64_t{lo} << 32);
  235|  2.64k|  uint64_t div100 = ((merged * kDivisionBy100Mul) / kDivisionBy100Div) &
  236|  2.64k|                    ((0x7Full << 32) | 0x7Full);
  237|  2.64k|  uint64_t mod100 = merged - 100ull * div100;
  238|  2.64k|  uint64_t hundreds = (mod100 << 16) + div100;
  239|  2.64k|  uint64_t tens = (hundreds * kDivisionBy10Mul) / kDivisionBy10Div;
  240|  2.64k|  tens &= (0xFull << 48) | (0xFull << 32) | (0xFull << 16) | 0xFull;
  241|  2.64k|  tens += (hundreds - 10ull * tens) << 8;
  242|  2.64k|  return tens;
  243|  2.64k|}
numbers.cc:_ZN4absl12lts_2026010712_GLOBAL__N_113EncodeHundredEjPc:
  179|    661|inline char* EncodeHundred(uint32_t n, char* absl_nonnull out_str) {
  180|    661|  int num_digits = static_cast<int>(n - 10) >> 8;
  181|    661|  uint32_t div10 = (n * kDivisionBy10Mul) / kDivisionBy10Div;
  182|    661|  uint32_t mod10 = n - 10u * div10;
  183|    661|  uint32_t base = kTwoZeroBytes + div10 + (mod10 << 8);
  184|    661|  base >>= num_digits & 8;
  185|    661|  little_endian::Store16(out_str, static_cast<uint16_t>(base));
  186|    661|  return out_str + 2 + num_digits;
  187|    661|}

str_cat.cc:_ZN4absl12lts_2026010724StringResizeAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_16strings_internal9CatPiecesESt16initializer_listINS2_17basic_string_viewIcS5_EEEE3$_0EEvRT_NSF_9size_typeET0_:
  182|    128|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  183|    128|  strings_internal::StringResizeAndOverwriteImpl(str, n, std::move(op));
  184|       |#if defined(ABSL_HAVE_MEMORY_SANITIZER)
  185|       |  __msan_check_mem_is_initialized(str.data(), str.size());
  186|       |#endif
  187|    128|}
str_cat.cc:_ZN4absl12lts_2026010716strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS1_9CatPiecesESt16initializer_listINS3_17basic_string_viewIcS6_EEEE3$_0EEvRT_NSF_9size_typeET0_:
  145|    128|void StringResizeAndOverwriteImpl(T& str, typename T::size_type n, Op op) {
  146|       |#ifdef ABSL_INTERNAL_HAS_RESIZE_AND_OVERWRITE
  147|       |  str.resize_and_overwrite(n, std::move(op));
  148|       |#else
  149|       |  if constexpr (strings_internal::
  150|       |                    has__google_nonstandard_backport_resize_and_overwrite<
  151|       |                        T>::value) {
  152|       |    str.__google_nonstandard_backport_resize_and_overwrite(n, std::move(op));
  153|       |  } else if constexpr (strings_internal::has__resize_and_overwrite<T>::value) {
  154|       |    str.__resize_and_overwrite(n, std::move(op));
  155|    128|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  156|    128|    str.__resize_default_init(n);
  157|    128|    str.__resize_default_init(
  158|    128|        static_cast<typename T::size_type>(std::move(op)(str.data(), n)));
  159|       |  } else if constexpr (strings_internal::has_Resize_and_overwrite<T>::value) {
  160|       |    str._Resize_and_overwrite(n, std::move(op));
  161|       |  } else {
  162|       |    strings_internal::StringResizeAndOverwriteFallback(str, n, std::move(op));
  163|       |  }
  164|    128|#endif
  165|    128|}
str_cat.cc:_ZN4absl12lts_2026010716strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS1_24StringAppendAndOverwriteIS9_ZNS0_9StrAppendEPS9_RKNS0_8AlphaNumEE3$_0EEvRT_NSG_9size_typeET0_EUlPcmE_EEvSH_SI_SJ_:
  145|  3.13M|void StringResizeAndOverwriteImpl(T& str, typename T::size_type n, Op op) {
  146|       |#ifdef ABSL_INTERNAL_HAS_RESIZE_AND_OVERWRITE
  147|       |  str.resize_and_overwrite(n, std::move(op));
  148|       |#else
  149|       |  if constexpr (strings_internal::
  150|       |                    has__google_nonstandard_backport_resize_and_overwrite<
  151|       |                        T>::value) {
  152|       |    str.__google_nonstandard_backport_resize_and_overwrite(n, std::move(op));
  153|       |  } else if constexpr (strings_internal::has__resize_and_overwrite<T>::value) {
  154|       |    str.__resize_and_overwrite(n, std::move(op));
  155|  3.13M|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  156|  3.13M|    str.__resize_default_init(n);
  157|  3.13M|    str.__resize_default_init(
  158|  3.13M|        static_cast<typename T::size_type>(std::move(op)(str.data(), n)));
  159|       |  } else if constexpr (strings_internal::has_Resize_and_overwrite<T>::value) {
  160|       |    str._Resize_and_overwrite(n, std::move(op));
  161|       |  } else {
  162|       |    strings_internal::StringResizeAndOverwriteFallback(str, n, std::move(op));
  163|       |  }
  164|  3.13M|#endif
  165|  3.13M|}
str_cat.cc:_ZN4absl12lts_2026010716strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS1_24StringAppendAndOverwriteIS9_ZNS0_9StrAppendEPS9_RKNS0_8AlphaNumESE_E3$_0EEvRT_NSG_9size_typeET0_EUlPcmE_EEvSH_SI_SJ_:
  145|   108k|void StringResizeAndOverwriteImpl(T& str, typename T::size_type n, Op op) {
  146|       |#ifdef ABSL_INTERNAL_HAS_RESIZE_AND_OVERWRITE
  147|       |  str.resize_and_overwrite(n, std::move(op));
  148|       |#else
  149|       |  if constexpr (strings_internal::
  150|       |                    has__google_nonstandard_backport_resize_and_overwrite<
  151|       |                        T>::value) {
  152|       |    str.__google_nonstandard_backport_resize_and_overwrite(n, std::move(op));
  153|       |  } else if constexpr (strings_internal::has__resize_and_overwrite<T>::value) {
  154|       |    str.__resize_and_overwrite(n, std::move(op));
  155|   108k|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  156|   108k|    str.__resize_default_init(n);
  157|   108k|    str.__resize_default_init(
  158|   108k|        static_cast<typename T::size_type>(std::move(op)(str.data(), n)));
  159|       |  } else if constexpr (strings_internal::has_Resize_and_overwrite<T>::value) {
  160|       |    str._Resize_and_overwrite(n, std::move(op));
  161|       |  } else {
  162|       |    strings_internal::StringResizeAndOverwriteFallback(str, n, std::move(op));
  163|       |  }
  164|   108k|#endif
  165|   108k|}

_ZN4absl12lts_2026010716strings_internal9CatPiecesESt16initializer_listINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE:
  126|    128|std::string CatPieces(std::initializer_list<absl::string_view> pieces) {
  127|    128|  std::string result;
  128|       |  // Use uint64_t to prevent size_t overflow. We assume it is not possible for
  129|       |  // in memory strings to overflow a uint64_t.
  130|    128|  constexpr uint64_t kMaxSize = uint64_t{std::numeric_limits<size_t>::max()};
  131|    128|  uint64_t total_size = 0;
  132|    640|  for (absl::string_view piece : pieces) {
  ------------------
  |  Branch (132:32): [True: 640, False: 128]
  ------------------
  133|    640|    total_size += piece.size();
  134|    640|  }
  135|    128|  ABSL_INTERNAL_CHECK(total_size <= kMaxSize, "size_t overflow");
  ------------------
  |  |   85|    128|  do {                                                             \
  |  |   86|    128|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  189|    128|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 128]
  |  |  |  |  |  Branch (189:49): [Folded, False: 128]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 128]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|    128|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 128]
  |  |  ------------------
  ------------------
  136|    128|  absl::StringResizeAndOverwrite(result, static_cast<size_t>(total_size),
  137|    128|                                 [&pieces](char* const begin, size_t buf_size) {
  138|    128|                                   char* out = begin;
  139|    128|                                   for (absl::string_view piece : pieces) {
  140|    128|                                     const size_t this_size = piece.size();
  141|    128|                                     if (this_size != 0) {
  142|    128|                                       memcpy(out, piece.data(), this_size);
  143|    128|                                       out += this_size;
  144|    128|                                     }
  145|    128|                                   }
  146|    128|                                   assert(out == begin + buf_size);
  147|    128|                                   return buf_size;
  148|    128|                                 });
  149|    128|  return result;
  150|    128|}
_ZN4absl12lts_202601079StrAppendEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS0_8AlphaNumE:
  185|  3.13M|void StrAppend(std::string* absl_nonnull dest, const AlphaNum& a) {
  186|       |  ASSERT_NO_OVERLAP(*dest, a);
  ------------------
  |  |  158|  3.13M|  assert(((src).size() == 0) ||      \
  |  |  159|  3.13M|         (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size())))
  ------------------
  187|  3.13M|  strings_internal::StringAppendAndOverwrite(
  188|  3.13M|      *dest, a.size(), [&a](char* const buf, size_t buf_size) {
  189|  3.13M|        char* out = buf;
  190|  3.13M|        out = Append(out, a);
  191|  3.13M|        assert(out == buf + buf_size);
  192|  3.13M|        return buf_size;
  193|  3.13M|      });
  194|  3.13M|}
_ZN4absl12lts_202601079StrAppendEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS0_8AlphaNumESB_:
  197|   108k|               const AlphaNum& b) {
  198|   108k|  ASSERT_NO_OVERLAP(*dest, a);
  ------------------
  |  |  158|   108k|  assert(((src).size() == 0) ||      \
  |  |  159|   108k|         (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size())))
  ------------------
  199|       |  ASSERT_NO_OVERLAP(*dest, b);
  ------------------
  |  |  158|   108k|  assert(((src).size() == 0) ||      \
  |  |  159|   108k|         (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size())))
  ------------------
  200|   108k|  strings_internal::StringAppendAndOverwrite(
  201|   108k|      *dest, a.size() + b.size(), [&a, &b](char* const buf, size_t buf_size) {
  202|   108k|        char* out = buf;
  203|   108k|        out = Append(out, a);
  204|   108k|        out = Append(out, b);
  205|   108k|        assert(out == buf + buf_size);
  206|   108k|        return buf_size;
  207|   108k|      });
  208|   108k|}
str_cat.cc:_ZN4absl12lts_2026010712_GLOBAL__N_16AppendEPcRKNS0_8AlphaNumE:
   46|  3.34M|inline char* absl_nonnull Append(char* absl_nonnull out, const AlphaNum& x) {
   47|       |  // memcpy is allowed to overwrite arbitrary memory, so doing this after the
   48|       |  // call would force an extra fetch of x.size().
   49|  3.34M|  char* after = out + x.size();
   50|  3.34M|  if (x.size() != 0) {
  ------------------
  |  Branch (50:7): [True: 3.23M, False: 113k]
  ------------------
   51|  3.23M|    memcpy(out, x.data(), x.size());
   52|  3.23M|  }
   53|  3.34M|  return after;
   54|  3.34M|}
str_cat.cc:_ZZN4absl12lts_2026010716strings_internal9CatPiecesESt16initializer_listINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEENK3$_0clEPcm:
  137|    128|                                 [&pieces](char* const begin, size_t buf_size) {
  138|    128|                                   char* out = begin;
  139|    640|                                   for (absl::string_view piece : pieces) {
  ------------------
  |  Branch (139:65): [True: 640, False: 128]
  ------------------
  140|    640|                                     const size_t this_size = piece.size();
  141|    640|                                     if (this_size != 0) {
  ------------------
  |  Branch (141:42): [True: 511, False: 129]
  ------------------
  142|    511|                                       memcpy(out, piece.data(), this_size);
  143|    511|                                       out += this_size;
  144|    511|                                     }
  145|    640|                                   }
  146|       |                                   assert(out == begin + buf_size);
  147|    128|                                   return buf_size;
  148|    128|                                 });
str_cat.cc:_ZZN4absl12lts_202601079StrAppendEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS0_8AlphaNumEENK3$_0clEPcm:
  188|  3.13M|      *dest, a.size(), [&a](char* const buf, size_t buf_size) {
  189|  3.13M|        char* out = buf;
  190|  3.13M|        out = Append(out, a);
  191|       |        assert(out == buf + buf_size);
  192|  3.13M|        return buf_size;
  193|  3.13M|      });
str_cat.cc:_ZZN4absl12lts_202601079StrAppendEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS0_8AlphaNumESB_ENK3$_0clEPcm:
  201|   108k|      *dest, a.size() + b.size(), [&a, &b](char* const buf, size_t buf_size) {
  202|   108k|        char* out = buf;
  203|   108k|        out = Append(out, a);
  204|   108k|        out = Append(out, b);
  205|       |        assert(out == buf + buf_size);
  206|   108k|        return buf_size;
  207|   108k|      });

_ZNK4absl12lts_202601078AlphaNum4sizeEv:
  395|  13.2M|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl12lts_202601078AlphaNum4dataEv:
  396|  3.23M|  const char* absl_nullable data() const { return piece_.data(); }

_ZN4absl12lts_202601078SNPrintFIJciiiEEEiPcmRKNS0_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKS5_:
  470|    661|             const FormatSpec<Args...>& format, const Args&... args) {
  471|    661|  return str_format_internal::SnprintF(
  472|    661|      output, size, str_format_internal::UntypedFormatSpecImpl::Extract(format),
  473|    661|      {str_format_internal::FormatArgImpl(args)...});
  474|    661|}

_ZN4absl12lts_2026010716strings_internal18ApplySubstitutionsENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_6vectorINS1_18ViableSubstitutionENS2_9allocatorIS8_EEEEPNS2_12basic_stringIcS5_NS9_IcEEEE:
   41|  2.45M|    std::string* absl_nonnull result_ptr) {
   42|  2.45M|  auto& subs = *subs_ptr;
   43|  2.45M|  int substitutions = 0;
   44|  2.45M|  size_t pos = 0;
   45|  2.56M|  while (!subs.empty()) {
  ------------------
  |  Branch (45:10): [True: 108k, False: 2.45M]
  ------------------
   46|   108k|    auto& sub = subs.back();
   47|   108k|    if (sub.offset >= pos) {
  ------------------
  |  Branch (47:9): [True: 108k, False: 0]
  ------------------
   48|   108k|      if (pos <= s.size()) {
  ------------------
  |  Branch (48:11): [True: 108k, False: 0]
  ------------------
   49|   108k|        StrAppend(result_ptr, s.substr(pos, sub.offset - pos), sub.replacement);
   50|   108k|      }
   51|   108k|      pos = sub.offset + sub.old.size();
   52|   108k|      substitutions += 1;
   53|   108k|    }
   54|   108k|    sub.offset = s.find(sub.old, pos);
   55|   108k|    if (sub.offset == s.npos) {
  ------------------
  |  Branch (55:9): [True: 108k, False: 0]
  ------------------
   56|   108k|      subs.pop_back();
   57|   108k|    } else {
   58|       |      // Insertion sort to ensure the last ViableSubstitution continues to be
   59|       |      // before all the others.
   60|      0|      size_t index = subs.size();
   61|      0|      while (--index && subs[index - 1].OccursBefore(subs[index])) {
  ------------------
  |  Branch (61:14): [True: 0, False: 0]
  |  Branch (61:25): [True: 0, False: 0]
  ------------------
   62|      0|        std::swap(subs[index], subs[index - 1]);
   63|      0|      }
   64|      0|    }
   65|   108k|  }
   66|  2.45M|  result_ptr->append(s.data() + pos, s.size() - pos);
   67|  2.45M|  return substitutions;
   68|  2.45M|}
_ZN4absl12lts_2026010713StrReplaceAllENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEESt16initializer_listINS1_4pairIS5_S5_EEE:
   81|  2.45M|                          strings_internal::FixedMapping replacements) {
   82|  2.45M|  return StrReplaceAll<strings_internal::FixedMapping>(s, replacements);
   83|  2.45M|}

_ZN4absl12lts_2026010716strings_internal18ViableSubstitutionC2ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEES7_m:
  145|   108k|      : old(old_str), replacement(replacement_str), offset(offset_val) {}
_ZN4absl12lts_2026010713StrReplaceAllISt16initializer_listINSt3__14pairINS3_17basic_string_viewIcNS3_11char_traitsIcEEEES8_EEEEENS3_12basic_stringIcS7_NS3_9allocatorIcEEEES8_RKT_:
  197|  2.45M|                          const StrToStrMapping& replacements) {
  198|  2.45M|  auto subs = strings_internal::FindSubstitutions(s, replacements);
  199|  2.45M|  std::string result;
  200|  2.45M|  result.reserve(s.size());
  201|  2.45M|  strings_internal::ApplySubstitutions(s, &subs, &result);
  202|  2.45M|  return result;
  203|  2.45M|}
_ZN4absl12lts_2026010716strings_internal17FindSubstitutionsISt16initializer_listINSt3__14pairINS4_17basic_string_viewIcNS4_11char_traitsIcEEEES9_EEEEENS4_6vectorINS1_18ViableSubstitutionENS4_9allocatorISD_EEEES9_RKT_:
  161|  2.45M|    absl::string_view s, const StrToStrMapping& replacements) {
  162|  2.45M|  std::vector<ViableSubstitution> subs;
  163|  2.45M|  subs.reserve(replacements.size());
  164|       |
  165|  2.45M|  for (const auto& rep : replacements) {
  ------------------
  |  Branch (165:24): [True: 2.45M, False: 2.45M]
  ------------------
  166|  2.45M|    using std::get;
  167|  2.45M|    absl::string_view old(get<0>(rep));
  168|       |
  169|  2.45M|    size_t pos = s.find(old);
  170|  2.45M|    if (pos == s.npos) continue;
  ------------------
  |  Branch (170:9): [True: 2.34M, False: 108k]
  ------------------
  171|       |
  172|       |    // Ignore attempts to replace "". This condition is almost never true,
  173|       |    // but above condition is frequently true. That's why we test for this
  174|       |    // now and not before.
  175|   108k|    if (old.empty()) continue;
  ------------------
  |  Branch (175:9): [True: 0, False: 108k]
  ------------------
  176|       |
  177|   108k|    subs.emplace_back(old, get<1>(rep), pos);
  178|       |
  179|       |    // Insertion sort to ensure the last ViableSubstitution comes before
  180|       |    // all the others.
  181|   108k|    size_t index = subs.size();
  182|   108k|    while (--index && subs[index - 1].OccursBefore(subs[index])) {
  ------------------
  |  Branch (182:12): [True: 0, False: 108k]
  |  Branch (182:23): [True: 0, False: 0]
  ------------------
  183|      0|      std::swap(subs[index], subs[index - 1]);
  184|      0|    }
  185|   108k|  }
  186|  2.45M|  return subs;
  187|  2.45M|}

_ZNK4absl12lts_202601076ByChar4FindENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEm:
  108|  1.06k|absl::string_view ByChar::Find(absl::string_view text, size_t pos) const {
  109|  1.06k|  size_t found_pos = text.find(c_, pos);
  110|  1.06k|  if (found_pos == absl::string_view::npos)
  ------------------
  |  Branch (110:7): [True: 564, False: 504]
  ------------------
  111|    564|    return absl::string_view(text.data() + text.size(), 0);
  112|    504|  return text.substr(found_pos, 1);
  113|  1.06k|}

_ZN4absl12lts_2026010724synchronization_internal14InvalidGraphIdEv:
   58|    662|inline GraphId InvalidGraphId() {
   59|    662|  return GraphId{0};
   60|    662|}

_ZN4absl12lts_202601075Mutex4lockEv:
 1530|      1|void Mutex::lock() {
 1531|      1|  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
 1532|      1|  GraphId id = DebugOnlyDeadlockCheck(this);
 1533|      1|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1534|       |  // try fast acquire, then spin loop
 1535|      1|  if (ABSL_PREDICT_FALSE((v & (kMuWriter | kMuReader | kMuEvent)) != 0) ||
  ------------------
  |  |  189|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1]
  |  |  |  Branch (189:49): [Folded, False: 1]
  |  |  |  Branch (189:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1536|      1|      ABSL_PREDICT_FALSE(!mu_.compare_exchange_strong(
  ------------------
  |  |  189|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1]
  |  |  |  Branch (189:49): [Folded, False: 1]
  |  |  |  Branch (189:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1537|      1|          v, kMuWriter | v, std::memory_order_acquire,
 1538|      1|          std::memory_order_relaxed))) {
 1539|       |    // try spin acquire, then slow loop
 1540|      0|    if (ABSL_PREDICT_FALSE(!TryAcquireWithSpinning(&this->mu_))) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1541|      0|      this->LockSlow(kExclusive, nullptr, 0);
 1542|      0|    }
 1543|      0|  }
 1544|      1|  DebugOnlyLockEnter(this, id);
 1545|      1|  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 1546|      1|}
_ZN4absl12lts_202601075Mutex11lock_sharedEv:
 1548|    661|void Mutex::lock_shared() {
 1549|    661|  ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
 1550|    661|  GraphId id = DebugOnlyDeadlockCheck(this);
 1551|    661|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1552|    661|  for (;;) {
 1553|       |    // If there are non-readers holding the lock, use the slow loop.
 1554|    661|    if (ABSL_PREDICT_FALSE(v & (kMuWriter | kMuWait | kMuEvent)) != 0) {
  ------------------
  |  |  189|    661|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:49): [Folded, False: 661]
  |  |  |  Branch (189:58): [True: 0, False: 661]
  |  |  ------------------
  ------------------
  |  Branch (1554:9): [True: 0, False: 661]
  ------------------
 1555|      0|      this->LockSlow(kShared, nullptr, 0);
 1556|      0|      break;
 1557|      0|    }
 1558|       |    // We can avoid the loop and only use the CAS when the lock is free or
 1559|       |    // only held by readers.
 1560|    661|    if (ABSL_PREDICT_TRUE(mu_.compare_exchange_weak(
  ------------------
  |  |  190|    661|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 661, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 661]
  |  |  |  Branch (190:57): [True: 661, False: 0]
  |  |  ------------------
  ------------------
 1561|    661|            v, (kMuReader | v) + kMuOne, std::memory_order_acquire,
 1562|    661|            std::memory_order_relaxed))) {
 1563|    661|      break;
 1564|    661|    }
 1565|    661|  }
 1566|    661|  DebugOnlyLockEnter(this, id);
 1567|    661|  ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
 1568|    661|}
_ZN4absl12lts_202601075Mutex6unlockEv:
 1708|      1|void Mutex::unlock() {
 1709|      1|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
 1710|      1|  DebugOnlyLockLeave(this);
 1711|      1|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1712|       |
 1713|      1|  if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) {
  ------------------
  |  Branch (1713:7): [Folded, False: 1]
  |  Branch (1713:21): [True: 0, False: 0]
  ------------------
 1714|      0|    ABSL_RAW_LOG(FATAL, "Mutex unlocked when destroyed or not locked: v=0x%x",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1715|      0|                 static_cast<unsigned>(v));
 1716|      0|  }
 1717|       |
 1718|       |  // should_try_cas is whether we'll try a compare-and-swap immediately.
 1719|       |  // NOTE: optimized out when kDebugMode is false.
 1720|      1|  bool should_try_cas = ((v & (kMuEvent | kMuWriter)) == kMuWriter &&
  ------------------
  |  Branch (1720:26): [True: 1, False: 0]
  ------------------
 1721|      1|                         (v & (kMuWait | kMuDesig)) != kMuWait);
  ------------------
  |  Branch (1721:26): [True: 1, False: 0]
  ------------------
 1722|       |
 1723|       |  // But, we can use an alternate computation of it, that compilers
 1724|       |  // currently don't find on their own.  When that changes, this function
 1725|       |  // can be simplified.
 1726|       |  //
 1727|       |  // should_try_cas is true iff the bits satisfy the following conditions:
 1728|       |  //
 1729|       |  //                   Ev Wr Wa De
 1730|       |  // equal to           0  1
 1731|       |  // and not equal to         1  0
 1732|       |  //
 1733|       |  // after xoring by    0  1  0  1,  this is equivalent to:
 1734|       |  //
 1735|       |  // equal to           0  0
 1736|       |  // and not equal to         1  1,  which is the same as:
 1737|       |  //
 1738|       |  // smaller than       0  0  1  1
 1739|      1|  static_assert(kMuEvent > kMuWait, "Needed for should_try_cas_fast");
 1740|      1|  static_assert(kMuEvent > kMuDesig, "Needed for should_try_cas_fast");
 1741|      1|  static_assert(kMuWriter > kMuWait, "Needed for should_try_cas_fast");
 1742|      1|  static_assert(kMuWriter > kMuDesig, "Needed for should_try_cas_fast");
 1743|       |
 1744|      1|  bool should_try_cas_fast =
 1745|      1|      ((v ^ (kMuWriter | kMuDesig)) &
 1746|      1|       (kMuEvent | kMuWriter | kMuWait | kMuDesig)) < (kMuWait | kMuDesig);
 1747|       |
 1748|      1|  if (kDebugMode && should_try_cas != should_try_cas_fast) {
  ------------------
  |  Branch (1748:7): [Folded, False: 1]
  |  Branch (1748:21): [True: 0, False: 0]
  ------------------
 1749|       |    // We would usually use PRIdPTR here, but is not correctly implemented
 1750|       |    // within the android toolchain.
 1751|      0|    ABSL_RAW_LOG(FATAL, "internal logic error %llx %llx %llx\n",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1752|      0|                 static_cast<long long>(v),
 1753|      0|                 static_cast<long long>(should_try_cas),
 1754|      0|                 static_cast<long long>(should_try_cas_fast));
 1755|      0|  }
 1756|      1|  if (should_try_cas_fast &&
  ------------------
  |  Branch (1756:7): [True: 1, False: 0]
  ------------------
 1757|      1|      mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
  ------------------
  |  Branch (1757:7): [True: 1, False: 0]
  ------------------
 1758|      1|                                  std::memory_order_release,
 1759|      1|                                  std::memory_order_relaxed)) {
 1760|       |    // fast writer release (writer with no waiters or with designated waker)
 1761|      1|  } else {
 1762|      0|    this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
 1763|      0|  }
 1764|      1|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
 1765|      1|}
_ZN4absl12lts_202601075Mutex13unlock_sharedEv:
 1778|    661|void Mutex::unlock_shared() {
 1779|    661|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, __tsan_mutex_read_lock);
 1780|    661|  DebugOnlyLockLeave(this);
 1781|    661|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1782|    661|  assert((v & (kMuWriter | kMuReader)) == kMuReader);
 1783|    661|  for (;;) {
 1784|    661|    if (ABSL_PREDICT_FALSE((v & (kMuReader | kMuWait | kMuEvent)) !=
  ------------------
  |  |  189|    661|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 661]
  |  |  |  Branch (189:49): [Folded, False: 661]
  |  |  |  Branch (189:58): [True: 0, False: 661]
  |  |  ------------------
  ------------------
 1785|    661|                           kMuReader)) {
 1786|      0|      this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
 1787|      0|      break;
 1788|      0|    }
 1789|       |    // fast reader release (reader with no waiters)
 1790|    661|    intptr_t clear = ExactlyOneReader(v) ? kMuReader | kMuOne : kMuOne;
  ------------------
  |  Branch (1790:22): [True: 661, False: 0]
  ------------------
 1791|    661|    if (ABSL_PREDICT_TRUE(
  ------------------
  |  |  190|    661|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 661, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 661]
  |  |  |  Branch (190:57): [True: 661, False: 0]
  |  |  ------------------
  ------------------
 1792|    661|            mu_.compare_exchange_strong(v, v - clear, std::memory_order_release,
 1793|    661|                                        std::memory_order_relaxed))) {
 1794|    661|      break;
 1795|    661|    }
 1796|    661|  }
 1797|    661|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, __tsan_mutex_read_lock);
 1798|    661|}
mutex.cc:_ZN4absl12lts_20260107L22DebugOnlyDeadlockCheckEPNS0_5MutexE:
 1472|    662|static inline GraphId DebugOnlyDeadlockCheck(Mutex* mu) {
 1473|    662|  if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1473:7): [Folded, False: 662]
  |  Branch (1473:21): [True: 0, False: 0]
  ------------------
 1474|      0|                        OnDeadlockCycle::kIgnore) {
 1475|      0|    return DeadlockCheck(mu);
 1476|    662|  } else {
 1477|    662|    return InvalidGraphId();
 1478|    662|  }
 1479|    662|}
mutex.cc:_ZN4absl12lts_20260107L18DebugOnlyLockEnterEPNS0_5MutexENS0_24synchronization_internal7GraphIdE:
 1305|    662|static inline void DebugOnlyLockEnter(Mutex* mu, GraphId id) {
 1306|    662|  if (kDebugMode) {
  ------------------
  |  Branch (1306:7): [Folded, False: 662]
  ------------------
 1307|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1307:9): [True: 0, False: 0]
  ------------------
 1308|      0|        OnDeadlockCycle::kIgnore) {
 1309|      0|      LockEnter(mu, id, Synch_GetAllLocks());
 1310|      0|    }
 1311|      0|  }
 1312|    662|}
mutex.cc:_ZN4absl12lts_20260107L18DebugOnlyLockLeaveEPNS0_5MutexE:
 1315|    662|static inline void DebugOnlyLockLeave(Mutex* mu) {
 1316|    662|  if (kDebugMode) {
  ------------------
  |  Branch (1316:7): [Folded, False: 662]
  ------------------
 1317|      0|    if (synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1317:9): [True: 0, False: 0]
  ------------------
 1318|      0|        OnDeadlockCycle::kIgnore) {
 1319|      0|      LockLeave(mu, GetGraphId(mu), Synch_GetAllLocks());
 1320|      0|    }
 1321|      0|  }
 1322|    662|}
mutex.cc:_ZN4absl12lts_20260107L16ExactlyOneReaderEl:
 1768|    661|static bool ExactlyOneReader(intptr_t v) {
 1769|    661|  assert((v & (kMuWriter | kMuReader)) == kMuReader);
 1770|    661|  assert((v & kMuHigh) != 0);
 1771|       |  // The more straightforward "(v & kMuHigh) == kMuOne" also works, but
 1772|       |  // on some architectures the following generates slightly smaller code.
 1773|       |  // It may be faster too.
 1774|    661|  constexpr intptr_t kMuMultipleWaitersMask = kMuHigh ^ kMuOne;
 1775|    661|  return (v & kMuMultipleWaitersMask) == 0;
 1776|    661|}

_ZN4absl12lts_2026010715ReaderMutexLockC2ERNS0_5MutexE:
  659|    661|      : mu_(mu) {
  660|    661|    mu.lock_shared();
  661|    661|  }
_ZN4absl12lts_2026010715ReaderMutexLockD2Ev:
  685|    661|  ~ReaderMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_.unlock_shared(); }
_ZN4absl12lts_2026010715WriterMutexLockC2ERNS0_5MutexE:
  699|      1|      : mu_(mu) {
  700|      1|    mu.lock();
  701|      1|  }
_ZN4absl12lts_2026010715WriterMutexLockD2Ev:
  727|      1|  ~WriterMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_.unlock(); }
_ZN4absl12lts_202601075MutexC2Ev:
 1156|      1|inline Mutex::Mutex() : mu_(0) {
 1157|      1|  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
 1158|      1|}

_ZN4absl12lts_202601073NowEv:
   39|    661|Time Now() {
   40|       |  // TODO(bww): Get a timespec instead so we don't have to divide.
   41|    661|  int64_t n = absl::GetCurrentTimeNanos();
   42|    661|  if (n >= 0) {
  ------------------
  |  Branch (42:7): [True: 661, False: 0]
  ------------------
   43|    661|    return time_internal::FromUnixDuration(
   44|    661|        time_internal::MakeDuration(n / 1000000000, n % 1000000000 * 4));
   45|    661|  }
   46|      0|  return time_internal::FromUnixDuration(absl::Nanoseconds(n));
   47|    661|}
_ZN4absl12lts_2026010719GetCurrentTimeNanosEv:
   77|    661|int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); }
  ------------------
  |  |   71|    661|  ::absl::time_internal::GetCurrentTimeNanosFromSystem()
  ------------------

clock.cc:_ZN4absl12lts_2026010713time_internalL29GetCurrentTimeNanosFromSystemEv:
   13|    661|static int64_t GetCurrentTimeNanosFromSystem() {
   14|    661|  const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
   15|    661|  struct timespec ts;
   16|    661|  ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0,
  ------------------
  |  |   60|    661|  do {                                                                 \
  |  |   61|    661|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|    661|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 661]
  |  |  |  |  |  Branch (189:49): [Folded, False: 661]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 661]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   62|      0|      ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
  |  |  ------------------
  |  |  |  |   45|      0|  do {                                                                         \
  |  |  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|    661|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 661]
  |  |  ------------------
  ------------------
   17|    661|                 "Failed to read real-time clock.");
   18|    661|  return (int64_t{ts.tv_sec} * kNanosPerSecond +
   19|    661|          int64_t{ts.tv_nsec});
   20|    661|}

_ZN4absl12lts_2026010711ToUnixNanosENS0_4TimeE:
  249|    661|int64_t ToUnixNanos(Time t) {
  250|    661|  if (time_internal::GetRepHi(time_internal::ToUnixDuration(t)) >= 0 &&
  ------------------
  |  Branch (250:7): [True: 661, False: 0]
  ------------------
  251|    661|      time_internal::GetRepHi(time_internal::ToUnixDuration(t)) >> 33 == 0) {
  ------------------
  |  Branch (251:7): [True: 661, False: 0]
  ------------------
  252|    661|    return (time_internal::GetRepHi(time_internal::ToUnixDuration(t)) * 1000 *
  253|    661|            1000 * 1000) +
  254|    661|           (time_internal::GetRepLo(time_internal::ToUnixDuration(t)) / 4);
  255|    661|  }
  256|      0|  return FloorToUnit(time_internal::ToUnixDuration(t), absl::Nanoseconds(1));
  257|    661|}
_ZN4absl12lts_2026010710ToTimespecENS0_4TimeE:
  302|    661|timespec ToTimespec(Time t) {
  303|    661|  timespec ts;
  304|    661|  absl::Duration d = time_internal::ToUnixDuration(t);
  305|    661|  if (!time_internal::IsInfiniteDuration(d)) {
  ------------------
  |  Branch (305:7): [True: 661, False: 0]
  ------------------
  306|    661|    ts.tv_sec = static_cast<decltype(ts.tv_sec)>(time_internal::GetRepHi(d));
  307|    661|    if (ts.tv_sec == time_internal::GetRepHi(d)) {  // no time_t narrowing
  ------------------
  |  Branch (307:9): [True: 661, False: 0]
  ------------------
  308|    661|      ts.tv_nsec = time_internal::GetRepLo(d) / 4;  // floor
  309|    661|      return ts;
  310|    661|    }
  311|    661|  }
  312|      0|  if (d >= absl::ZeroDuration()) {
  ------------------
  |  Branch (312:7): [True: 0, False: 0]
  ------------------
  313|      0|    ts.tv_sec = std::numeric_limits<time_t>::max();
  314|      0|    ts.tv_nsec = 1000 * 1000 * 1000 - 1;
  315|      0|  } else {
  316|      0|    ts.tv_sec = std::numeric_limits<time_t>::min();
  317|      0|    ts.tv_nsec = 0;
  318|      0|  }
  319|      0|  return ts;
  320|    661|}
_ZN4absl12lts_202601079ToTimevalENS0_4TimeE:
  322|    661|timeval ToTimeval(Time t) {
  323|    661|  timeval tv;
  324|    661|  timespec ts = absl::ToTimespec(t);
  325|    661|  tv.tv_sec = static_cast<decltype(tv.tv_sec)>(ts.tv_sec);
  326|    661|  if (tv.tv_sec != ts.tv_sec) {  // narrowing
  ------------------
  |  Branch (326:7): [True: 0, False: 661]
  ------------------
  327|      0|    if (ts.tv_sec < 0) {
  ------------------
  |  Branch (327:9): [True: 0, False: 0]
  ------------------
  328|      0|      tv.tv_sec = std::numeric_limits<decltype(tv.tv_sec)>::min();
  329|      0|      tv.tv_usec = 0;
  330|      0|    } else {
  331|      0|      tv.tv_sec = std::numeric_limits<decltype(tv.tv_sec)>::max();
  332|      0|      tv.tv_usec = 1000 * 1000 - 1;
  333|      0|    }
  334|      0|    return tv;
  335|      0|  }
  336|    661|  tv.tv_usec = static_cast<int>(ts.tv_nsec / 1000);  // suseconds_t
  337|    661|  return tv;
  338|    661|}

_ZN4absl12lts_202601078DurationC2Ev:
  186|    661|  constexpr Duration() : rep_hi_(0), rep_lo_(0) {}  // zero-length duration
_ZN4absl12lts_202601078DurationC2Elj:
  248|    661|  constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
_ZN4absl12lts_202601078Duration5HiRepC2El:
  268|  1.32k|          lo_(0),
  269|  1.32k|          hi_(0)
  270|       |#endif
  271|  1.32k|    {
  272|  1.32k|      *this = value;
  273|  1.32k|    }
_ZNK4absl12lts_202601078Duration5HiRep3GetEv:
  275|  1.32k|    constexpr int64_t Get() const {
  276|  1.32k|      const uint64_t unsigned_value =
  277|  1.32k|          (static_cast<uint64_t>(hi_) << 32) | static_cast<uint64_t>(lo_);
  278|       |      // `static_cast<int64_t>(unsigned_value)` is implementation-defined
  279|       |      // before c++20. On all supported platforms the behaviour is that mandated
  280|       |      // by c++20, i.e. "If the destination type is signed, [...] the result is
  281|       |      // the unique value of the destination type equal to the source value
  282|       |      // modulo 2^n, where n is the number of bits used to represent the
  283|       |      // destination type."
  284|  1.32k|      static_assert(
  285|  1.32k|          (static_cast<int64_t>((std::numeric_limits<uint64_t>::max)()) ==
  286|  1.32k|           int64_t{-1}) &&
  287|  1.32k|              (static_cast<int64_t>(static_cast<uint64_t>(
  288|  1.32k|                                        (std::numeric_limits<int64_t>::max)()) +
  289|  1.32k|                                    1) ==
  290|  1.32k|               (std::numeric_limits<int64_t>::min)()),
  291|  1.32k|          "static_cast<int64_t>(uint64_t) does not have c++20 semantics");
  292|  1.32k|      return static_cast<int64_t>(unsigned_value);
  293|  1.32k|    }
_ZN4absl12lts_202601078Duration5HiRepaSEl:
  295|  1.32k|    constexpr HiRep& operator=(const int64_t value) {
  296|       |      // "If the destination type is unsigned, the resulting value is the
  297|       |      // smallest unsigned value equal to the source value modulo 2^n
  298|       |      // where `n` is the number of bits used to represent the destination
  299|       |      // type".
  300|  1.32k|      const auto unsigned_value = static_cast<uint64_t>(value);
  301|  1.32k|      hi_ = static_cast<uint32_t>(unsigned_value >> 32);
  302|  1.32k|      lo_ = static_cast<uint32_t>(unsigned_value);
  303|  1.32k|      return *this;
  304|  1.32k|    }
_ZN4absl12lts_202601074TimeC2ENS0_8DurationE:
  878|    661|  constexpr explicit Time(Duration rep) : rep_(rep) {}
_ZN4absl12lts_2026010713time_internal12MakeDurationElj:
 1598|    661|                                                              uint32_t lo = 0) {
 1599|    661|  return Duration(hi, lo);
 1600|    661|}
_ZN4absl12lts_2026010713time_internal12MakeDurationEll:
 1603|    661|                                                              int64_t lo) {
 1604|    661|  return MakeDuration(hi, static_cast<uint32_t>(lo));
 1605|    661|}
_ZN4absl12lts_2026010713time_internal8GetRepHiENS0_8DurationE:
 1630|  1.32k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr int64_t GetRepHi(Duration d) {
 1631|  1.32k|  return d.rep_hi_.Get();
 1632|  1.32k|}
_ZN4absl12lts_2026010713time_internal8GetRepLoENS0_8DurationE:
 1633|  1.98k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr uint32_t GetRepLo(Duration d) {
 1634|  1.98k|  return d.rep_lo_;
 1635|  1.98k|}
_ZN4absl12lts_2026010713time_internal18IsInfiniteDurationENS0_8DurationE:
 1638|    661|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool IsInfiniteDuration(Duration d) {
 1639|    661|  return GetRepLo(d) == ~uint32_t{0};
 1640|    661|}
_ZN4absl12lts_2026010713time_internal16FromUnixDurationENS0_8DurationE:
 1663|    661|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixDuration(Duration d) {
 1664|    661|  return Time(d);
 1665|    661|}
_ZN4absl12lts_2026010713time_internal14ToUnixDurationENS0_4TimeE:
 1666|  1.32k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ToUnixDuration(Time t) {
 1667|  1.32k|  return t.rep_;
 1668|  1.32k|}
_ZN4absl12lts_202601074TimeC2Ev:
  803|    661|  constexpr Time() = default;

_ZN4absl12lts_2026010713span_internal11GetDataImplIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEDTcldtfp_4dataEERT_c:
   39|  3.18k|    -> decltype(c.data()) {
   40|  3.18k|  return c.data();
   41|  3.18k|}
_ZN4absl12lts_2026010713span_internal7GetDataIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   51|  3.18k|    -> decltype(GetDataImpl(c, 0)) {
   52|  3.18k|  return GetDataImpl(c, 0);
   53|  3.18k|}
_ZN4absl12lts_2026010713span_internal7GetDataINSt3__15arrayIcLm15000EEEEEDTcl11GetDataImplfp_Li0EEERT_:
   51|  1.98k|    -> decltype(GetDataImpl(c, 0)) {
   52|  1.98k|  return GetDataImpl(c, 0);
   53|  1.98k|}
_ZN4absl12lts_2026010713span_internal11GetDataImplINSt3__15arrayIcLm15000EEEEEDTcldtfp_4dataEERT_c:
   39|  1.98k|    -> decltype(c.data()) {
   40|  1.98k|  return c.data();
   41|  1.98k|}
_ZN4absl12lts_2026010713span_internal7GetDataIKNS0_4SpanIcEEEEDTcl11GetDataImplfp_Li0EEERT_:
   51|    661|    -> decltype(GetDataImpl(c, 0)) {
   52|    661|  return GetDataImpl(c, 0);
   53|    661|}
_ZN4absl12lts_2026010713span_internal11GetDataImplIKNS0_4SpanIcEEEEDTcldtfp_4dataEERT_c:
   39|    661|    -> decltype(c.data()) {
   40|    661|  return c.data();
   41|    661|}
_ZN4absl12lts_2026010713span_internal7GetDataINS0_13InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS5_EEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   51|    661|    -> decltype(GetDataImpl(c, 0)) {
   52|    661|  return GetDataImpl(c, 0);
   53|    661|}
_ZN4absl12lts_2026010713span_internal11GetDataImplINS0_13InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS5_EEEEEEDTcldtfp_4dataEERT_c:
   39|    661|    -> decltype(c.data()) {
   40|    661|  return c.data();
   41|    661|}
_ZN4absl12lts_2026010713span_internal7GetDataINSt3__16vectorIPNS0_7LogSinkENS3_9allocatorIS6_EEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   51|    661|    -> decltype(GetDataImpl(c, 0)) {
   52|    661|  return GetDataImpl(c, 0);
   53|    661|}
_ZN4absl12lts_2026010713span_internal11GetDataImplINSt3__16vectorIPNS0_7LogSinkENS3_9allocatorIS6_EEEEEEDTcldtfp_4dataEERT_c:
   39|    661|    -> decltype(c.data()) {
   40|    661|  return c.data();
   41|    661|}

_ZNK4absl12lts_202601074SpanIKcE4dataEv:
  318|  20.3k|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202601074SpanIKcE4sizeEv:
  323|   109k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202601074SpanIKNS0_19str_format_internal13FormatArgImplEE4sizeEv:
  323|  4.26k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202601074SpanIcE4sizeEv:
  323|  64.5k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202601074SpanIcE4dataEv:
  318|  62.2k|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202601074SpanIcE7subspanEmm:
  468|  6.04k|  constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
  469|  6.04k|    return (pos <= size())
  ------------------
  |  Branch (469:12): [True: 6.04k, False: 0]
  ------------------
  470|  6.04k|               ? Span(data() + pos, (std::min)(size() - pos, len))
  471|  6.04k|               : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
  472|  6.04k|  }
_ZN4absl12lts_202601074SpanIKcEC2INSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEvS9_TnNS5_9enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKSB_:
  269|  3.18k|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202601074SpanIKcEC2EPS2_m:
  230|  19.7k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202601074SpanIKcEC2Ev:
  227|  5.27k|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZN4absl12lts_202601074SpanIcEC2Ev:
  227|  3.52k|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZN4absl12lts_202601074SpanIcEC2EPcm:
  230|  11.5k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202601078MakeSpanITpTnRiJENSt3__15arrayIcLm15000EEEEENS3_9enable_ifIXntsr13span_internal6IsViewIT0_EE5valueEDTclsr4abslE8MakeSpanclsr13span_internalE7GetDatafp_Ecldtfp_4sizeEEEE4typeERS7_:
  762|  1.32k|                                                c.size()))> {
  763|  1.32k|  return MakeSpan(span_internal::GetData(c), c.size());
  764|  1.32k|}
_ZN4absl12lts_202601078MakeSpanITpTnRiJEcEENS0_4SpanIT0_EEPS4_m:
  738|  1.32k|                           size_t size) noexcept {
  739|  1.32k|  return Span<T>(ptr, size);
  740|  1.32k|}
_ZN4absl12lts_202601074SpanIKcEC2INS1_IcEEvS5_TnNSt3__19enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKS8_:
  269|    661|      : Span(span_internal::GetData(v), v.size()) {}
_ZNK4absl12lts_202601074SpanIKcE5emptyEv:
  333|  17.2k|  constexpr bool empty() const noexcept { return size() == 0; }
_ZN4absl12lts_202601078MakeSpanITpTnRiJENS0_13InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS5_EEEEEENS6_9enable_ifIXntsr13span_internal6IsViewIT0_EE5valueEDTclsr4abslE8MakeSpanclsr13span_internalE7GetDatafp_Ecldtfp_4sizeEEEE4typeERSB_:
  762|    661|                                                c.size()))> {
  763|    661|  return MakeSpan(span_internal::GetData(c), c.size());
  764|    661|}
_ZN4absl12lts_202601078MakeSpanITpTnRiJEPNS0_7LogSinkEEENS0_4SpanIT0_EEPS6_m:
  738|  1.32k|                           size_t size) noexcept {
  739|  1.32k|  return Span<T>(ptr, size);
  740|  1.32k|}
_ZN4absl12lts_202601074SpanIPNS0_7LogSinkEEC2EPS3_m:
  230|  1.32k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202601074SpanIcE13remove_prefixEm:
  433|  38.3k|  void remove_prefix(size_type n) noexcept {
  434|  38.3k|    ABSL_HARDENING_ASSERT(size() >= n);
  ------------------
  |  |  140|  38.3k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  38.3k|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 38.3k]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  435|  38.3k|    ptr_ += n;
  436|  38.3k|    len_ -= n;
  437|  38.3k|  }
_ZN4absl12lts_202601074SpanIcEC2INSt3__15arrayIcLm15000EEEvS6_iEERT_:
  246|    661|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202601074SpanIcE13remove_suffixEm:
  442|    661|  void remove_suffix(size_type n) noexcept {
  443|    661|    ABSL_HARDENING_ASSERT(size() >= n);
  ------------------
  |  |  140|    661|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|    661|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 661]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  444|    661|    len_ -= n;
  445|    661|  }
_ZNK4absl12lts_202601074SpanIcEixEm:
  338|  40.1k|  constexpr reference operator[](size_type i) const noexcept {
  339|  40.1k|    ABSL_HARDENING_ASSERT(i < size());
  ------------------
  |  |  140|  40.1k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  40.1k|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 40.1k]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  340|  40.1k|    return ptr_[i];
  341|  40.1k|  }
_ZNK4absl12lts_202601074SpanIKcEixEm:
  338|  63.8k|  constexpr reference operator[](size_type i) const noexcept {
  339|  63.8k|    ABSL_HARDENING_ASSERT(i < size());
  ------------------
  |  |  140|  63.8k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  63.8k|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 63.8k]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  340|  63.8k|    return ptr_[i];
  341|  63.8k|  }
_ZNK4absl12lts_202601074SpanIKcE7subspanEmm:
  468|  8.57k|  constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
  469|  8.57k|    return (pos <= size())
  ------------------
  |  Branch (469:12): [True: 8.57k, False: 0]
  ------------------
  470|  8.57k|               ? Span(data() + pos, (std::min)(size() - pos, len))
  471|  8.57k|               : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
  472|  8.57k|  }
_ZN4absl12lts_202601074SpanIKcE13remove_prefixEm:
  433|  31.0k|  void remove_prefix(size_type n) noexcept {
  434|  31.0k|    ABSL_HARDENING_ASSERT(size() >= n);
  ------------------
  |  |  140|  31.0k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  31.0k|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 31.0k]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  435|  31.0k|    ptr_ += n;
  436|  31.0k|    len_ -= n;
  437|  31.0k|  }
_ZNK4absl12lts_202601074SpanIKNS0_19str_format_internal13FormatArgImplEEixEm:
  338|  4.26k|  constexpr reference operator[](size_type i) const noexcept {
  339|  4.26k|    ABSL_HARDENING_ASSERT(i < size());
  ------------------
  |  |  140|  4.26k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  4.26k|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 4.26k]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  340|  4.26k|    return ptr_[i];
  341|  4.26k|  }
_ZNK4absl12lts_202601074SpanIPNS0_7LogSinkEE5beginEv:
  376|  1.32k|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202601074SpanIPNS0_7LogSinkEE4dataEv:
  318|  2.64k|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202601074SpanIPNS0_7LogSinkEE3endEv:
  389|  1.32k|  constexpr iterator end() const noexcept { return data() + size(); }
_ZNK4absl12lts_202601074SpanIPNS0_7LogSinkEE4sizeEv:
  323|  1.32k|  constexpr size_type size() const noexcept { return len_; }
_ZN4absl12lts_202601078MakeSpanITpTnRiJENSt3__16vectorIPNS0_7LogSinkENS3_9allocatorIS6_EEEEEENS3_9enable_ifIXntsr13span_internal6IsViewIT0_EE5valueEDTclsr4abslE8MakeSpanclsr13span_internalE7GetDatafp_Ecldtfp_4sizeEEEE4typeERSB_:
  762|    661|                                                c.size()))> {
  763|    661|  return MakeSpan(span_internal::GetData(c), c.size());
  764|    661|}

_ZN4absl12lts_202601078bit_castIstTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  183|   100M|inline constexpr Dest bit_cast(const Source& source) {
  184|   100M|  return __builtin_bit_cast(Dest, source);
  185|   100M|}
_ZN4absl12lts_202601078bit_castImlTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  183|   100M|inline constexpr Dest bit_cast(const Source& source) {
  184|   100M|  return __builtin_bit_cast(Dest, source);
  185|   100M|}

_ZN4absl12lts_2026010713little_endian8ToHost64Em:
  110|    732|inline uint64_t ToHost64(uint64_t x) { return x; }

_ZN4absl12lts_2026010713base_internal15UnalignedLoad32EPKv:
   45|  1.42M|inline uint32_t UnalignedLoad32(const void* absl_nonnull p) {
   46|  1.42M|  uint32_t t;
   47|  1.42M|  memcpy(&t, p, sizeof t);
   48|  1.42M|  return t;
   49|  1.42M|}
_ZN4absl12lts_2026010713base_internal15UnalignedLoad64EPKv:
   51|   107M|inline uint64_t UnalignedLoad64(const void* absl_nonnull p) {
   52|   107M|  uint64_t t;
   53|   107M|  memcpy(&t, p, sizeof t);
   54|   107M|  return t;
   55|   107M|}

_ZN4absl12lts_2026010720PrefetchToLocalCacheEPKv:
  146|  67.1M|    const void* addr) {
  147|  67.1M|  __builtin_prefetch(addr, 0, 3);
  148|  67.1M|}

_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE7destroyINS3_9allocatorINS3_4pairIKS7_iEEEEEEDaPT_PNS1_13map_slot_typeIS7_iEE:
  655|  1.49k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  656|  1.49k|    return slot_policy::destroy(alloc, slot);
  657|  1.49k|  }
_ZN4absl12lts_2026010713flat_hash_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEhNS0_18container_internal10StringHashENS9_8StringEqENS6_INS2_4pairIKS8_hEEEEEC2Ev:
  184|      1|  flat_hash_map() {}
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE5valueEPNS3_4pairIKS9_hEE:
  684|    256|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE7elementEPNS1_13map_slot_typeIS9_hEE:
  682|  31.4k|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE5applyINS1_12EqualElementIS9_NS1_8StringEqEEEJRNS3_4pairIKS9_hEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|     11|  apply(F&& f, Args&&... args) {
  669|     11|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|     11|                                                   std::forward<Args>(args)...);
  671|     11|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE8transferINS7_INS3_4pairIKS9_hEEEEEEDaPT_PNS1_13map_slot_typeIS9_hEESK_:
  661|    445|                       slot_type* old_slot) {
  662|    445|    return slot_policy::transfer(alloc, new_slot, old_slot);
  663|    445|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS3_4pairIKS9_hEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|    434|  apply(F&& f, Args&&... args) {
  669|    434|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|    434|                                                   std::forward<Args>(args)...);
  671|    434|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE9constructINS7_INS3_4pairIKS9_hEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOS9_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_hEEDpOT0_:
  649|    256|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|    256|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|    256|  }
_ZN4absl12lts_2026010713flat_hash_mapINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEiNS0_18container_internal10StringHashENS7_8StringEqENS2_9allocatorINS2_4pairIKS6_iEEEEEC2Ev:
  184|  6.35k|  flat_hash_map() {}
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE5applyINS1_12EqualElementIS7_NS1_8StringEqEEEJRNS3_4pairIKS7_iEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSH_DpOSI_:
  668|  5.61M|  apply(F&& f, Args&&... args) {
  669|  5.61M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  5.61M|                                                   std::forward<Args>(args)...);
  671|  5.61M|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE7elementEPNS1_13map_slot_typeIS7_iEE:
  682|  6.09M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE5applyINS1_12raw_hash_setIS8_JEE19EmplaceDecomposableEJRKNS3_4pairIKS7_iEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSI_DpOSJ_:
  668|  43.9k|  apply(F&& f, Args&&... args) {
  669|  43.9k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  43.9k|                                                   std::forward<Args>(args)...);
  671|  43.9k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE9constructINS3_9allocatorINS3_4pairIKS7_iEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSC_EEENSI_IJRKiEEEEEEvPT_PNS1_13map_slot_typeIS7_iEEDpOT0_:
  649|  43.9k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|  43.9k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|  43.9k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE5applyINS1_12EqualElementINS3_17basic_string_viewIcS6_EENS1_8StringEqEEEJRNS3_4pairIKS9_hEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSL_DpOSM_:
  668|  15.3k|  apply(F&& f, Args&&... args) {
  669|  15.3k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  15.3k|                                                   std::forward<Args>(args)...);
  671|  15.3k|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_E5applyINS1_12EqualElementIS8_NS1_6HashEqIS8_vE2EqEEEJRNSt3__14pairIKS8_S9_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSM_DpOSN_:
  668|  4.77M|  apply(F&& f, Args&&... args) {
  669|  4.77M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  4.77M|                                                   std::forward<Args>(args)...);
  671|  4.77M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_E7elementEPNS1_13map_slot_typeIS8_S9_EE:
  682|  45.1M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_E5applyINS1_12raw_hash_setISA_JEE19EmplaceDecomposableEJNSt3__14pairIS8_S9_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSI_DpOSJ_:
  668|  26.4M|  apply(F&& f, Args&&... args) {
  669|  26.4M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  26.4M|                                                   std::forward<Args>(args)...);
  671|  26.4M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_E5applyINS1_11HashElementINS1_6HashEqIS8_vE4HashELb0EEEJRNSt3__14pairIKS8_S9_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSM_DpOSN_:
  668|  40.3M|  apply(F&& f, Args&&... args) {
  669|  40.3M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  40.3M|                                                   std::forward<Args>(args)...);
  671|  40.3M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_E8transferINSt3__19allocatorINSC_4pairIKS8_S9_EEEEEEDaPT_PNS1_13map_slot_typeIS8_S9_EESM_:
  661|  40.3M|                       slot_type* old_slot) {
  662|  40.3M|    return slot_policy::transfer(alloc, new_slot, old_slot);
  663|  40.3M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_E9constructINSt3__19allocatorINSC_4pairIKS8_S9_EEEEJRKNSC_21piecewise_construct_tENSC_5tupleIJOS8_EEENSL_IJOS9_EEEEEEvPT_PNS1_13map_slot_typeIS8_S9_EEDpOT0_:
  649|  26.4M|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|  26.4M|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|  26.4M|  }
unigram_model.cc:_ZN4absl12lts_2026010713flat_hash_mapIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS5_NS0_18container_internal6HashEqIS7_vE4HashENSB_2EqENSt3__19allocatorINSE_4pairIKS7_S8_EEEEEC2Ev:
  184|    365|  flat_hash_map() {}
_ZN4absl12lts_2026010713flat_hash_mapINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS2_4pairIS6_S6_EENS0_18container_internal10StringHashENS9_8StringEqENS2_9allocatorINS7_IKS6_S8_EEEEEC2Ev:
  184|    376|  flat_hash_map() {}

_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE7destroyINS4_9allocatorINS4_4pairIKS8_iEEEEEEDaPT_PNS1_13map_slot_typeIS8_iEE:
   59|  1.49k|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|  1.49k|    return Policy::destroy(alloc, slot);
   61|  1.49k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeISA_hEE:
   85|  31.4k|      -> decltype(P::element(slot)) {
   86|  31.4k|    return P::element(slot);
   87|  31.4k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE8transferINS8_INS4_4pairIKSA_hEEEEEEvPT_PNS1_13map_slot_typeISA_hEESM_:
   75|    445|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|    445|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|    445|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE13transfer_implINS8_INS4_4pairIKSA_hEEEESB_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeISA_hEESO_NSC_5Rank2E:
  119|    445|                                                           old_slot)) {
  120|    445|    return P::transfer(alloc, new_slot, old_slot);
  121|    445|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE9constructINS8_INS4_4pairIKSA_hEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSL_IJEEEEEEvPT_PNS1_13map_slot_typeISA_hEEDpOT0_:
   51|    256|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|    256|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|    256|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE7elementIS9_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIS8_iEE:
   85|  6.09M|      -> decltype(P::element(slot)) {
   86|  6.09M|    return P::element(slot);
   87|  6.09M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE9constructINS4_9allocatorINS4_4pairIKS8_iEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRSE_EEENSK_IJRKiEEEEEEvPT_PNS1_13map_slot_typeIS8_iEEDpOT0_:
   51|  43.9k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|  43.9k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|  43.9k|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIS9_SA_EE:
   85|  45.1M|      -> decltype(P::element(slot)) {
   86|  45.1M|    return P::element(slot);
   87|  45.1M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEvE8transferINSt3__19allocatorINSE_4pairIKS9_SA_EEEEEEvPT_PNS1_13map_slot_typeIS9_SA_EESO_:
   75|  40.3M|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|  40.3M|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|  40.3M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEvE13transfer_implINSt3__19allocatorINSE_4pairIKS9_SA_EEEESB_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeIS9_SA_EESQ_NSC_5Rank2E:
  119|  40.3M|                                                           old_slot)) {
  120|  40.3M|    return P::transfer(alloc, new_slot, old_slot);
  121|  40.3M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEvE9constructINSt3__19allocatorINSE_4pairIKS9_SA_EEEEJRKNSE_21piecewise_construct_tENSE_5tupleIJOS9_EEENSN_IJOSA_EEEEEEvPT_PNS1_13map_slot_typeIS9_SA_EEDpOT0_:
   51|  26.4M|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|  26.4M|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|  26.4M|  }

_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   91|  54.2M|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|  54.2M|  constexpr const ElemT<I>& get() const& {
  250|  54.2M|    return StorageT<I>::get();
  251|  54.2M|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   92|  33.0M|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|  33.0M|  constexpr ElemT<I>& get() & {
  245|  33.0M|    return StorageT<I>::get();
  246|  33.0M|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EE3getEv:
  105|  53.3k|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|  53.3k|  constexpr ElemT<I>& get() & {
  245|  53.3k|    return StorageT<I>::get();
  246|  53.3k|  }
_ZN4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEC2IS3_JS4_S5_S8_ETnNS6_9enable_ifIXsr4absl11conjunctionINS6_8negationINS6_7is_sameIFvS9_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS9_JSF_DpT0_EEEEE5valueEbE4typeELb1EEEOSF_DpOSM_:
  239|  6.73k|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|  6.73k|                                             std::forward<First>(first),
  241|  6.73k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S6_S7_SA_EEENS8_10in_place_tEDpOT_:
  126|  26.9k|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|  26.9k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EEC2IS4_EENS8_10in_place_tEOT_:
   90|  6.73k|      : value(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EEC2IS4_EENS8_10in_place_tEOT_:
  102|  6.73k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EEC2IS4_EENS8_10in_place_tEOT_:
  102|  6.73k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  6.73k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi2EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|  5.63M|  constexpr const ElemT<I>& get() const& {
  250|  5.63M|    return StorageT<I>::get();
  251|  5.63M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EE3getEv:
  104|  5.63M|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|  7.35M|  constexpr const ElemT<I>& get() const& {
  250|  7.35M|    return StorageT<I>::get();
  251|  7.35M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  104|  7.35M|  constexpr const T& get() const& { return *this; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|  1.49k|  constexpr ElemT<I>& get() & {
  245|  1.49k|    return StorageT<I>::get();
  246|  1.49k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  105|  1.49k|  constexpr T& get() & { return *this; }
unigram_model.cc:_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSB_2EqENSt3__19allocatorIcEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISH_XT_EE4typeEv:
  249|   368M|  constexpr const ElemT<I>& get() const& {
  250|   368M|    return StorageT<I>::get();
  251|   368M|  }
unigram_model.cc:_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSD_2EqENSt3__19allocatorIcEEEEELb0EE3getEv:
   91|   368M|  constexpr const T& get() const& { return value; }
unigram_model.cc:_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSB_2EqENSt3__19allocatorIcEEEE3getILi2EEERKNS1_25internal_compressed_tuple4ElemISH_XT_EE4typeEv:
  249|  4.77M|  constexpr const ElemT<I>& get() const& {
  250|  4.77M|    return StorageT<I>::get();
  251|  4.77M|  }
unigram_model.cc:_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE2EqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENSB_4HashESC_NSt3__19allocatorIcEEEEELb1EE3getEv:
  104|  4.77M|  constexpr const T& get() const& { return *this; }
unigram_model.cc:_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSB_2EqENSt3__19allocatorIcEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemISH_XT_EE4typeEv:
  244|   225M|  constexpr ElemT<I>& get() & {
  245|   225M|    return StorageT<I>::get();
  246|   225M|  }
unigram_model.cc:_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSD_2EqENSt3__19allocatorIcEEEEELb0EE3getEv:
   92|   225M|  constexpr T& get() & { return value; }
unigram_model.cc:_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSB_2EqENSt3__19allocatorIcEEEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemISH_XT_EE4typeEv:
  249|  93.1M|  constexpr const ElemT<I>& get() const& {
  250|  93.1M|    return StorageT<I>::get();
  251|  93.1M|  }
unigram_model.cc:_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashELm1ENS2_10StorageTagIJNS1_12CommonFieldsESC_NSB_2EqENSt3__19allocatorIcEEEEELb1EE3getEv:
  104|  93.1M|  constexpr const T& get() const& { return *this; }
unigram_model.cc:_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSB_2EqENSt3__19allocatorIcEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemISH_XT_EE4typeEv:
  244|  66.7M|  constexpr ElemT<I>& get() & {
  245|  66.7M|    return StorageT<I>::get();
  246|  66.7M|  }
unigram_model.cc:_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSG_2EqES6_EEELb1EE3getEv:
  105|  66.7M|  constexpr T& get() & { return *this; }
unigram_model.cc:_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSB_2EqENSt3__19allocatorIcEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISH_XT_EE4typeEv:
  244|    365|  constexpr ElemT<I>& get() & {
  245|    365|    return StorageT<I>::get();
  246|    365|  }
unigram_model.cc:_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashELm1ENS2_10StorageTagIJNS1_12CommonFieldsESC_NSB_2EqENSt3__19allocatorIcEEEEELb1EE3getEv:
  105|    365|  constexpr T& get() & { return *this; }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSB_2EqENSt3__19allocatorIcEEEEC2IS3_JSC_SD_SG_ETnNSE_9enable_ifIXsr4absl11conjunctionINSE_8negationINSE_7is_sameIFvSH_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleISH_JSN_DpT0_EEEEE5valueEbE4typeELb1EEEOSN_DpOSU_:
  239|    365|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|    365|                                             std::forward<First>(first),
  241|    365|                                             std::forward<Vs>(base)...) {}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSD_2EqENSt3__19allocatorIcEEEEENSG_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_SE_SF_SI_EEENSG_10in_place_tEDpOT_:
  126|  1.46k|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|  1.46k|                                          std::forward<Vs>(args))... {}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSD_2EqENSt3__19allocatorIcEEEEELb0EEC2IS4_EENSG_10in_place_tEOT_:
   90|    365|      : value(std::forward<V>(v)) {}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashELm1ENS2_10StorageTagIJNS1_12CommonFieldsESC_NSB_2EqENSt3__19allocatorIcEEEEELb1EEC2ISC_EENSG_10in_place_tEOT_:
  102|    365|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE2EqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENSB_4HashESC_NSt3__19allocatorIcEEEEELb1EEC2ISC_EENSG_10in_place_tEOT_:
  102|    365|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashENSG_2EqES6_EEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|    365|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}

_ZN4absl12lts_2026010718container_internal27SanitizerPoisonMemoryRegionEPKvm:
  240|  40.3M|inline void SanitizerPoisonMemoryRegion(const void* m, size_t s) {
  241|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  242|       |  ASAN_POISON_MEMORY_REGION(m, s);
  243|       |#endif
  244|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  245|       |  __msan_poison(m, s);
  246|       |#endif
  247|  40.3M|  (void)m;
  248|  40.3M|  (void)s;
  249|  40.3M|}
_ZN4absl12lts_2026010718container_internal29SanitizerUnpoisonMemoryRegionEPKvm:
  251|  66.8M|inline void SanitizerUnpoisonMemoryRegion(const void* m, size_t s) {
  252|       |#ifdef ABSL_HAVE_ADDRESS_SANITIZER
  253|       |  ASAN_UNPOISON_MEMORY_REGION(m, s);
  254|       |#endif
  255|       |#ifdef ABSL_HAVE_MEMORY_SANITIZER
  256|       |  __msan_unpoison(m, s);
  257|       |#endif
  258|  66.8M|  (void)m;
  259|  66.8M|  (void)s;
  260|  66.8M|}
_ZN4absl12lts_2026010718container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKNS3_17basic_string_viewIcNS3_11char_traitsIcEEEEiEEEESB_EEDav:
   81|  1.49k|constexpr auto IsDestructionTrivial() {
   82|  1.49k|  constexpr bool result =
   83|  1.49k|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [True: 0, Folded]
  ------------------
   84|      0|      std::is_same<typename absl::allocator_traits<
  ------------------
  |  Branch (84:7): [True: 0, Folded]
  ------------------
   85|      0|                       Allocator>::template rebind_alloc<char>,
   86|      0|                   std::allocator<char>>::value;
   87|  1.49k|  return std::integral_constant<bool, result>();
   88|  1.49k|}
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE7destroyINS3_9allocatorINS3_4pairIKS7_iEEEEEEDaPT_PNS1_13map_slot_typeIS7_iEE:
  431|  1.49k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|  1.49k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 1.49k, Folded]
  ------------------
  433|  1.49k|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|  1.49k|    } else {
  435|      0|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|  1.49k|    return IsDestructionTrivial<Allocator, value_type>();
  438|  1.49k|  }
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_8StringEqEEEJRNS4_4pairIKSA_hEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|     11|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|     11|  return memory_internal::DecomposePairImpl(
  228|     11|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|     11|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS1_8StringEqEEERKSB_NS5_5tupleIJRKhEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS5_4pairISO_SP_EE:
  158|     11|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|     11|  const auto& key = std::get<0>(p.first);
  160|     11|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|     11|                            std::move(p.second));
  162|     11|}
_ZNK4absl12lts_2026010718container_internal12EqualElementINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS1_8StringEqEEclIS9_JRKNS3_21piecewise_construct_tENS3_5tupleIJRKS9_EEENSG_IJRKhEEEEEEbRKT_DpOT0_:
  529|     11|  bool operator()(const K2& lhs, Args&&...) const {
  530|     11|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|     11|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|     11|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE:
  207|  15.8k|    const std::pair<F, S>& p) {
  208|  15.8k|  return PairArgs(p.first, p.second);
  209|  15.8k|}
_ZN4absl12lts_2026010718container_internal8PairArgsIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKhEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_:
  201|  15.8k|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  15.8k|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  15.8k|          std::forward_as_tuple(std::forward<S>(s))};
  204|  15.8k|}
_ZN4absl12lts_2026010718container_internal23TypeErasedApplyToSlotFnINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEEmPKvPvm:
  542|      1|size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
  543|      1|  const auto* f = static_cast<const Fn*>(fn);
  544|      1|  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
  545|      1|}
_ZN4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEC2ERKS3_m:
  495|  7.35M|  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJEEEmRKT_DpOT0_:
  498|    256|  size_t operator()(const K& key, Args&&...) const {
  499|    256|    if constexpr (kIsDefault) {
  500|       |      // TODO(b/384509507): resolve `no header providing
  501|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  502|       |      // Maybe we should make "internal/hash.h" be a separate library.
  503|    256|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|    256|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|    256|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE8transferINS7_INS3_4pairIKS9_hEEEEEEDaPT_PNS1_13map_slot_typeIS9_hEESK_:
  442|    445|                       slot_type* old_slot) {
  443|       |    // This should really just be
  444|       |    // typename absl::is_trivially_relocatable<value_type>::type()
  445|       |    // but std::pair is not trivially copyable in C++23 in some standard
  446|       |    // library versions.
  447|       |    // See https://github.com/llvm/llvm-project/pull/95444 for instance.
  448|    445|    auto is_relocatable = typename std::conjunction<
  449|    445|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|    445|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|    445|        type();
  452|       |
  453|    445|    emplace(new_slot);
  454|    445|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [Folded, False: 445]
  ------------------
  455|       |      // TODO(b/247130232,b/251814870): remove casts after fixing warnings.
  456|      0|      std::memcpy(static_cast<void*>(std::launder(&new_slot->value)),
  457|      0|                  static_cast<const void*>(&old_slot->value),
  458|      0|                  sizeof(value_type));
  459|      0|      return is_relocatable;
  460|      0|    }
  461|       |
  462|    445|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 445, Folded]
  ------------------
  463|    445|      absl::allocator_traits<Allocator>::construct(
  464|    445|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|    445|    } else {
  466|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                   std::move(old_slot->value));
  468|      0|    }
  469|    445|    destroy(alloc, old_slot);
  470|    445|    return is_relocatable;
  471|    445|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE7emplaceEPNS1_13map_slot_typeIS9_hEE:
  368|    701|  static void emplace(slot_type* slot) {
  369|       |    // The construction of union doesn't do anything at runtime but it allows us
  370|       |    // to access its members without violating aliasing rules.
  371|    701|    new (slot) slot_type;
  372|    701|  }
_ZN4absl12lts_2026010718container_internal13map_slot_typeINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhEC2Ev:
  349|    701|  map_slot_type() {}
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE7destroyINS7_INS3_4pairIKS9_hEEEEEEDaPT_PNS1_13map_slot_typeIS9_hEE:
  431|    445|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|    445|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 445, Folded]
  ------------------
  433|    445|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|    445|    } else {
  435|      0|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|    445|    return IsDestructionTrivial<Allocator, value_type>();
  438|    445|  }
_ZN4absl12lts_2026010718container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKNS3_12basic_stringIcNS3_11char_traitsIcEENS4_IcEEEEhEEEESC_EEDav:
   81|    445|constexpr auto IsDestructionTrivial() {
   82|    445|  constexpr bool result =
   83|    445|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [Folded, False: 445]
  ------------------
   84|      0|      std::is_same<typename absl::allocator_traits<
  ------------------
  |  Branch (84:7): [True: 0, Folded]
  ------------------
   85|      0|                       Allocator>::template rebind_alloc<char>,
   86|      0|                   std::allocator<char>>::value;
   87|    445|  return std::integral_constant<bool, result>();
   88|    445|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_11HashElementINS1_10StringHashELb1EEEJRNSt3__14pairIKNS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEhEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|    434|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|    434|  return memory_internal::DecomposePairImpl(
  228|    434|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|    434|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS1_10StringHashELb1EEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENS7_5tupleIJRKhEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS7_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS7_4pairISO_SP_EE:
  158|    434|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|    434|  const auto& key = std::get<0>(p.first);
  160|    434|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|    434|                            std::move(p.second));
  162|    434|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSG_IJRKhEEEEEEmRKT_DpOT0_:
  498|    434|  size_t operator()(const K& key, Args&&...) const {
  499|    434|    if constexpr (kIsDefault) {
  500|       |      // TODO(b/384509507): resolve `no header providing
  501|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  502|       |      // Maybe we should make "internal/hash.h" be a separate library.
  503|    434|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|    434|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|    434|  }
_ZN4absl12lts_2026010718container_internal7HashKeyINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEC2ERKS3_RKSA_:
  515|      2|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026010718container_internal7HashKeyINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEclEm:
  517|      1|  size_t operator()(size_t seed) const {
  518|      1|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|      1|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE9constructINS7_INS3_4pairIKS9_hEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOS9_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_hEEDpOT0_:
  397|    256|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|    256|    emplace(slot);
  399|    256|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 256, Folded]
  ------------------
  400|    256|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|    256|                                                   std::forward<Args>(args)...);
  402|    256|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|    256|  }
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS1_8StringEqEEEJRNS4_4pairIKS8_iEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSF_DpOSG_:
  226|  5.61M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  5.61M|  return memory_internal::DecomposePairImpl(
  228|  5.61M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  5.61M|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_8StringEqEEERKS9_NS5_5tupleIJRKiEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSE_IJSJ_EEEEEclsr3stdE7declvalIT1_EEEEOSI_NS5_4pairISM_SN_EE:
  158|  5.61M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  5.61M|  const auto& key = std::get<0>(p.first);
  160|  5.61M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  5.61M|                            std::move(p.second));
  162|  5.61M|}
_ZNK4absl12lts_2026010718container_internal12EqualElementINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_8StringEqEEclIS7_JRKNS3_21piecewise_construct_tENS3_5tupleIJRKS7_EEENSE_IJRKiEEEEEEbRKT_DpOT0_:
  529|  5.61M|  bool operator()(const K2& lhs, Args&&...) const {
  530|  5.61M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  5.61M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  5.61M|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiEENS3_4pairINS3_5tupleIJRKT_EEENSA_IJRKT0_EEEEERKNS9_ISB_SF_EE:
  207|  5.66M|    const std::pair<F, S>& p) {
  208|  5.66M|  return PairArgs(p.first, p.second);
  209|  5.66M|}
_ZN4absl12lts_2026010718container_internal8PairArgsIRKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERKiEENS3_4pairINS3_5tupleIJOT_EEENSD_IJOT0_EEEEESF_SI_:
  201|  5.66M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  5.66M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  5.66M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  5.66M|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEEmRKT_DpOT0_:
  498|  7.35M|  size_t operator()(const K& key, Args&&...) const {
  499|  7.35M|    if constexpr (kIsDefault) {
  500|       |      // TODO(b/384509507): resolve `no header providing
  501|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  502|       |      // Maybe we should make "internal/hash.h" be a separate library.
  503|  7.35M|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|  7.35M|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|  7.35M|  }
_ZN4absl12lts_2026010718container_internal21SanitizerPoisonObjectINS1_13map_slot_typeINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEEEvPKT_:
  263|    355|inline void SanitizerPoisonObject(const T* object) {
  264|    355|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  265|    355|}
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE7emplaceEPNS1_13map_slot_typeIS7_iEE:
  368|  43.9k|  static void emplace(slot_type* slot) {
  369|       |    // The construction of union doesn't do anything at runtime but it allows us
  370|       |    // to access its members without violating aliasing rules.
  371|  43.9k|    new (slot) slot_type;
  372|  43.9k|  }
_ZN4absl12lts_2026010718container_internal13map_slot_typeINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiEC2Ev:
  349|  43.9k|  map_slot_type() {}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEiEEJEE19EmplaceDecomposableEJRKNS5_4pairIKS9_iEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSI_DpOSJ_:
  226|  43.9k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  43.9k|  return memory_internal::DecomposePairImpl(
  228|  43.9k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  43.9k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEiEEJEE19EmplaceDecomposableERKSA_NS6_5tupleIJRKiEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS6_4pairISO_SP_EE:
  158|  43.9k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  43.9k|  const auto& key = std::get<0>(p.first);
  160|  43.9k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  43.9k|                            std::move(p.second));
  162|  43.9k|}
_ZN4absl12lts_2026010718container_internal7HashKeyINS1_10StringHashENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEELb1EEC2ERKS3_RKS8_:
  515|  1.49k|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE9constructINS3_9allocatorINS3_4pairIKS7_iEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSC_EEENSI_IJRKiEEEEEEvPT_PNS1_13map_slot_typeIS7_iEEDpOT0_:
  397|  43.9k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|  43.9k|    emplace(slot);
  399|  43.9k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 43.9k, Folded]
  ------------------
  400|  43.9k|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|  43.9k|                                                   std::forward<Args>(args)...);
  402|  43.9k|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|  43.9k|  }
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS1_8StringEqEEEJRNS4_4pairIKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEhEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  226|  15.3k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  15.3k|  return memory_internal::DecomposePairImpl(
  228|  15.3k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  15.3k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_8StringEqEEERKNS5_12basic_stringIcS8_NS5_9allocatorIcEEEENS5_5tupleIJRKhEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSI_IJSN_EEEEEclsr3stdE7declvalIT1_EEEEOSM_NS5_4pairISQ_SR_EE:
  158|  15.3k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  15.3k|  const auto& key = std::get<0>(p.first);
  160|  15.3k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  15.3k|                            std::move(p.second));
  162|  15.3k|}
_ZNK4absl12lts_2026010718container_internal12EqualElementINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_8StringEqEEclINS3_12basic_stringIcS6_NS3_9allocatorIcEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKSE_EEENSI_IJRKhEEEEEEbRKT_DpOT0_:
  529|  15.3k|  bool operator()(const K2& lhs, Args&&...) const {
  530|  15.3k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  15.3k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  15.3k|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisENS1_6HashEqIS9_vE2EqEEEJRNSt3__14pairIKS9_PS7_EEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSK_DpOSL_:
  226|  4.77M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  4.77M|  return memory_internal::DecomposePairImpl(
  228|  4.77M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  4.77M|}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisENS1_6HashEqISA_vE2EqEEERKSA_NSt3__15tupleIJRKPS8_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSH_19piecewise_constructEEclsr3stdE7declvalINSI_IJSO_EEEEEclsr3stdE7declvalIT1_EEEEOSN_NSH_4pairISR_SS_EE:
  158|  4.77M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  4.77M|  const auto& key = std::get<0>(p.first);
  160|  4.77M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  4.77M|                            std::move(p.second));
  162|  4.77M|}
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12EqualElementIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisENS1_6HashEqIS8_vE2EqEEclIS8_JRKNSt3__121piecewise_construct_tENSE_5tupleIJRKS8_EEENSI_IJRKPS6_EEEEEEbRKT_DpOT0_:
  529|  4.77M|  bool operator()(const K2& lhs, Args&&...) const {
  530|  4.77M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  4.77M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  4.77M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal8PairArgsIKPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_EENSt3__14pairINSB_5tupleIJRKT_EEENSD_IJRKT0_EEEEERKNSC_ISE_SI_EE:
  207|  45.1M|    const std::pair<F, S>& p) {
  208|  45.1M|  return PairArgs(p.first, p.second);
  209|  45.1M|}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal8PairArgsIRKPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisERKPS6_EENSt3__14pairINSE_5tupleIJOT_EEENSG_IJOT0_EEEEESI_SL_:
  201|  45.1M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  45.1M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  45.1M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  45.1M|}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal11HashElementINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashELb0EEC2ERKSB_m:
  495|  93.1M|  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal11HashElementINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashELb0EEclIS9_JEEEmRKT_DpOT0_:
  498|  52.8M|  size_t operator()(const K& key, Args&&...) const {
  499|       |    if constexpr (kIsDefault) {
  500|       |      // TODO(b/384509507): resolve `no header providing
  501|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  502|       |      // Maybe we should make "internal/hash.h" be a separate library.
  503|       |      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|       |    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|  52.8M|    return hash(key) ^ seed;
  507|  52.8M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS8_EEJEE19EmplaceDecomposableEJNSt3__14pairISA_SB_EEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSI_DpOSJ_:
  226|  26.4M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  26.4M|  return memory_internal::DecomposePairImpl(
  228|  26.4M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  26.4M|}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS9_EEJEE19EmplaceDecomposableEOSB_NSt3__15tupleIJOSC_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSH_19piecewise_constructEEclsr3stdE7declvalINSI_IJSM_EEEEEclsr3stdE7declvalIT1_EEEEOSL_NSH_4pairISP_SQ_EE:
  158|  26.4M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  26.4M|  const auto& key = std::get<0>(p.first);
  160|  26.4M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  26.4M|                            std::move(p.second));
  162|  26.4M|}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal23TypeErasedApplyToSlotFnINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashES9_Lb0EEEmPKvPvm:
  542|    365|size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
  543|    365|  const auto* f = static_cast<const Fn*>(fn);
  544|    365|  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
  545|    365|}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_11HashElementINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashELb0EEEJRNSt3__14pairIKSA_PS8_EEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSK_DpOSL_:
  226|  40.3M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  40.3M|  return memory_internal::DecomposePairImpl(
  228|  40.3M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  40.3M|}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashELb0EEERKSB_NSt3__15tupleIJRKPS9_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSH_19piecewise_constructEEclsr3stdE7declvalINSI_IJSO_EEEEEclsr3stdE7declvalIT1_EEEEOSN_NSH_4pairISR_SS_EE:
  158|  40.3M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  40.3M|  const auto& key = std::get<0>(p.first);
  160|  40.3M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  40.3M|                            std::move(p.second));
  162|  40.3M|}
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal11HashElementINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashELb0EEclIS9_JRKNSt3__121piecewise_construct_tENSE_5tupleIJRKS9_EEENSI_IJRKPS7_EEEEEEmRKT_DpOT0_:
  498|  40.3M|  size_t operator()(const K& key, Args&&...) const {
  499|       |    if constexpr (kIsDefault) {
  500|       |      // TODO(b/384509507): resolve `no header providing
  501|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  502|       |      // Maybe we should make "internal/hash.h" be a separate library.
  503|       |      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|       |    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|  40.3M|    return hash(key) ^ seed;
  507|  40.3M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal15map_slot_policyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_E8transferINSt3__19allocatorINSC_4pairIKS8_S9_EEEEEEDaPT_PNS1_13map_slot_typeIS8_S9_EESM_:
  442|  40.3M|                       slot_type* old_slot) {
  443|       |    // This should really just be
  444|       |    // typename absl::is_trivially_relocatable<value_type>::type()
  445|       |    // but std::pair is not trivially copyable in C++23 in some standard
  446|       |    // library versions.
  447|       |    // See https://github.com/llvm/llvm-project/pull/95444 for instance.
  448|  40.3M|    auto is_relocatable = typename std::conjunction<
  449|  40.3M|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|  40.3M|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|  40.3M|        type();
  452|       |
  453|  40.3M|    emplace(new_slot);
  454|  40.3M|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [True: 40.3M, Folded]
  ------------------
  455|       |      // TODO(b/247130232,b/251814870): remove casts after fixing warnings.
  456|  40.3M|      std::memcpy(static_cast<void*>(std::launder(&new_slot->value)),
  457|  40.3M|                  static_cast<const void*>(&old_slot->value),
  458|  40.3M|                  sizeof(value_type));
  459|  40.3M|      return is_relocatable;
  460|  40.3M|    }
  461|       |
  462|      0|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 0, Folded]
  ------------------
  463|      0|      absl::allocator_traits<Allocator>::construct(
  464|      0|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|      0|    } else {
  466|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                   std::move(old_slot->value));
  468|      0|    }
  469|      0|    destroy(alloc, old_slot);
  470|      0|    return is_relocatable;
  471|  40.3M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal15map_slot_policyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_E7emplaceEPNS1_13map_slot_typeIS8_S9_EE:
  368|  66.7M|  static void emplace(slot_type* slot) {
  369|       |    // The construction of union doesn't do anything at runtime but it allows us
  370|       |    // to access its members without violating aliasing rules.
  371|  66.7M|    new (slot) slot_type;
  372|  66.7M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal13map_slot_typeIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_EC2Ev:
  349|  66.7M|  map_slot_type() {}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal7HashKeyINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashES9_Lb0EEC2ERKSB_RKS9_:
  515|    365|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal7HashKeyINS1_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashES9_Lb0EEclEm:
  517|    365|  size_t operator()(size_t seed) const {
  518|    365|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|    365|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal15map_slot_policyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_E9constructINSt3__19allocatorINSC_4pairIKS8_S9_EEEEJRKNSC_21piecewise_construct_tENSC_5tupleIJOS8_EEENSL_IJOS9_EEEEEEvPT_PNS1_13map_slot_typeIS8_S9_EEDpOT0_:
  397|  26.4M|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|  26.4M|    emplace(slot);
  399|  26.4M|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 26.4M, Folded]
  ------------------
  400|  26.4M|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|  26.4M|                                                   std::forward<Args>(args)...);
  402|  26.4M|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|  26.4M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal8PairArgsIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_EENSt3__14pairINSA_5tupleIJOT_EEENSC_IJOT0_EEEEEONSB_ISD_SG_EE:
  211|  26.4M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(std::pair<F, S>&& p) {
  212|  26.4M|  return PairArgs(std::forward<F>(p.first), std::forward<S>(p.second));
  213|  26.4M|}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal8PairArgsIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS6_EENSt3__14pairINSA_5tupleIJOT_EEENSC_IJOT0_EEEEESE_SH_:
  201|  26.4M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  26.4M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  26.4M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  26.4M|}

_ZNK4absl12lts_2026010718container_internal10StringHash14hash_with_seedENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEm:
   86|  7.35M|  size_t hash_with_seed(absl::string_view v, size_t seed) const {
   87|  7.35M|    return absl::hash_internal::HashWithSeed().hash(
   88|  7.35M|        absl::Hash<absl::string_view>{}, v, seed);
   89|  7.35M|  }
_ZNK4absl12lts_2026010718container_internal8StringEqclENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEES7_:
   98|  5.63M|  bool operator()(absl::string_view lhs, absl::string_view rhs) const {
   99|  5.63M|    return lhs == rhs;
  100|  5.63M|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE2EqclIS8_S8_EEbRKT_RKT0_:
  176|  4.77M|    bool operator()(const A& a, const B& b) const {
  177|  4.77M|      return HashEq::ToPtr(a) == HashEq::ToPtr(b);
  178|  4.77M|    }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE5ToPtrES8_:
  182|   102M|  static const T* ToPtr(const T* ptr) { return ptr; }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashclIS8_EEmRKT_:
  169|  93.1M|    size_t operator()(const U& ptr) const {
  170|  93.1M|      return absl::Hash<const T*>{}(HashEq::ToPtr(ptr));
  171|  93.1M|    }

_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE5applyINS1_12EqualElementISA_NS1_8StringEqEEEJRNS4_4pairIKSA_hEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|     11|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|     11|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|     11|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS4_4pairIKSA_hEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|    434|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|    434|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|    434|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE5applyINS1_12EqualElementIS8_NS1_8StringEqEEEJRNS4_4pairIKS8_iEEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSK_DpOSL_:
  130|  5.61M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  5.61M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  5.61M|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE5applyINS1_12raw_hash_setIS9_JEE19EmplaceDecomposableEJRKNS4_4pairIKS8_iEEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSL_DpOSM_:
  130|  43.9k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  43.9k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  43.9k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE5applyINS1_12EqualElementINS4_17basic_string_viewIcS7_EENS1_8StringEqEEEJRNS4_4pairIKSA_hEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSO_DpOSP_:
  130|  15.3k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  15.3k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  15.3k|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEvE5applyINS1_12EqualElementIS9_NS1_6HashEqIS9_vE2EqEEEJRNSt3__14pairIKS9_SA_EEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSP_DpOSQ_:
  130|  4.77M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  4.77M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  4.77M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEvE5applyINS1_12raw_hash_setISB_JEE19EmplaceDecomposableEJNSt3__14pairIS9_SA_EEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSL_DpOSM_:
  130|  26.4M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  26.4M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  26.4M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEvE5applyINS1_11HashElementINS1_6HashEqIS9_vE4HashELb0EEEJRNSt3__14pairIKS9_SA_EEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSP_DpOSQ_:
  130|  40.3M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  40.3M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  40.3M|  }

_ZN4absl12lts_2026010718container_internal13GroupSse2ImplC2EPKNS1_6ctrl_tE:
  280|  71.1M|  explicit GroupSse2Impl(const ctrl_t* pos) {
  281|  71.1M|    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
  282|  71.1M|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl5MatchEh:
  285|  66.4M|  BitMaskType Match(h2_t hash) const {
  286|  66.4M|    auto match = _mm_set1_epi8(static_cast<char>(hash));
  287|  66.4M|    return BitMaskType(
  288|  66.4M|        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  289|  66.4M|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl9MaskEmptyEv:
  292|  66.0M|  NonIterableBitMaskType MaskEmpty() const {
  293|       |#ifdef ABSL_INTERNAL_HAVE_SSSE3
  294|       |    // This only works because ctrl_t::kEmpty is -128.
  295|       |    return NonIterableBitMaskType(
  296|       |        static_cast<uint16_t>(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl))));
  297|       |#else
  298|  66.0M|    auto match = _mm_set1_epi8(static_cast<char>(ctrl_t::kEmpty));
  299|  66.0M|    return NonIterableBitMaskType(
  300|  66.0M|        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  301|  66.0M|#endif
  302|  66.0M|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl8MaskFullEv:
  307|  2.88M|  BitMaskType MaskFull() const {
  308|  2.88M|    return BitMaskType(static_cast<uint16_t>(_mm_movemask_epi8(ctrl) ^ 0xffff));
  309|  2.88M|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl11MaskNonFullEv:
  314|  1.80M|  auto MaskNonFull() const {
  315|  1.80M|    return BitMaskType(static_cast<uint16_t>(_mm_movemask_epi8(ctrl)));
  316|  1.80M|  }
_ZN4absl12lts_2026010718container_internal16IsEmptyOrDeletedENS1_6ctrl_tE:
  228|  43.6k|inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
_ZN4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EEC2Et:
  133|   140M|  explicit BitMask(T mask) : Base(mask) {
  134|   140M|    if (Shift == 3 && !NullifyBitsOnIteration) {
  ------------------
  |  Branch (134:9): [Folded, False: 140M]
  |  Branch (134:23): [True: 0, Folded]
  ------------------
  135|       |      ABSL_SWISSTABLE_ASSERT(this->mask_ == (this->mask_ & kMsbs8Bytes));
  ------------------
  |  |   58|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  136|      0|    }
  137|   140M|  }
_ZN4absl12lts_2026010718container_internal18NonIterableBitMaskItLi16ELi0EEC2Et:
   85|   206M|  explicit NonIterableBitMask(T mask) : mask_(mask) {}
_ZNK4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EE5beginEv:
  153|  69.3M|  BitMask begin() const { return *this; }
_ZNK4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EE3endEv:
  154|  69.3M|  BitMask end() const { return BitMask(0); }
_ZN4absl12lts_2026010718container_internalneERKNS1_7BitMaskItLi16ELi0ELb0EEES5_:
  160|   114M|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  161|   114M|    return a.mask_ != b.mask_;
  162|   114M|  }
_ZNK4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EEdeEv:
  151|  45.5M|  uint32_t operator*() const { return Base::LowestBitSet(); }
_ZNK4absl12lts_2026010718container_internal18NonIterableBitMaskItLi16ELi0EE12LowestBitSetEv:
   90|  73.8M|  uint32_t LowestBitSet() const {
   91|  73.8M|    return container_internal::TrailingZeros(mask_) >> Shift;
   92|  73.8M|  }
_ZN4absl12lts_2026010718container_internal13TrailingZerosItEEjT_:
   63|  73.8M|uint32_t TrailingZeros(T x) {
   64|  73.8M|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  270|  73.8M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
   65|  73.8M|  return static_cast<uint32_t>(countr_zero(x));
   66|  73.8M|}
_ZNK4absl12lts_2026010718container_internal18NonIterableBitMaskItLi16ELi0EEcvbEv:
   87|  67.9M|  explicit operator bool() const { return this->mask_ != 0; }
_ZN4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EEppEv:
  143|  45.1M|  BitMask& operator++() {
  144|  45.1M|    if (Shift == 3 && NullifyBitsOnIteration) {
  ------------------
  |  Branch (144:9): [Folded, False: 45.1M]
  |  Branch (144:23): [Folded, False: 0]
  ------------------
  145|      0|      this->mask_ &= kMsbs8Bytes;
  146|      0|    }
  147|  45.1M|    this->mask_ &= (this->mask_ - 1);
  148|  45.1M|    return *this;
  149|  45.1M|  }

_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle10UnregisterEv:
  219|  6.36k|  inline void Unregister() {}
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle15RecordInsertHitEv:
  228|     10|  inline void RecordInsertHit() {}
_ZN4absl12lts_2026010718container_internal21ShouldSampleNextTableEv:
  243|  6.36k|inline bool ShouldSampleNextTable() {
  244|       |#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
  245|       |  if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0)) {
  246|       |    return false;
  247|       |  }
  248|       |  return true;
  249|       |#else
  250|  6.36k|  return false;
  251|  6.36k|#endif  // ABSL_INTERNAL_HASHTABLEZ_SAMPLE
  252|  6.36k|}

_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEEC2Ev:
  107|      1|  raw_hash_map() {}
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEEixISA_SB_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS4_4pairIKSA_hEEEEPT_RSJ_EclL_ZNS4_7declvalB8ne220000IRSI_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEEEEEOSJ_:
  313|    256|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  314|       |    // It is safe to use unchecked_deref here because try_emplace
  315|       |    // will always return an iterator pointing to a valid item in the table,
  316|       |    // since it inserts if nothing is found for the given key.
  317|    256|    return Policy::value(&this->unchecked_deref(
  318|    256|        try_emplace(std::forward<key_arg<K>>(key)).first));
  319|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE11try_emplaceISA_Li0EJETnNS4_9enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setISB_JEE14const_iteratorEEE5valueEiE4typeELi0EEENS4_4pairINSH_8iteratorEbEEOSF_DpOT1_:
  223|    256|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  224|    256|    return try_emplace_impl(std::forward<key_arg<K>>(k),
  225|    256|                            std::forward<Args>(args)...);
  226|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE16try_emplace_implISA_JEEENS4_4pairINS1_12raw_hash_setISB_JEE8iteratorEbEEOT_DpOT0_:
  367|    256|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  368|    256|    auto res = this->find_or_prepare_insert(k);
  369|    256|    if (res.second) {
  ------------------
  |  Branch (369:9): [True: 256, False: 0]
  ------------------
  370|    256|      this->emplace_at(res.first, std::piecewise_construct,
  371|    256|                       std::forward_as_tuple(std::forward<K>(k)),
  372|    256|                       std::forward_as_tuple(std::forward<Args>(args)...));
  373|    256|    }
  374|    256|    return res;
  375|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEEC2Ev:
  107|  6.35k|  raw_hash_map() {}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEEC2Ev:
  107|    365|  raw_hash_map() {}
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS4_4pairIS8_S8_EEEEJEEC2Ev:
  107|    376|  raw_hash_map() {}

_ZNK4absl12lts_2026010718container_internal12PerTableSeed4seedEv:
  445|   100M|  size_t seed() const {
  446|       |    // We use a sign-extended load to ensure high bits are non-zero.
  447|   100M|    int16_t seed_signed = absl::bit_cast<int16_t>(seed_);
  448|   100M|    auto seed_sign_extended =
  449|   100M|        static_cast<std::make_signed_t<size_t>>(seed_signed);
  450|   100M|    return absl::bit_cast<size_t>(seed_sign_extended);
  451|   100M|  }
_ZN4absl12lts_2026010718container_internal12PerTableSeedC2Et:
  455|   100M|  explicit PerTableSeed(uint16_t seed) : seed_(seed) {
  456|       |    ABSL_SWISSTABLE_ASSERT((seed & kSignBit) != 0 || seed == 0);
  ------------------
  |  |  248|   100M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  457|   100M|  }
_ZN4absl12lts_2026010718container_internal13HashtableSizeC2ENS1_19no_seed_empty_tag_tE:
  472|  7.10k|  explicit HashtableSize(no_seed_empty_tag_t) : data_(0) {}
_ZN4absl12lts_2026010718container_internal13HashtableSizeC2ENS1_14full_soo_tag_tE:
  473|    365|  explicit HashtableSize(full_soo_tag_t) : data_(kSizeOneNoMetadata) {}
_ZNK4absl12lts_2026010718container_internal13HashtableSize4sizeEv:
  476|  5.45M|  size_t size() const { return static_cast<size_t>(data_ >> kSizeShift); }
_ZN4absl12lts_2026010718container_internal13HashtableSize14decrement_sizeEv:
  481|    355|  void decrement_size() { data_ -= kSizeOneNoMetadata; }
_ZNK4absl12lts_2026010718container_internal13HashtableSize4seedEv:
  487|   100M|  PerTableSeed seed() const {
  488|   100M|    return PerTableSeed(static_cast<size_t>(data_) & kSeedMask);
  489|   100M|  }
_ZNK4absl12lts_2026010718container_internal13HashtableSize9has_infozEv:
  502|  26.4M|  bool has_infoz() const {
  503|  26.4M|    return ABSL_PREDICT_FALSE((data_ & kHasInfozMask) != 0);
  ------------------
  |  |  189|  26.4M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:49): [Folded, False: 26.4M]
  |  |  |  Branch (189:58): [True: 0, False: 26.4M]
  |  |  ------------------
  ------------------
  504|  26.4M|  }
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled19set_reserved_growthEm:
  631|  7.98k|  void set_reserved_growth(size_t) {}
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled20set_reservation_sizeEm:
  633|  13.9k|  void set_reservation_size(size_t) {}
_ZNK4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled14generation_ptrEv:
  636|   104M|  GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2026010718container_internal37HashSetIteratorGenerationInfoDisabledC2EPKh:
  660|   104M|  explicit HashSetIteratorGenerationInfoDisabled(const GenerationType*) {}
_ZNK4absl12lts_2026010718container_internal37HashSetIteratorGenerationInfoDisabled10generationEv:
  662|  79.3M|  GenerationType generation() const { return 0; }
_ZNK4absl12lts_2026010718container_internal37HashSetIteratorGenerationInfoDisabled14generation_ptrEv:
  664|   157M|  const GenerationType* generation_ptr() const { return nullptr; }
_ZNK4absl12lts_2026010718container_internal9HeapOrSoo7controlEv:
  880|   226M|  MaybeInitializedPtr<ctrl_t> control() const {
  881|   226M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.control);
  ------------------
  |  |  488|   226M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  882|   226M|  }
_ZNK4absl12lts_2026010718container_internal9HeapOrSoo10slot_arrayEv:
  886|   130M|  MaybeInitializedPtr<void> slot_array() const {
  887|   130M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.slot_array);
  ------------------
  |  |  488|   130M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  888|   130M|  }
_ZN4absl12lts_2026010718container_internal9HeapOrSoo12get_soo_dataEv:
  889|  1.82k|  void* get_soo_data() {
  890|  1.82k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(soo_data);
  ------------------
  |  |  488|  1.82k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  891|  1.82k|  }
_ZN4absl12lts_2026010718container_internal12CommonFieldsC2ENS1_9soo_tag_tE:
  915|    365|      : capacity_(SooCapacity()), size_(no_seed_empty_tag_t{}) {}
_ZN4absl12lts_2026010718container_internal12CommonFieldsC2ENS1_13non_soo_tag_tE:
  919|  6.73k|      : capacity_(0), size_(no_seed_empty_tag_t{}) {}
_ZN4absl12lts_2026010718container_internal12CommonFields8soo_dataEv:
  946|  1.82k|  void* soo_data() { return heap_or_soo_.get_soo_data(); }
_ZNK4absl12lts_2026010718container_internal12CommonFields7controlEv:
  948|   226M|  ctrl_t* control() const {
  949|   226M|    ABSL_SWISSTABLE_ASSERT(capacity() > 0);
  ------------------
  |  |  248|   226M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  950|       |    // Assume that the control bytes don't alias `this`.
  951|   226M|    ctrl_t* ctrl = heap_or_soo_.control().get();
  952|   226M|    [[maybe_unused]] size_t num_control_bytes = NumControlBytes(capacity());
  953|   226M|    ABSL_ASSUME(reinterpret_cast<uintptr_t>(ctrl + num_control_bytes) <=
  ------------------
  |  |  270|   232M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (270:44): [True: 221M, False: 5.47M]
  |  |  |  Branch (270:44): [True: 5.47M, False: 0]
  |  |  ------------------
  ------------------
  954|   226M|                    reinterpret_cast<uintptr_t>(this) ||
  955|   226M|                reinterpret_cast<uintptr_t>(this + 1) <=
  956|   226M|                    reinterpret_cast<uintptr_t>(ctrl));
  957|   226M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(ctrl);
  ------------------
  |  |  488|   226M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  958|   226M|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields10slot_arrayEv:
  963|   130M|  void* slot_array() const { return heap_or_soo_.slot_array().get(); }
_ZNK4absl12lts_2026010718container_internal12CommonFields11slots_unionEv:
  964|  1.46k|  MaybeInitializedPtr<void> slots_union() const {
  965|  1.46k|    return heap_or_soo_.slot_array();
  966|  1.46k|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields4sizeEv:
  970|  5.45M|  size_t size() const { return size_.size(); }
_ZN4absl12lts_2026010718container_internal12CommonFields12set_full_sooEv:
  977|    365|  void set_full_soo() {
  978|    365|    AssertInSooMode();
  979|    365|    size_ = HashtableSize(full_soo_tag_t{});
  980|    365|  }
_ZN4absl12lts_2026010718container_internal12CommonFields14decrement_sizeEv:
  989|    355|  void decrement_size() {
  990|       |    ABSL_SWISSTABLE_ASSERT(!empty());
  ------------------
  |  |  248|    355|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  991|    355|    size_.decrement_size();
  992|    355|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields4seedEv:
  996|   100M|  PerTableSeed seed() const { return size_.seed(); }
_ZNK4absl12lts_2026010718container_internal12CommonFields8capacityEv:
 1012|   366M|  size_t capacity() const { return capacity_; }
_ZNK4absl12lts_2026010718container_internal12CommonFields8is_smallEv:
 1019|  65.6M|  bool is_small() const { return IsSmallCapacity(capacity_); }
_ZNK4absl12lts_2026010718container_internal12CommonFields9has_infozEv:
 1035|  26.4M|  bool has_infoz() const { return size_.has_infoz(); }
_ZN4absl12lts_2026010718container_internal12CommonFields5infozEv:
 1050|  26.4M|  HashtablezInfoHandle infoz() {
 1051|  26.4M|    return has_infoz() ? *infoz_ptr() : HashtablezInfoHandle();
  ------------------
  |  Branch (1051:12): [True: 0, False: 26.4M]
  ------------------
 1052|  26.4M|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields15AssertInSooModeEv:
 1119|    365|  void AssertInSooMode() const {
 1120|    365|    ABSL_SWISSTABLE_ASSERT(capacity() == SooCapacity());
  ------------------
  |  |  248|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1121|       |    ABSL_SWISSTABLE_ASSERT(!has_infoz());
  ------------------
  |  |  248|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1122|    365|  }
_ZN4absl12lts_2026010718container_internal10SooControlEv:
  395|   118k|inline ctrl_t* SooControl() {
  396|       |  // Const must be cast away here; no uses of this function will actually write
  397|       |  // to it because it is only used for SOO iterators.
  398|   118k|  return const_cast<ctrl_t*>(kSooControl);
  399|   118k|}
_ZN4absl12lts_2026010718container_internal11SooCapacityEv:
  419|  6.36k|constexpr size_t SooCapacity() { return 1; }
_ZN4absl12lts_2026010718container_internal2H1Em:
  529|   100M|inline size_t H1(size_t hash) { return hash; }
_ZN4absl12lts_2026010718container_internal2H2Em:
  534|   126M|inline h2_t H2(size_t hash) { return hash >> (sizeof(size_t) * 8 - 7); }
_ZN4absl12lts_2026010718container_internal15IsSmallCapacityEm:
  775|   292M|constexpr bool IsSmallCapacity(size_t capacity) { return capacity <= 1; }
_ZN4absl12lts_2026010718container_internal14NumClonedBytesEv:
  782|   279M|constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
_ZN4absl12lts_2026010718container_internal15NumControlBytesEm:
  785|   226M|constexpr size_t NumControlBytes(size_t capacity) {
  786|   226M|  return IsSmallCapacity(capacity) ? 0 : capacity + 1 + NumClonedBytes();
  ------------------
  |  Branch (786:10): [True: 6.37k, False: 226M]
  ------------------
  787|   226M|}
_ZN4absl12lts_2026010718container_internal13ControlOffsetEb:
  791|  22.4k|constexpr size_t ControlOffset(bool has_infoz) {
  792|  22.4k|  return (has_infoz ? sizeof(HashtablezInfoHandle) : 0) + sizeof(GrowthInfo);
  ------------------
  |  Branch (792:11): [True: 0, False: 22.4k]
  ------------------
  793|  22.4k|}
_ZN4absl12lts_2026010718container_internal16PreviousCapacityEm:
 1151|  4.12k|constexpr size_t PreviousCapacity(size_t n) {
 1152|       |  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(n));
  ------------------
  |  |  248|  4.12k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1153|  4.12k|  return n / 2;
 1154|  4.12k|}
_ZN4absl12lts_2026010718container_internal12AssertIsFullEPKNS1_6ctrl_tEhPKhPKc:
 1243|  1.00M|                         const char* operation) {
 1244|  1.00M|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1244:7): [True: 1.00M, Folded]
  ------------------
 1245|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1246|       |  // enabled. To minimize their impact in those builds:
 1247|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1248|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1249|       |  //   the chances that the hot paths will be inlined.
 1250|      0|  if (ABSL_PREDICT_FALSE(ctrl == nullptr)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1251|      0|    ABSL_RAW_LOG(FATAL, "%s called on end() iterator.", operation);
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1252|      0|  }
 1253|      0|  if (ABSL_PREDICT_FALSE(ctrl == DefaultIterControl())) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1254|      0|    ABSL_RAW_LOG(FATAL, "%s called on default-constructed iterator.",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1255|      0|                 operation);
 1256|      0|  }
 1257|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1257:7): [Folded, False: 0]
  ------------------
 1258|      0|    if (ABSL_PREDICT_FALSE(generation != *generation_ptr)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1259|      0|      ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1260|      0|                   "%s called on invalid iterator. The table could have "
 1261|      0|                   "rehashed or moved since this iterator was initialized.",
 1262|      0|                   operation);
 1263|      0|    }
 1264|      0|    if (ABSL_PREDICT_FALSE(!IsFull(*ctrl))) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1265|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1266|      0|          FATAL,
 1267|      0|          "%s called on invalid iterator. The element was likely erased.",
 1268|      0|          operation);
 1269|      0|    }
 1270|      0|  } else {
 1271|      0|    if (ABSL_PREDICT_FALSE(!IsFull(*ctrl))) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1272|       |      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1273|      0|          FATAL,
 1274|      0|          "%s called on invalid iterator. The element might have been erased "
 1275|      0|          "or the table might have rehashed. Consider running with "
 1276|      0|          "--config=asan to diagnose rehashing issues.",
 1277|      0|          operation);
 1278|      0|    }
 1279|      0|  }
 1280|      0|}
_ZN4absl12lts_2026010718container_internal26AssertIsValidForComparisonEPKNS1_6ctrl_tEhPKh:
 1285|  78.3M|                                       const GenerationType* generation_ptr) {
 1286|  78.3M|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1286:7): [True: 78.3M, Folded]
  ------------------
 1287|      0|  const bool ctrl_is_valid_for_comparison =
 1288|      0|      ctrl == nullptr || ctrl == DefaultIterControl() || IsFull(*ctrl);
  ------------------
  |  Branch (1288:7): [True: 0, False: 0]
  |  Branch (1288:26): [True: 0, False: 0]
  |  Branch (1288:58): [True: 0, False: 0]
  ------------------
 1289|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1289:7): [Folded, False: 0]
  ------------------
 1290|      0|    if (ABSL_PREDICT_FALSE(generation != *generation_ptr)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1291|      0|      ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1292|      0|                   "Invalid iterator comparison. The table could have rehashed "
 1293|      0|                   "or moved since this iterator was initialized.");
 1294|      0|    }
 1295|      0|    if (ABSL_PREDICT_FALSE(!ctrl_is_valid_for_comparison)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1296|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1297|      0|          FATAL, "Invalid iterator comparison. The element was likely erased.");
 1298|      0|    }
 1299|      0|  } else {
 1300|      0|    ABSL_HARDENING_ASSERT_SLOW(
  ------------------
  |  |  159|      0|#define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|      0|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1301|      0|        ctrl_is_valid_for_comparison &&
 1302|      0|        "Invalid iterator comparison. The element might have been erased or "
 1303|      0|        "the table might have rehashed. Consider running with --config=asan to "
 1304|      0|        "diagnose rehashing issues.");
 1305|      0|  }
 1306|      0|}
_ZN4absl12lts_2026010718container_internal19AssertSameContainerEPKNS1_6ctrl_tES4_RKPKvS8_PKhSA_:
 1338|  39.1M|                                const GenerationType* generation_ptr_b) {
 1339|  39.1M|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1339:7): [True: 39.1M, Folded]
  ------------------
 1340|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1341|       |  // enabled. To minimize their impact in those builds:
 1342|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1343|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1344|       |  //   the chances that the hot paths will be inlined.
 1345|       |
 1346|       |  // fail_if(is_invalid, message) crashes when is_invalid is true and provides
 1347|       |  // an error message based on `message`.
 1348|      0|  const auto fail_if = [](bool is_invalid, const char* message) {
 1349|      0|    if (ABSL_PREDICT_FALSE(is_invalid)) {
 1350|      0|      ABSL_RAW_LOG(FATAL, "Invalid iterator comparison. %s", message);
 1351|      0|    }
 1352|      0|  };
 1353|       |
 1354|      0|  const bool a_is_default = ctrl_a == DefaultIterControl();
 1355|      0|  const bool b_is_default = ctrl_b == DefaultIterControl();
 1356|      0|  if (a_is_default && b_is_default) return;
  ------------------
  |  Branch (1356:7): [True: 0, False: 0]
  |  Branch (1356:23): [True: 0, False: 0]
  ------------------
 1357|      0|  fail_if(a_is_default != b_is_default,
 1358|      0|          "Comparing default-constructed hashtable iterator with a "
 1359|      0|          "non-default-constructed hashtable iterator.");
 1360|       |
 1361|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1361:7): [Folded, False: 0]
  ------------------
 1362|      0|    if (ABSL_PREDICT_TRUE(generation_ptr_a == generation_ptr_b)) return;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 0]
  |  |  |  Branch (190:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1363|      0|    const bool a_is_empty = IsEmptyGeneration(generation_ptr_a);
 1364|      0|    const bool b_is_empty = IsEmptyGeneration(generation_ptr_b);
 1365|      0|    fail_if(a_is_empty != b_is_empty,
 1366|      0|            "Comparing an iterator from an empty hashtable with an iterator "
 1367|      0|            "from a non-empty hashtable.");
 1368|      0|    fail_if(a_is_empty && b_is_empty,
  ------------------
  |  Branch (1368:13): [True: 0, False: 0]
  |  Branch (1368:27): [True: 0, False: 0]
  ------------------
 1369|      0|            "Comparing iterators from different empty hashtables.");
 1370|       |
 1371|      0|    const bool a_is_end = ctrl_a == nullptr;
 1372|      0|    const bool b_is_end = ctrl_b == nullptr;
 1373|      0|    fail_if(a_is_end || b_is_end,
  ------------------
  |  Branch (1373:13): [True: 0, False: 0]
  |  Branch (1373:25): [True: 0, False: 0]
  ------------------
 1374|      0|            "Comparing iterator with an end() iterator from a different "
 1375|      0|            "hashtable.");
 1376|      0|    fail_if(true, "Comparing non-end() iterators from different hashtables.");
 1377|      0|  } else {
 1378|      0|    ABSL_HARDENING_ASSERT_SLOW(
  ------------------
  |  |  159|      0|#define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|      0|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1379|      0|        AreItersFromSameContainer(ctrl_a, ctrl_b, slot_a, slot_b) &&
 1380|      0|        "Invalid iterator comparison. The iterators may be from different "
 1381|      0|        "containers or the container might have rehashed or moved. Consider "
 1382|      0|        "running with --config=asan to diagnose issues.");
 1383|      0|  }
 1384|      0|}
_ZN4absl12lts_2026010718container_internal8probe_h1Emm:
 1398|  60.1M|inline probe_seq<Group::kWidth> probe_h1(size_t capacity, size_t h1) {
 1399|  60.1M|  return probe_seq<Group::kWidth>(h1, capacity);
 1400|  60.1M|}
_ZN4absl12lts_2026010718container_internal5probeEmm:
 1401|  60.1M|inline probe_seq<Group::kWidth> probe(size_t capacity, size_t hash) {
 1402|  60.1M|  return probe_h1(capacity, H1(hash));
 1403|  60.1M|}
_ZN4absl12lts_2026010718container_internal5probeERKNS1_12CommonFieldsEm:
 1404|  60.1M|inline probe_seq<Group::kWidth> probe(const CommonFields& common, size_t hash) {
 1405|  60.1M|  return probe(common.capacity(), hash);
 1406|  60.1M|}
_ZNK4absl12lts_2026010718container_internal19MaybeInitializedPtrINS1_6ctrl_tEE3getEv:
  849|   226M|  T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
  ------------------
  |  |  488|   226M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
_ZNK4absl12lts_2026010718container_internal19MaybeInitializedPtrIvE3getEv:
  849|   130M|  T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
  ------------------
  |  |  488|   130M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE10SooEnabledEv:
 1856|  1.26k|  constexpr static bool SooEnabled() {
 1857|  1.26k|    return PolicyTraits::soo_enabled() &&
  ------------------
  |  Branch (1857:12): [True: 0, Folded]
  ------------------
 1858|      0|           sizeof(slot_type) <= sizeof(HeapOrSoo) &&
  ------------------
  |  Branch (1858:12): [Folded, False: 0]
  ------------------
 1859|      0|           alignof(slot_type) <= alignof(HeapOrSoo);
  ------------------
  |  Branch (1859:12): [True: 0, Folded]
  ------------------
 1860|  1.26k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields13CreateDefaultILb0EEES2_v:
  939|  6.73k|  static CommonFields CreateDefault() {
  940|  6.73k|    return kSooEnabled ? CommonFields{soo_tag_t{}}
  ------------------
  |  Branch (940:12): [Folded, False: 6.73k]
  ------------------
  941|  6.73k|                       : CommonFields{non_soo_tag_t{}};
  942|  6.73k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE15destructor_implEv:
 3019|  6.35k|  void destructor_impl() {
 3020|  6.35k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 6.35k]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|  6.35k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 358, False: 6.00k]
  ------------------
 3025|  6.00k|    if (is_small()) {
  ------------------
  |  Branch (3025:9): [True: 1.59k, False: 4.40k]
  ------------------
 3026|  1.59k|      if (!empty()) {
  ------------------
  |  Branch (3026:11): [True: 1.13k, False: 455]
  ------------------
 3027|  1.13k|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|  1.13k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3028|  1.13k|      }
 3029|       |      if constexpr (SooEnabled()) return;
 3030|  4.40k|    } else {
 3031|  4.40k|      destroy_slots();
 3032|  4.40k|    }
 3033|  6.00k|    dealloc();
 3034|  6.00k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE15DefaultCapacityEv:
 1862|  6.35k|  constexpr static size_t DefaultCapacity() {
 1863|  6.35k|    return SooEnabled() ? SooCapacity() : 0;
  ------------------
  |  Branch (1863:12): [Folded, False: 6.35k]
  ------------------
 1864|  6.35k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8capacityEv:
 2331|  26.3k|  size_t capacity() const {
 2332|  26.3k|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|  26.3k|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|  26.3k|        DefaultCapacity();
 2336|  26.3k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|  26.3k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|  26.3k|    return cap;
 2338|  26.3k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6commonEv:
 3431|  54.1M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8is_smallEv:
 1874|  12.7M|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5emptyEv:
 2326|  5.43M|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE4sizeEv:
 2327|  5.43M|  size_t size() const {
 2328|  5.43M|    AssertNotDebugCapacity();
 2329|  5.43M|    return common().size();
 2330|  5.43M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22AssertNotDebugCapacityEv:
 3285|  43.2M|  void AssertNotDebugCapacity() const {
 3286|  43.2M|#ifdef NDEBUG
 3287|  43.2M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 43.2M, Folded]
  ------------------
 3288|  43.2M|      return;
 3289|  43.2M|    }
 3290|      0|#endif
 3291|      0|    if (ABSL_PREDICT_TRUE(capacity() <
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 0]
  |  |  |  Branch (190:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3292|      0|                          InvalidCapacity::kAboveMaxValidCapacity)) {
 3293|      0|      return;
 3294|      0|    }
 3295|      0|    assert(capacity() != InvalidCapacity::kReentrance &&
 3296|      0|           "Reentrant container access during element construction/destruction "
 3297|      0|           "is not allowed.");
 3298|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3299|       |      if (capacity() == InvalidCapacity::kDestroyed) {
 3300|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3301|       |      }
 3302|       |    }
 3303|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3303:9): [Folded, False: 0]
  ------------------
 3304|      0|        ABSL_PREDICT_FALSE(capacity() >= InvalidCapacity::kMovedFrom)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3305|      0|      if (capacity() == InvalidCapacity::kSelfMovedFrom) {
  ------------------
  |  Branch (3305:11): [True: 0, False: 0]
  ------------------
 3306|       |        // If this log triggers, then a hash table was move-assigned to itself
 3307|       |        // and then used again later without being reinitialized.
 3308|      0|        ABSL_RAW_LOG(FATAL, "Use of self-move-assigned hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3309|      0|      }
 3310|      0|      ABSL_RAW_LOG(FATAL, "Use of moved-from hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3311|      0|    }
 3312|      0|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7destroyEPNS1_13map_slot_typeIS8_iEE:
 2935|  1.49k|  inline void destroy(slot_type* slot) {
 2936|  1.49k|    common().RunWithReentrancyGuard([&] {
 2937|  1.49k|      allocator_type alloc(char_alloc_ref());
 2938|  1.49k|      PolicyTraits::destroy(&alloc, slot);
 2939|  1.49k|    });
 2940|  1.49k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6commonEv:
 3430|  32.9M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE14char_alloc_refEv:
 3479|  52.6k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEiEEJEE7destroyEPNS1_13map_slot_typeISA_iEEEUlvE_EEvT_:
 1099|  1.49k|  void RunWithReentrancyGuard(F f) {
 1100|  1.49k|#ifdef NDEBUG
 1101|  1.49k|    f();
 1102|  1.49k|    return;
 1103|      0|#endif
 1104|      0|    const size_t cap = capacity();
 1105|      0|    set_capacity(InvalidCapacity::kReentrance);
 1106|      0|    f();
 1107|      0|    set_capacity(cap);
 1108|      0|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE11single_slotEv:
 3450|  5.32M|  slot_type* single_slot() {
 3451|  5.32M|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  5.32M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|  5.32M|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [Folded, False: 5.32M]
  ------------------
 3453|  5.32M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE10slot_arrayEv:
 3437|  13.4M|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  13.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|  13.4M|    return static_cast<slot_type*>(common().slot_array());
 3440|  13.4M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE13destroy_slotsEv:
 2992|  5.67k|  void destroy_slots() {
 2993|  5.67k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  5.67k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2994|  5.67k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (2994:9): [True: 5.67k, Folded]
  ------------------
 2995|      0|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 2996|      0|      this->destroy(static_cast<slot_type*>(slot));
 2997|      0|    };
 2998|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2999|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3000|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 3001|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3002|       |      common().set_capacity(common_copy.capacity());
 3003|      0|    } else {
 3004|      0|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3005|      0|    }
 3006|      0|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7deallocEv:
 3008|  6.00k|  void dealloc() {
 3009|  6.00k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3010|       |    // Unpoison before returning the memory to the allocator.
 3011|  6.00k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3012|  6.00k|    infoz().Unregister();
 3013|  6.00k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3014|  6.00k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3015|  6.00k|                                      sizeof(slot_type), alignof(slot_type),
 3016|  6.00k|                                      common().has_infoz());
 3017|  6.00k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5infozEv:
 3470|  6.00k|  HashtablezInfoHandle infoz() {
 3471|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  6.00k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3472|  6.00k|    return common().infoz();
 3473|  6.00k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7controlEv:
 3433|  15.0M|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  15.0M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|  15.0M|    return common().control();
 3436|  15.0M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEED2Ev:
 2294|  6.35k|  ~raw_hash_set() {
 2295|  6.35k|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|  6.35k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7destroyEPNS1_13map_slot_typeIS8_iEEENKUlvE_clEv:
 2936|  1.49k|    common().RunWithReentrancyGuard([&] {
 2937|  1.49k|      allocator_type alloc(char_alloc_ref());
 2938|  1.49k|      PolicyTraits::destroy(&alloc, slot);
 2939|  1.49k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEEC2Ev:
 2109|      1|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE15unchecked_derefENSC_8iteratorE:
 3394|    256|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iterator15unchecked_derefEv:
 2039|  15.6k|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE22find_or_prepare_insertISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3358|    256|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|    256|    AssertOnFind(key);
 3360|    256|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 2, False: 254]
  ------------------
 3361|    254|    return find_or_prepare_insert_large(key);
 3362|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE12AssertOnFindISA_EEvRKT_:
 3279|    256|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|    256|    AssertHashEqConsistent(key);
 3281|    256|    AssertNotDebugCapacity();
 3282|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE22AssertHashEqConsistentISA_EEvRKT_:
 3317|    256|  void AssertHashEqConsistent(const K& key) {
 3318|    256|#ifdef NDEBUG
 3319|    256|    return;
 3320|      0|#endif
 3321|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3322|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3322:9): [True: 0, Folded]
  ------------------
 3323|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3323:9): [True: 0, Folded]
  ------------------
 3324|      0|      return;
 3325|      0|    }
 3326|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3326:9): [Folded, False: 0]
  ------------------
 3327|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3327:9): [Folded, False: 0]
  ------------------
 3328|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3328:9): [Folded, False: 0]
  ------------------
 3329|      0|      return;
 3330|      0|    }
 3331|      0|    if (empty()) return;
  ------------------
  |  Branch (3331:9): [True: 0, False: 0]
  ------------------
 3332|       |
 3333|      0|    const size_t hash_of_arg = hash_of(key);
 3334|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3335|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3336|      0|      if (!is_key_equal) return;
 3337|       |
 3338|      0|      [[maybe_unused]] const bool is_hash_equal =
 3339|      0|          hash_of_arg == hash_of(to_slot(slot));
 3340|      0|      assert((!is_key_equal || is_hash_equal) &&
 3341|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3342|      0|             "hash/eq functors are inconsistent.");
 3343|      0|    };
 3344|       |
 3345|      0|    if (is_small()) {
  ------------------
  |  Branch (3345:9): [True: 0, False: 0]
  ------------------
 3346|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3347|      0|      return;
 3348|      0|    }
 3349|       |    // We only do validation for small tables so that it's constant time.
 3350|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3350:9): [True: 0, False: 0]
  ------------------
 3351|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3352|      0|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE22AssertNotDebugCapacityEv:
 3285|  31.0k|  void AssertNotDebugCapacity() const {
 3286|  31.0k|#ifdef NDEBUG
 3287|  31.0k|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 31.0k, Folded]
  ------------------
 3288|  31.0k|      return;
 3289|  31.0k|    }
 3290|      0|#endif
 3291|      0|    if (ABSL_PREDICT_TRUE(capacity() <
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 0]
  |  |  |  Branch (190:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3292|      0|                          InvalidCapacity::kAboveMaxValidCapacity)) {
 3293|      0|      return;
 3294|      0|    }
 3295|      0|    assert(capacity() != InvalidCapacity::kReentrance &&
 3296|      0|           "Reentrant container access during element construction/destruction "
 3297|      0|           "is not allowed.");
 3298|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3299|       |      if (capacity() == InvalidCapacity::kDestroyed) {
 3300|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3301|       |      }
 3302|       |    }
 3303|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3303:9): [Folded, False: 0]
  ------------------
 3304|      0|        ABSL_PREDICT_FALSE(capacity() >= InvalidCapacity::kMovedFrom)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3305|      0|      if (capacity() == InvalidCapacity::kSelfMovedFrom) {
  ------------------
  |  Branch (3305:11): [True: 0, False: 0]
  ------------------
 3306|       |        // If this log triggers, then a hash table was move-assigned to itself
 3307|       |        // and then used again later without being reinitialized.
 3308|      0|        ABSL_RAW_LOG(FATAL, "Use of self-move-assigned hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3309|      0|      }
 3310|      0|      ABSL_RAW_LOG(FATAL, "Use of moved-from hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3311|      0|    }
 3312|      0|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8is_smallEv:
 1874|  15.6k|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE6commonEv:
 3431|   125k|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE28find_or_prepare_insert_smallISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3207|      2|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|      2|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|       |    if constexpr (SooEnabled()) {
 3210|       |      return find_or_prepare_insert_soo(key);
 3211|       |    }
 3212|      2|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 1, False: 1]
  ------------------
 3213|      1|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3213:11): [True: 0, False: 1]
  ------------------
 3214|      0|        common().infoz().RecordInsertHit();
 3215|      0|        return {single_iterator(), false};
 3216|      0|      }
 3217|      1|    }
 3218|      2|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|      2|                common(), GetPolicyFunctions(),
 3220|      2|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|      2|            true};
 3222|      2|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE5emptyEv:
 2326|      2|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE4sizeEv:
 2327|      2|  size_t size() const {
 2328|      2|    AssertNotDebugCapacity();
 2329|      2|    return common().size();
 2330|      2|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8equal_toISA_EEbRKT_PNS1_13map_slot_typeISA_hEE:
 3056|     11|                                             slot_type* slot) const {
 3057|     11|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|     11|                               PolicyTraits::element(slot));
 3059|     11|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE6eq_refEv:
 3478|  15.3k|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE11single_slotEv:
 3450|      1|  slot_type* single_slot() {
 3451|      1|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|      1|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [Folded, False: 1]
  ------------------
 3453|      1|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE10slot_arrayEv:
 3437|  46.6k|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  46.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|  46.6k|    return static_cast<slot_type*>(common().slot_array());
 3440|  46.6k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE6commonEv:
 3430|  47.6k|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeISA_hEEPKh:
 1993|  15.6k|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|  15.6k|          ctrl_(ctrl),
 1995|  15.6k|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|  15.6k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  15.6k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|  15.6k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3390|      2|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3391|      2|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3392|      2|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE7to_slotEPv:
 3073|     15|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|     15|    return static_cast<slot_type*>(buf);
 3075|     15|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE18GetPolicyFunctionsEv:
 3558|    256|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|    256|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|    256|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|    256|                  "or use absl::node_hash_{map,set}.");
 3562|    256|    static_assert(alignof(slot_type) <=
 3563|    256|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|    256|    static_assert(sizeof(key_type) <=
 3565|    256|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|    256|    static_assert(sizeof(value_type) <=
 3567|    256|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|    256|    static constexpr size_t kBackingArrayAlignment =
 3569|    256|        BackingArrayAlignment(alignof(slot_type));
 3570|    256|    static constexpr PolicyFunctions value = {
 3571|    256|        static_cast<uint32_t>(sizeof(key_type)),
 3572|    256|        static_cast<uint32_t>(sizeof(value_type)),
 3573|    256|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|    256|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|    256|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|    256|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|    256|                                : &raw_hash_set::get_hash_ref_fn,
 3580|    256|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|    256|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [Folded, False: 256]
  ------------------
 3582|    256|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|    256|            : &raw_hash_set::transfer_n_slots_fn,
 3584|    256|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|    256|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|    256|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|    256|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|    256|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|    256|    return value;
 3590|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE19transfer_n_slots_fnEPvSD_SD_m:
 3494|      4|                                  size_t count) {
 3495|      4|    auto* src_slot = to_slot(src);
 3496|      4|    auto* dst_slot = to_slot(dst);
 3497|       |
 3498|      4|    auto* h = static_cast<raw_hash_set*>(set);
 3499|     16|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3499:12): [True: 12, False: 4]
  ------------------
 3500|     12|      h->transfer(dst_slot, src_slot);
 3501|     12|    }
 3502|      4|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8transferEPNS1_13map_slot_typeISA_hEESF_:
 2941|    445|  inline void transfer(slot_type* to, slot_type* from) {
 2942|    445|    common().RunWithReentrancyGuard([&] {
 2943|    445|      allocator_type alloc(char_alloc_ref());
 2944|    445|      PolicyTraits::transfer(&alloc, to, from);
 2945|    445|    });
 2946|    445|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEhEEJEE8transferEPNS1_13map_slot_typeISC_hEESH_EUlvE_EEvT_:
 1099|    445|  void RunWithReentrancyGuard(F f) {
 1100|    445|#ifdef NDEBUG
 1101|    445|    f();
 1102|    445|    return;
 1103|      0|#endif
 1104|      0|    const size_t cap = capacity();
 1105|      0|    set_capacity(InvalidCapacity::kReentrance);
 1106|      0|    f();
 1107|      0|    set_capacity(cap);
 1108|      0|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8transferEPNS1_13map_slot_typeISA_hEESF_ENKUlvE_clEv:
 2942|    445|    common().RunWithReentrancyGuard([&] {
 2943|    445|      allocator_type alloc(char_alloc_ref());
 2944|    445|      PolicyTraits::transfer(&alloc, to, from);
 2945|    445|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE14char_alloc_refEv:
 3479|    701|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3511|      5|                                    size_t source_offset, size_t h1)) {
 3512|      5|    const size_t new_capacity = common.capacity();
 3513|      5|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3514|      5|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  270|      5|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3515|      5|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  270|      5|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3516|       |
 3517|      5|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3518|      5|    slot_type* old_slots_ptr = to_slot(old_slots);
 3519|      5|    ctrl_t* new_ctrl = common.control();
 3520|      5|    slot_type* new_slots = set->slot_array();
 3521|       |
 3522|     36|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3522:34): [True: 31, False: 5]
  ------------------
 3523|     31|         group_index += Group::kWidth) {
 3524|     31|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3525|     31|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3526|     31|                  Group::kWidth);
 3527|     31|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3528|     31|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3529|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3530|       |      // We will share a lot of code in expense of one function call per group.
 3531|    434|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3531:38): [True: 434, False: 31]
  ------------------
 3532|    434|        size_t old_index = group_index + in_fixed_group_index;
 3533|    434|        slot_type* old_slot = old_slots_ptr + old_index;
 3534|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3535|       |        // only one new bit of h1.
 3536|    434|        size_t hash = set->hash_of(old_slot);
 3537|    434|        size_t h1 = H1(hash);
 3538|    434|        h2_t h2 = H2(hash);
 3539|    434|        size_t new_index = TryFindNewIndexWithoutProbing(
 3540|    434|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3541|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3542|       |        // till and included the old_index.
 3543|    434|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  189|    434|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 433]
  |  |  |  Branch (189:49): [Folded, False: 434]
  |  |  |  Branch (189:58): [True: 1, False: 433]
  |  |  ------------------
  ------------------
 3544|      1|          encode_probed_element(probed_storage, h2, old_index, h1);
 3545|      1|          continue;
 3546|      1|        }
 3547|    433|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  248|    433|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3548|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  248|    433|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3549|    433|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3550|    433|        auto* new_slot = new_slots + new_index;
 3551|    433|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3552|    433|        set->transfer(new_slot, old_slot);
 3553|    433|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3554|    433|      }
 3555|     31|    }
 3556|      5|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE7hash_ofEPNS1_13map_slot_typeISA_hEE:
 3065|    434|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3066|    434|    return PolicyTraits::apply(
 3067|    434|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3068|    434|        PolicyTraits::element(slot));
 3069|    434|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8hash_refEv:
 3476|  16.0k|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal29TryFindNewIndexWithoutProbingIvEEmmmmPNS1_6ctrl_tEm:
 1425|  40.3M|                                            size_t new_capacity) {
 1426|  40.3M|  size_t index_diff = old_index - h1;
 1427|       |  // The first probe group starts with h1 & capacity.
 1428|       |  // All following groups start at (h1 + Group::kWidth * K) & capacity.
 1429|       |  // We can find an index within the floating group as index_diff modulo
 1430|       |  // Group::kWidth.
 1431|       |  // Both old and new capacity are larger than Group::kWidth so we can avoid
 1432|       |  // computing `& capacity`.
 1433|  40.3M|  size_t in_floating_group_index = index_diff & (Group::kWidth - 1);
 1434|       |  // By subtracting we will get the difference between the first probe group
 1435|       |  // and the probe group corresponding to old_index.
 1436|  40.3M|  index_diff -= in_floating_group_index;
 1437|  40.3M|  if (ABSL_PREDICT_TRUE((index_diff & old_capacity) == 0)) {
  ------------------
  |  |  190|  40.3M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 38.5M, False: 1.81M]
  |  |  |  Branch (190:48): [Folded, False: 40.3M]
  |  |  |  Branch (190:57): [True: 38.5M, False: 1.81M]
  |  |  ------------------
  ------------------
 1438|  38.5M|    size_t new_index = (h1 + in_floating_group_index) & new_capacity;
 1439|  38.5M|    ABSL_ASSUME(new_index != kProbedElementIndexSentinel);
  ------------------
  |  |  270|  38.5M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1440|  38.5M|    return new_index;
 1441|  38.5M|  }
 1442|  1.81M|  ABSL_SWISSTABLE_ASSERT(((old_index - h1) & old_capacity) >= Group::kWidth);
  ------------------
  |  |  248|  1.81M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1443|       |  // Try to insert element into the first probe group.
 1444|       |  // new_ctrl is not yet fully initialized so we can't use regular search via
 1445|       |  // find_first_non_full.
 1446|       |
 1447|       |  // We can search in the first probe group only if it is located in already
 1448|       |  // initialized part of the table.
 1449|  1.81M|  if (ABSL_PREDICT_FALSE((h1 & old_capacity) >= old_index)) {
  ------------------
  |  |  189|  1.81M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 6.25k, False: 1.80M]
  |  |  |  Branch (189:49): [Folded, False: 1.81M]
  |  |  |  Branch (189:58): [True: 6.25k, False: 1.80M]
  |  |  ------------------
  ------------------
 1450|  6.25k|    return kProbedElementIndexSentinel;
 1451|  6.25k|  }
 1452|  1.80M|  size_t offset = h1 & new_capacity;
 1453|  1.80M|  Group new_g(new_ctrl + offset);
 1454|  1.80M|  if (auto mask = new_g.MaskNonFull(); ABSL_PREDICT_TRUE(mask)) {
  ------------------
  |  |  190|  1.80M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 1.80M, False: 1.03k]
  |  |  |  Branch (190:48): [Folded, False: 1.80M]
  |  |  |  Branch (190:57): [True: 1.80M, False: 1.03k]
  |  |  ------------------
  ------------------
 1455|  1.80M|    size_t result = offset + mask.LowestBitSet();
 1456|  1.80M|    ABSL_ASSUME(result != kProbedElementIndexSentinel);
  ------------------
  |  |  270|  1.80M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1457|  1.80M|    return result;
 1458|  1.80M|  }
 1459|  1.03k|  return kProbedElementIndexSentinel;
 1460|  1.80M|}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8hash_refEv:
 3475|      2|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3225|    254|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|    254|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|    254|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|    254|    prefetch_heap_block();
 3228|    254|    const size_t hash = hash_of(key);
 3229|    254|    auto seq = probe(common(), hash);
 3230|    254|    const h2_t h2 = H2(hash);
 3231|    254|    const ctrl_t* ctrl = control();
 3232|    254|    size_t index;
 3233|    254|    bool inserted;
 3234|       |    // We use a lambda function to be able to exit from the nested loop without
 3235|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3236|    254|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|    254|      while (true) {
 3238|    254|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|    254|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|    254|#endif
 3241|    254|        Group g{ctrl + seq.offset()};
 3242|    254|        for (uint32_t i : g.Match(h2)) {
 3243|    254|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|    254|            index = seq.offset(i);
 3245|    254|            inserted = false;
 3246|    254|            common().infoz().RecordInsertHit();
 3247|    254|            return;
 3248|    254|          }
 3249|    254|        }
 3250|    254|        auto mask_empty = g.MaskEmpty();
 3251|    254|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|    254|          size_t target_group_offset = seq.offset();
 3253|    254|          index = SwisstableGenerationsEnabled()
 3254|    254|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|    254|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|    254|                            FindInfo{target_group_offset, seq.index()},
 3257|    254|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|    254|                      : PrepareInsertLarge(
 3259|    254|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|    254|                            FindInfo{target_group_offset, seq.index()});
 3261|    254|          inserted = true;
 3262|    254|          return;
 3263|    254|        }
 3264|    254|        seq.next();
 3265|    254|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|    254|      }
 3267|    254|    }();
 3268|    254|    return {iterator_at(index), inserted};
 3269|    254|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE19prefetch_heap_blockEv:
 3423|  15.6k|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  15.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|  15.6k|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|  15.6k|    __builtin_prefetch(control(), 0, 1);
 3427|  15.6k|#endif
 3428|  15.6k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE7hash_ofISA_EEmRKT_:
 3061|    254|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|    254|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|    254|                                               common().seed().seed()}(key);
 3064|    254|  }
_ZN4absl12lts_2026010718container_internal9probe_seqILm16EEC2Emm:
  327|  60.1M|  probe_seq(size_t hash, size_t mask) {
  328|       |    ABSL_SWISSTABLE_ASSERT(((mask + 1) & mask) == 0 && "not a mask");
  ------------------
  |  |  248|  60.1M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  329|  60.1M|    mask_ = mask;
  330|  60.1M|    offset_ = hash & mask_;
  331|  60.1M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE7controlEv:
 3433|  46.8k|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  46.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|  46.8k|    return common().control();
 3436|  46.8k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|    254|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|    259|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 259, Folded]
  ------------------
 3238|    259|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|    259|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|    259|#endif
 3241|    259|        Group g{ctrl + seq.offset()};
 3242|    259|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 10, False: 259]
  ------------------
 3243|     10|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|     10|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 10]
  |  |  |  Branch (190:48): [Folded, False: 10]
  |  |  |  Branch (190:57): [True: 0, False: 10]
  |  |  ------------------
  ------------------
 3244|      0|            index = seq.offset(i);
 3245|      0|            inserted = false;
 3246|      0|            common().infoz().RecordInsertHit();
 3247|      0|            return;
 3248|      0|          }
 3249|     10|        }
 3250|    259|        auto mask_empty = g.MaskEmpty();
 3251|    259|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|    259|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 254, False: 5]
  |  |  |  Branch (190:48): [Folded, False: 259]
  |  |  |  Branch (190:57): [True: 254, False: 5]
  |  |  ------------------
  ------------------
 3252|    254|          size_t target_group_offset = seq.offset();
 3253|    254|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 254]
  ------------------
 3254|    254|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|      0|                            FindInfo{target_group_offset, seq.index()},
 3257|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|    254|                      : PrepareInsertLarge(
 3259|    254|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|    254|                            FindInfo{target_group_offset, seq.index()});
 3261|    254|          inserted = true;
 3262|    254|          return;
 3263|    254|        }
 3264|      5|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|      5|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|      5|      }
 3267|    254|    }();
_ZNK4absl12lts_2026010718container_internal9probe_seqILm16EE6offsetEv:
  334|   159M|  size_t offset() const { return offset_; }
_ZNK4absl12lts_2026010718container_internal9probe_seqILm16EE6offsetEm:
  335|  5.57M|  size_t offset(size_t i) const { return (offset_ + i) & mask_; }
_ZNK4absl12lts_2026010718container_internal9probe_seqILm16EE5indexEv:
  343|  26.4M|  size_t index() const { return index_; }
_ZN4absl12lts_2026010718container_internal9probe_seqILm16EE4nextEv:
  337|  6.28M|  void next() {
  338|  6.28M|    index_ += Width;
  339|  6.28M|    offset_ += index_;
  340|  6.28M|    offset_ &= mask_;
  341|  6.28M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE11iterator_atEm:
 3383|  15.6k|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|  15.6k|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|  15.6k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3373|    256|  void emplace_at(iterator iter, Args&&... args) {
 3374|    256|    construct(iter.slot(), std::forward<Args>(args)...);
 3375|       |
 3376|       |    // When is_small, find calls find_small and if size is 0, then it will
 3377|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3378|       |    assert((is_small() ||
 3379|    256|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|    256|           "constructed value does not match the lookup key");
 3381|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_hEEDpOT_:
 2929|    256|  inline void construct(slot_type* slot, Args&&... args) {
 2930|    256|    common().RunWithReentrancyGuard([&] {
 2931|    256|      allocator_type alloc(char_alloc_ref());
 2932|    256|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|    256|    });
 2934|    256|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEhEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJOSC_EEENSJ_IJEEEEEEvPNS1_13map_slot_typeISC_hEEDpOT_EUlvE_EEvT_:
 1099|    256|  void RunWithReentrancyGuard(F f) {
 1100|    256|#ifdef NDEBUG
 1101|    256|    f();
 1102|    256|    return;
 1103|      0|#endif
 1104|      0|    const size_t cap = capacity();
 1105|      0|    set_capacity(InvalidCapacity::kReentrance);
 1106|      0|    f();
 1107|      0|    set_capacity(cap);
 1108|      0|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_hEEDpOT_ENKUlvE_clEv:
 2930|    256|    common().RunWithReentrancyGuard([&] {
 2931|    256|      allocator_type alloc(char_alloc_ref());
 2932|    256|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|    256|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iterator4slotEv:
 2042|    256|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEEC2Ev:
 2109|  6.35k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE4findIS8_EENSA_14const_iteratorERKT_:
 2803|  12.7M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2804|  12.7M|    return const_cast<raw_hash_set*>(this)->find(key);
 2805|  12.7M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE4findIS8_EENSA_8iteratorERKT_:
 2788|  12.7M|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2789|  12.7M|    AssertOnFind(key);
 2790|  12.7M|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (2790:9): [True: 5.43M, False: 7.29M]
  ------------------
 2791|  7.29M|    prefetch_heap_block();
 2792|  7.29M|    return find_large(key, hash_of(key));
 2793|  12.7M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE12AssertOnFindIS8_EEvRKT_:
 3279|  12.7M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|  12.7M|    AssertHashEqConsistent(key);
 3281|  12.7M|    AssertNotDebugCapacity();
 3282|  12.7M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22AssertHashEqConsistentIS8_EEvRKT_:
 3317|  12.7M|  void AssertHashEqConsistent(const K& key) {
 3318|  12.7M|#ifdef NDEBUG
 3319|  12.7M|    return;
 3320|      0|#endif
 3321|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3322|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3322:9): [True: 0, Folded]
  ------------------
 3323|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3323:9): [True: 0, Folded]
  ------------------
 3324|      0|      return;
 3325|      0|    }
 3326|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3326:9): [Folded, False: 0]
  ------------------
 3327|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3327:9): [Folded, False: 0]
  ------------------
 3328|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3328:9): [Folded, False: 0]
  ------------------
 3329|      0|      return;
 3330|      0|    }
 3331|      0|    if (empty()) return;
  ------------------
  |  Branch (3331:9): [True: 0, False: 0]
  ------------------
 3332|       |
 3333|      0|    const size_t hash_of_arg = hash_of(key);
 3334|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3335|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3336|      0|      if (!is_key_equal) return;
 3337|       |
 3338|      0|      [[maybe_unused]] const bool is_hash_equal =
 3339|      0|          hash_of_arg == hash_of(to_slot(slot));
 3340|      0|      assert((!is_key_equal || is_hash_equal) &&
 3341|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3342|      0|             "hash/eq functors are inconsistent.");
 3343|      0|    };
 3344|       |
 3345|      0|    if (is_small()) {
  ------------------
  |  Branch (3345:9): [True: 0, False: 0]
  ------------------
 3346|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3347|      0|      return;
 3348|      0|    }
 3349|       |    // We only do validation for small tables so that it's constant time.
 3350|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3350:9): [True: 0, False: 0]
  ------------------
 3351|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3352|      0|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE10find_smallIS8_EENSA_8iteratorERKT_:
 2951|  5.43M|  iterator find_small(const key_arg<K>& key) {
 2952|  5.43M|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  5.43M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2953|  5.43M|    return empty() || !equal_to(key, single_slot()) ? end() : single_iterator();
  ------------------
  |  Branch (2953:12): [True: 224k, False: 5.20M]
  |  Branch (2953:23): [True: 5.09M, False: 116k]
  ------------------
 2954|  5.43M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8equal_toIS8_EEbRKT_PNS1_13map_slot_typeIS8_iEE:
 3056|  5.61M|                                             slot_type* slot) const {
 3057|  5.61M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|  5.61M|                               PolicyTraits::element(slot));
 3059|  5.61M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6eq_refEv:
 3478|  5.61M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE3endEv:
 2310|  24.9M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|  24.9M|    AssertNotDebugCapacity();
 2312|  24.9M|    return iterator(common().generation_ptr());
 2313|  24.9M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorC2EPKh:
 2014|  24.9M|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE15single_iteratorEv:
 3464|   116k|  iterator single_iterator() {
 3465|   116k|    return {SooControl(), single_slot(), common().generation_ptr()};
 3466|   116k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIS8_iEEPKh:
 1993|   506k|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|   506k|          ctrl_(ctrl),
 1995|   506k|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|   506k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|   506k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|   506k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE19prefetch_heap_blockEv:
 3423|  7.33M|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  7.33M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|  7.33M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|  7.33M|    __builtin_prefetch(control(), 0, 1);
 3427|  7.33M|#endif
 3428|  7.33M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE10find_largeIS8_EENSA_8iteratorERKT_m:
 2957|  7.29M|  iterator find_large(const key_arg<K>& key, size_t hash) {
 2958|  7.29M|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  7.29M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2959|  7.29M|    auto seq = probe(common(), hash);
 2960|  7.29M|    const h2_t h2 = H2(hash);
 2961|  7.29M|    const ctrl_t* ctrl = control();
 2962|  7.29M|    while (true) {
  ------------------
  |  Branch (2962:12): [True: 7.29M, Folded]
  ------------------
 2963|  7.29M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 2964|  7.29M|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 2965|  7.29M|#endif
 2966|  7.29M|      Group g{ctrl + seq.offset()};
 2967|  7.29M|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (2967:23): [True: 409k, False: 6.94M]
  ------------------
 2968|   409k|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  190|   409k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 345k, False: 63.9k]
  |  |  |  Branch (190:48): [Folded, False: 409k]
  |  |  |  Branch (190:57): [True: 345k, False: 63.9k]
  |  |  ------------------
  ------------------
 2969|   345k|          return iterator_at(seq.offset(i));
 2970|   409k|      }
 2971|  6.94M|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  190|  6.94M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 6.94M, False: 1.21k]
  |  |  |  Branch (190:48): [Folded, False: 6.94M]
  |  |  |  Branch (190:57): [True: 6.94M, False: 1.21k]
  |  |  ------------------
  ------------------
 2972|  1.21k|      seq.next();
 2973|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  1.21k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2974|  1.21k|    }
 2975|  7.29M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE11iterator_atEm:
 3383|   388k|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|   388k|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|   388k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7hash_ofIS8_EEmRKT_:
 3061|  7.33M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|  7.33M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|  7.33M|                                               common().seed().seed()}(key);
 3064|  7.33M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8hash_refEv:
 3476|  7.33M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE14const_iteratorC2ENSA_8iteratorE:
 2069|  25.4M|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE3endEv:
 2318|  12.7M|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2319|  12.7M|    return const_cast<raw_hash_set*>(this)->end();
 2320|  12.7M|  }
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE14const_iteratorESD_:
 2083|  11.9M|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2084|  11.9M|      return !(a == b);
 2085|  11.9M|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE14const_iteratorESD_:
 2080|  12.7M|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2081|  12.7M|      return a.inner_ == b.inner_;
 2082|  12.7M|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorESD_:
 1979|  12.7M|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|  12.7M|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|  12.7M|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|  12.7M|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|  12.7M|                          a.generation_ptr(), b.generation_ptr());
 1984|  12.7M|      return a.ctrl_ == b.ctrl_;
 1985|  12.7M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE14const_iteratorptEv:
 2072|   461k|    pointer operator->() const { return inner_.operator->(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorptEv:
 1958|   461k|    pointer operator->() const {
 1959|   461k|      assert_is_full("operator->");
 1960|   461k|      return &operator*();
 1961|   461k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator14assert_is_fullEPKc:
 2016|   960k|    void assert_is_full(const char* operation) const {
 2017|   960k|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|   960k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratordeEv:
 1952|   480k|    reference operator*() const {
 1953|   480k|      assert_is_full("operator*()");
 1954|   480k|      return unchecked_deref();
 1955|   480k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator15unchecked_derefEv:
 2039|   480k|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5clearEv:
 2341|  7.98k|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2342|  7.98k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (2342:9): [Folded, False: 7.98k]
  ------------------
 2343|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (2343:9): [True: 0, False: 0]
  ------------------
 2344|      0|      common().set_capacity(DefaultCapacity());
 2345|      0|    }
 2346|  7.98k|    AssertNotDebugCapacity();
 2347|       |    // Iterating over this container is O(bucket_count()). When bucket_count()
 2348|       |    // is much greater than size(), iteration becomes prohibitively expensive.
 2349|       |    // For clear() it is more important to reuse the allocated array when the
 2350|       |    // container is small because allocation takes comparatively long time
 2351|       |    // compared to destruction of the elements of the container. So we pick the
 2352|       |    // largest bucket_count() threshold for which iteration is still fast and
 2353|       |    // past that we simply deallocate the array.
 2354|  7.98k|    const size_t cap = capacity();
 2355|  7.98k|    if (cap == 0) {
  ------------------
  |  Branch (2355:9): [True: 6.35k, False: 1.62k]
  ------------------
 2356|       |      // Already guaranteed to be empty; so nothing to do.
 2357|  6.35k|    } else if (is_small()) {
  ------------------
  |  Branch (2357:16): [True: 355, False: 1.26k]
  ------------------
 2358|    355|      if (!empty()) {
  ------------------
  |  Branch (2358:11): [True: 355, False: 0]
  ------------------
 2359|    355|        destroy(single_slot());
 2360|    355|        decrement_small_size();
 2361|    355|      }
 2362|  1.26k|    } else {
 2363|  1.26k|      destroy_slots();
 2364|  1.26k|      clear_backing_array(/*reuse=*/cap < 128);
 2365|  1.26k|    }
 2366|  7.98k|    common().set_reserved_growth(0);
 2367|  7.98k|    common().set_reservation_size(0);
 2368|  7.98k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE20decrement_small_sizeEv:
 3457|    355|  void decrement_small_size() {
 3458|    355|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|    355|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3459|    355|    SooEnabled() ? common().set_empty_soo() : common().decrement_size();
  ------------------
  |  Branch (3459:5): [Folded, False: 355]
  ------------------
 3460|    355|    if (!SooEnabled()) {
  ------------------
  |  Branch (3460:9): [True: 355, Folded]
  ------------------
 3461|    355|      SanitizerPoisonObject(single_slot());
 3462|    355|    }
 3463|    355|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE19clear_backing_arrayEb:
 2986|  1.26k|  void clear_backing_array(bool reuse) {
 2987|       |    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|  1.26k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2988|  1.26k|    ClearBackingArray(common(), GetPolicyFunctions(), &char_alloc_ref(), reuse,
 2989|  1.26k|                      SooEnabled());
 2990|  1.26k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE18GetPolicyFunctionsEv:
 3558|  51.1k|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|  51.1k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|  51.1k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|  51.1k|                  "or use absl::node_hash_{map,set}.");
 3562|  51.1k|    static_assert(alignof(slot_type) <=
 3563|  51.1k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|  51.1k|    static_assert(sizeof(key_type) <=
 3565|  51.1k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|  51.1k|    static_assert(sizeof(value_type) <=
 3567|  51.1k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|  51.1k|    static constexpr size_t kBackingArrayAlignment =
 3569|  51.1k|        BackingArrayAlignment(alignof(slot_type));
 3570|  51.1k|    static constexpr PolicyFunctions value = {
 3571|  51.1k|        static_cast<uint32_t>(sizeof(key_type)),
 3572|  51.1k|        static_cast<uint32_t>(sizeof(value_type)),
 3573|  51.1k|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|  51.1k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|  51.1k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|  51.1k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|  51.1k|                                : &raw_hash_set::get_hash_ref_fn,
 3580|  51.1k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|  51.1k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [True: 0, Folded]
  ------------------
 3582|  51.1k|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|  51.1k|            : &raw_hash_set::transfer_n_slots_fn,
 3584|  51.1k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|  51.1k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|  51.1k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|  51.1k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|  51.1k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|  51.1k|    return value;
 3590|  51.1k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7to_slotEPv:
 3073|  2.95k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|  2.95k|    return static_cast<slot_type*>(buf);
 3075|  2.95k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7reserveEm:
 2741|  6.35k|  void reserve(size_t n) {
 2742|  6.35k|    if (ABSL_PREDICT_TRUE(n > DefaultCapacity())) {
  ------------------
  |  |  190|  6.35k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 6.00k, False: 358]
  |  |  |  Branch (190:48): [Folded, False: 6.35k]
  |  |  |  Branch (190:57): [True: 6.00k, False: 358]
  |  |  ------------------
  ------------------
 2743|  6.00k|      ReserveTableToFitNewSize(common(), GetPolicyFunctions(), n);
 2744|  6.00k|    }
 2745|  6.35k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6insertINS4_4pairIKS8_iEELi0EEENSC_INSA_8iteratorEbEERKT_:
 2411|  43.9k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2412|  43.9k|    return emplace(value);
 2413|  43.9k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7emplaceIJRKNS4_4pairIKS8_iEEETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSC_INSA_8iteratorEbEEDpOSI_:
 2526|  43.9k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2527|  43.9k|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2528|  43.9k|                               std::forward<Args>(args)...);
 2529|  43.9k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE19EmplaceDecomposableclIS8_JRKNS4_21piecewise_construct_tENS4_5tupleIJRKS8_EEENSG_IJRKiEEEEEENS4_4pairINSA_8iteratorEbEERKT_DpOT0_:
 2901|  43.9k|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 2902|  43.9k|      auto res = s.find_or_prepare_insert(key);
 2903|  43.9k|      if (res.second) {
  ------------------
  |  Branch (2903:11): [True: 43.9k, False: 10]
  ------------------
 2904|  43.9k|        s.emplace_at(res.first, std::forward<Args>(args)...);
 2905|  43.9k|      }
 2906|  43.9k|      return res;
 2907|  43.9k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22find_or_prepare_insertIS8_EENS4_4pairINSA_8iteratorEbEERKT_:
 3358|  43.9k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|  43.9k|    AssertOnFind(key);
 3360|  43.9k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 1.49k, False: 42.4k]
  ------------------
 3361|  42.4k|    return find_or_prepare_insert_large(key);
 3362|  43.9k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE28find_or_prepare_insert_smallIS8_EENS4_4pairINSA_8iteratorEbEERKT_:
 3207|  1.49k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|  1.49k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  1.49k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|       |    if constexpr (SooEnabled()) {
 3210|       |      return find_or_prepare_insert_soo(key);
 3211|       |    }
 3212|  1.49k|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 0, False: 1.49k]
  ------------------
 3213|      0|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3213:11): [True: 0, False: 0]
  ------------------
 3214|      0|        common().infoz().RecordInsertHit();
 3215|      0|        return {single_iterator(), false};
 3216|      0|      }
 3217|      0|    }
 3218|  1.49k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|  1.49k|                common(), GetPolicyFunctions(),
 3220|  1.49k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|  1.49k|            true};
 3222|  1.49k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3390|  1.49k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3391|  1.49k|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3392|  1.49k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8hash_refEv:
 3475|  1.49k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE28find_or_prepare_insert_largeIS8_EENS4_4pairINSA_8iteratorEbEERKT_:
 3225|  42.4k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|  42.4k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  42.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|  42.4k|    prefetch_heap_block();
 3228|  42.4k|    const size_t hash = hash_of(key);
 3229|  42.4k|    auto seq = probe(common(), hash);
 3230|  42.4k|    const h2_t h2 = H2(hash);
 3231|  42.4k|    const ctrl_t* ctrl = control();
 3232|  42.4k|    size_t index;
 3233|  42.4k|    bool inserted;
 3234|       |    // We use a lambda function to be able to exit from the nested loop without
 3235|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3236|  42.4k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|  42.4k|      while (true) {
 3238|  42.4k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|  42.4k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|  42.4k|#endif
 3241|  42.4k|        Group g{ctrl + seq.offset()};
 3242|  42.4k|        for (uint32_t i : g.Match(h2)) {
 3243|  42.4k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|  42.4k|            index = seq.offset(i);
 3245|  42.4k|            inserted = false;
 3246|  42.4k|            common().infoz().RecordInsertHit();
 3247|  42.4k|            return;
 3248|  42.4k|          }
 3249|  42.4k|        }
 3250|  42.4k|        auto mask_empty = g.MaskEmpty();
 3251|  42.4k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|  42.4k|          size_t target_group_offset = seq.offset();
 3253|  42.4k|          index = SwisstableGenerationsEnabled()
 3254|  42.4k|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|  42.4k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|  42.4k|                            FindInfo{target_group_offset, seq.index()},
 3257|  42.4k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|  42.4k|                      : PrepareInsertLarge(
 3259|  42.4k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|  42.4k|                            FindInfo{target_group_offset, seq.index()});
 3261|  42.4k|          inserted = true;
 3262|  42.4k|          return;
 3263|  42.4k|        }
 3264|  42.4k|        seq.next();
 3265|  42.4k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|  42.4k|      }
 3267|  42.4k|    }();
 3268|  42.4k|    return {iterator_at(index), inserted};
 3269|  42.4k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE28find_or_prepare_insert_largeIS8_EENS4_4pairINSA_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|  42.4k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|  42.4k|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 42.4k, Folded]
  ------------------
 3238|  42.4k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|  42.4k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|  42.4k|#endif
 3241|  42.4k|        Group g{ctrl + seq.offset()};
 3242|  42.4k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 997, False: 42.4k]
  ------------------
 3243|    997|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|    997|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 10, False: 987]
  |  |  |  Branch (190:48): [Folded, False: 997]
  |  |  |  Branch (190:57): [True: 10, False: 987]
  |  |  ------------------
  ------------------
 3244|     10|            index = seq.offset(i);
 3245|     10|            inserted = false;
 3246|     10|            common().infoz().RecordInsertHit();
 3247|     10|            return;
 3248|     10|          }
 3249|    997|        }
 3250|  42.4k|        auto mask_empty = g.MaskEmpty();
 3251|  42.4k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|  42.4k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 42.4k, False: 49]
  |  |  |  Branch (190:48): [Folded, False: 42.4k]
  |  |  |  Branch (190:57): [True: 42.4k, False: 49]
  |  |  ------------------
  ------------------
 3252|  42.4k|          size_t target_group_offset = seq.offset();
 3253|  42.4k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 42.4k]
  ------------------
 3254|  42.4k|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|      0|                            FindInfo{target_group_offset, seq.index()},
 3257|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|  42.4k|                      : PrepareInsertLarge(
 3259|  42.4k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|  42.4k|                            FindInfo{target_group_offset, seq.index()});
 3261|  42.4k|          inserted = true;
 3262|  42.4k|          return;
 3263|  42.4k|        }
 3264|     49|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|     49|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|     49|      }
 3267|  42.4k|    }();
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKS8_EEENSF_IJRKiEEEEEEvNSA_8iteratorEDpOT_:
 3373|  43.9k|  void emplace_at(iterator iter, Args&&... args) {
 3374|  43.9k|    construct(iter.slot(), std::forward<Args>(args)...);
 3375|       |
 3376|       |    // When is_small, find calls find_small and if size is 0, then it will
 3377|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3378|       |    assert((is_small() ||
 3379|  43.9k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|  43.9k|           "constructed value does not match the lookup key");
 3381|  43.9k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKS8_EEENSF_IJRKiEEEEEEvPNS1_13map_slot_typeIS8_iEEDpOT_:
 2929|  43.9k|  inline void construct(slot_type* slot, Args&&... args) {
 2930|  43.9k|    common().RunWithReentrancyGuard([&] {
 2931|  43.9k|      allocator_type alloc(char_alloc_ref());
 2932|  43.9k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|  43.9k|    });
 2934|  43.9k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEiEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSA_EEENSH_IJRKiEEEEEEvPNS1_13map_slot_typeISA_iEEDpOT_EUlvE_EEvT_:
 1099|  43.9k|  void RunWithReentrancyGuard(F f) {
 1100|  43.9k|#ifdef NDEBUG
 1101|  43.9k|    f();
 1102|  43.9k|    return;
 1103|      0|#endif
 1104|      0|    const size_t cap = capacity();
 1105|      0|    set_capacity(InvalidCapacity::kReentrance);
 1106|      0|    f();
 1107|      0|    set_capacity(cap);
 1108|      0|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKS8_EEENSF_IJRKiEEEEEEvPNS1_13map_slot_typeIS8_iEEDpOT_ENKUlvE_clEv:
 2930|  43.9k|    common().RunWithReentrancyGuard([&] {
 2931|  43.9k|      allocator_type alloc(char_alloc_ref());
 2932|  43.9k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|  43.9k|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator4slotEv:
 2042|  43.9k|    slot_type* slot() const { return slot_; }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE4findINS4_17basic_string_viewIcS7_EEEENSC_14const_iteratorERKT_:
 2803|  15.3k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2804|  15.3k|    return const_cast<raw_hash_set*>(this)->find(key);
 2805|  15.3k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE4findINS4_17basic_string_viewIcS7_EEEENSC_8iteratorERKT_:
 2788|  15.3k|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2789|  15.3k|    AssertOnFind(key);
 2790|  15.3k|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (2790:9): [True: 0, False: 15.3k]
  ------------------
 2791|  15.3k|    prefetch_heap_block();
 2792|  15.3k|    return find_large(key, hash_of(key));
 2793|  15.3k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE12AssertOnFindINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3279|  15.3k|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|  15.3k|    AssertHashEqConsistent(key);
 3281|  15.3k|    AssertNotDebugCapacity();
 3282|  15.3k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE22AssertHashEqConsistentINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3317|  15.3k|  void AssertHashEqConsistent(const K& key) {
 3318|  15.3k|#ifdef NDEBUG
 3319|  15.3k|    return;
 3320|      0|#endif
 3321|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3322|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3322:9): [True: 0, Folded]
  ------------------
 3323|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3323:9): [True: 0, Folded]
  ------------------
 3324|      0|      return;
 3325|      0|    }
 3326|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3326:9): [Folded, False: 0]
  ------------------
 3327|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3327:9): [Folded, False: 0]
  ------------------
 3328|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3328:9): [Folded, False: 0]
  ------------------
 3329|      0|      return;
 3330|      0|    }
 3331|      0|    if (empty()) return;
  ------------------
  |  Branch (3331:9): [True: 0, False: 0]
  ------------------
 3332|       |
 3333|      0|    const size_t hash_of_arg = hash_of(key);
 3334|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3335|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3336|      0|      if (!is_key_equal) return;
 3337|       |
 3338|      0|      [[maybe_unused]] const bool is_hash_equal =
 3339|      0|          hash_of_arg == hash_of(to_slot(slot));
 3340|      0|      assert((!is_key_equal || is_hash_equal) &&
 3341|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3342|      0|             "hash/eq functors are inconsistent.");
 3343|      0|    };
 3344|       |
 3345|      0|    if (is_small()) {
  ------------------
  |  Branch (3345:9): [True: 0, False: 0]
  ------------------
 3346|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3347|      0|      return;
 3348|      0|    }
 3349|       |    // We only do validation for small tables so that it's constant time.
 3350|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3350:9): [True: 0, False: 0]
  ------------------
 3351|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3352|      0|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8equal_toINS4_17basic_string_viewIcS7_EEEEbRKT_PNS1_13map_slot_typeISA_hEE:
 3056|  15.3k|                                             slot_type* slot) const {
 3057|  15.3k|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|  15.3k|                               PolicyTraits::element(slot));
 3059|  15.3k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE3endEv:
 2310|  15.4k|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|  15.4k|    AssertNotDebugCapacity();
 2312|  15.4k|    return iterator(common().generation_ptr());
 2313|  15.4k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iteratorC2EPKh:
 2014|  15.4k|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE10find_largeINS4_17basic_string_viewIcS7_EEEENSC_8iteratorERKT_m:
 2957|  15.3k|  iterator find_large(const key_arg<K>& key, size_t hash) {
 2958|  15.3k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  15.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2959|  15.3k|    auto seq = probe(common(), hash);
 2960|  15.3k|    const h2_t h2 = H2(hash);
 2961|  15.3k|    const ctrl_t* ctrl = control();
 2962|  15.3k|    while (true) {
  ------------------
  |  Branch (2962:12): [True: 15.3k, Folded]
  ------------------
 2963|  15.3k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 2964|  15.3k|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 2965|  15.3k|#endif
 2966|  15.3k|      Group g{ctrl + seq.offset()};
 2967|  15.3k|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (2967:23): [True: 15.3k, False: 32]
  ------------------
 2968|  15.3k|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  190|  15.3k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 15.3k, False: 3]
  |  |  |  Branch (190:48): [Folded, False: 15.3k]
  |  |  |  Branch (190:57): [True: 15.3k, False: 3]
  |  |  ------------------
  ------------------
 2969|  15.3k|          return iterator_at(seq.offset(i));
 2970|  15.3k|      }
 2971|     32|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  190|     32|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 32, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 32]
  |  |  |  Branch (190:57): [True: 32, False: 0]
  |  |  ------------------
  ------------------
 2972|      0|      seq.next();
 2973|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2974|      0|    }
 2975|  15.3k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE7hash_ofINS4_17basic_string_viewIcS7_EEEEmRKT_:
 3061|  15.3k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|  15.3k|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|  15.3k|                                               common().seed().seed()}(key);
 3064|  15.3k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE14const_iteratorC2ENSC_8iteratorE:
 2069|  30.7k|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE3endEv:
 2318|  15.3k|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2319|  15.3k|    return const_cast<raw_hash_set*>(this)->end();
 2320|  15.3k|  }
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE14const_iteratorESF_:
 2083|  15.3k|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2084|  15.3k|      return !(a == b);
 2085|  15.3k|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE14const_iteratorESF_:
 2080|  15.3k|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2081|  15.3k|      return a.inner_ == b.inner_;
 2082|  15.3k|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iteratorESF_:
 1979|  15.3k|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|  15.3k|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|  15.3k|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|  15.3k|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|  15.3k|                          a.generation_ptr(), b.generation_ptr());
 1984|  15.3k|      return a.ctrl_ == b.ctrl_;
 1985|  15.3k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE14const_iteratorptEv:
 2072|  15.3k|    pointer operator->() const { return inner_.operator->(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iteratorptEv:
 1958|  15.3k|    pointer operator->() const {
 1959|  15.3k|      assert_is_full("operator->");
 1960|  15.3k|      return &operator*();
 1961|  15.3k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iterator14assert_is_fullEPKc:
 2016|  30.7k|    void assert_is_full(const char* operation) const {
 2017|  30.7k|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|  30.7k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iteratordeEv:
 1952|  15.3k|    reference operator*() const {
 1953|  15.3k|      assert_is_full("operator*()");
 1954|  15.3k|      return unchecked_deref();
 1955|  15.3k|    }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE4findIS9_EENSC_8iteratorERKT_:
 2788|  26.4M|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2789|  26.4M|    AssertOnFind(key);
 2790|  26.4M|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (2790:9): [True: 730, False: 26.4M]
  ------------------
 2791|  26.4M|    prefetch_heap_block();
 2792|  26.4M|    return find_large(key, hash_of(key));
 2793|  26.4M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE12AssertOnFindIS9_EEvRKT_:
 3279|  52.8M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|  52.8M|    AssertHashEqConsistent(key);
 3281|  52.8M|    AssertNotDebugCapacity();
 3282|  52.8M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE22AssertHashEqConsistentIS9_EEvRKT_:
 3317|  52.8M|  void AssertHashEqConsistent(const K& key) {
 3318|  52.8M|#ifdef NDEBUG
 3319|  52.8M|    return;
 3320|      0|#endif
 3321|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3322|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3322:9): [Folded, False: 0]
  ------------------
 3323|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3323:9): [Folded, False: 0]
  ------------------
 3324|      0|      return;
 3325|      0|    }
 3326|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3326:9): [True: 0, Folded]
  ------------------
 3327|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3327:9): [Folded, False: 0]
  ------------------
 3328|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3328:9): [Folded, False: 0]
  ------------------
 3329|      0|      return;
 3330|      0|    }
 3331|      0|    if (empty()) return;
  ------------------
  |  Branch (3331:9): [True: 0, False: 0]
  ------------------
 3332|       |
 3333|      0|    const size_t hash_of_arg = hash_of(key);
 3334|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3335|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3336|      0|      if (!is_key_equal) return;
 3337|       |
 3338|      0|      [[maybe_unused]] const bool is_hash_equal =
 3339|      0|          hash_of_arg == hash_of(to_slot(slot));
 3340|      0|      assert((!is_key_equal || is_hash_equal) &&
 3341|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3342|      0|             "hash/eq functors are inconsistent.");
 3343|      0|    };
 3344|       |
 3345|      0|    if (is_small()) {
  ------------------
  |  Branch (3345:9): [True: 0, False: 0]
  ------------------
 3346|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3347|      0|      return;
 3348|      0|    }
 3349|       |    // We only do validation for small tables so that it's constant time.
 3350|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3350:9): [True: 0, False: 0]
  ------------------
 3351|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3352|      0|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE22AssertNotDebugCapacityEv:
 3285|   105M|  void AssertNotDebugCapacity() const {
 3286|   105M|#ifdef NDEBUG
 3287|   105M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 105M, Folded]
  ------------------
 3288|   105M|      return;
 3289|   105M|    }
 3290|      0|#endif
 3291|      0|    if (ABSL_PREDICT_TRUE(capacity() <
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 0]
  |  |  |  Branch (190:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3292|      0|                          InvalidCapacity::kAboveMaxValidCapacity)) {
 3293|      0|      return;
 3294|      0|    }
 3295|      0|    assert(capacity() != InvalidCapacity::kReentrance &&
 3296|      0|           "Reentrant container access during element construction/destruction "
 3297|      0|           "is not allowed.");
 3298|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3299|       |      if (capacity() == InvalidCapacity::kDestroyed) {
 3300|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3301|       |      }
 3302|       |    }
 3303|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3303:9): [Folded, False: 0]
  ------------------
 3304|      0|        ABSL_PREDICT_FALSE(capacity() >= InvalidCapacity::kMovedFrom)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3305|      0|      if (capacity() == InvalidCapacity::kSelfMovedFrom) {
  ------------------
  |  Branch (3305:11): [True: 0, False: 0]
  ------------------
 3306|       |        // If this log triggers, then a hash table was move-assigned to itself
 3307|       |        // and then used again later without being reinitialized.
 3308|      0|        ABSL_RAW_LOG(FATAL, "Use of self-move-assigned hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3309|      0|      }
 3310|      0|      ABSL_RAW_LOG(FATAL, "Use of moved-from hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3311|      0|    }
 3312|      0|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8is_smallEv:
 1874|  52.8M|  bool is_small() const { return common().is_small(); }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE6commonEv:
 3431|   368M|  const CommonFields& common() const { return settings_.template get<0>(); }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE10find_smallIS9_EENSC_8iteratorERKT_:
 2951|    730|  iterator find_small(const key_arg<K>& key) {
 2952|    730|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|    730|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2953|    730|    return empty() || !equal_to(key, single_slot()) ? end() : single_iterator();
  ------------------
  |  Branch (2953:12): [True: 365, False: 365]
  |  Branch (2953:23): [True: 365, False: 0]
  ------------------
 2954|    730|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE5emptyEv:
 2326|  1.46k|  bool empty() const { return !size(); }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE4sizeEv:
 2327|  1.46k|  size_t size() const {
 2328|  1.46k|    AssertNotDebugCapacity();
 2329|  1.46k|    return common().size();
 2330|  1.46k|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8equal_toIS9_EEbRKT_PNS1_13map_slot_typeIS9_SA_EE:
 3056|  4.77M|                                             slot_type* slot) const {
 3057|  4.77M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|  4.77M|                               PolicyTraits::element(slot));
 3059|  4.77M|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE6eq_refEv:
 3478|  4.77M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE11single_slotEv:
 3450|  1.09k|  slot_type* single_slot() {
 3451|  1.09k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  1.09k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|  1.09k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [True: 1.09k, Folded]
  ------------------
 3453|  1.09k|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8soo_slotEv:
 3441|  1.09k|  slot_type* soo_slot() {
 3442|  1.09k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|  1.09k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3443|  1.09k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(
  ------------------
  |  |  488|  1.09k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 3444|  1.09k|        static_cast<slot_type*>(common().soo_data()));
 3445|  1.09k|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE6commonEv:
 3430|   225M|  CommonFields& common() { return settings_.template get<0>(); }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE15single_iteratorEv:
 3464|    365|  iterator single_iterator() {
 3465|    365|    return {SooControl(), single_slot(), common().generation_ptr()};
 3466|    365|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIS9_SA_EEPKh:
 1993|  26.4M|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|  26.4M|          ctrl_(ctrl),
 1995|  26.4M|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|  26.4M|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  26.4M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|  26.4M|    }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE19prefetch_heap_blockEv:
 3423|  52.8M|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  52.8M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|  52.8M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|  52.8M|    __builtin_prefetch(control(), 0, 1);
 3427|  52.8M|#endif
 3428|  52.8M|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE7controlEv:
 3433|   132M|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   132M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|   132M|    return common().control();
 3436|   132M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE10find_largeIS9_EENSC_8iteratorERKT_m:
 2957|  26.4M|  iterator find_large(const key_arg<K>& key, size_t hash) {
 2958|  26.4M|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  26.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2959|  26.4M|    auto seq = probe(common(), hash);
 2960|  26.4M|    const h2_t h2 = H2(hash);
 2961|  26.4M|    const ctrl_t* ctrl = control();
 2962|  29.5M|    while (true) {
  ------------------
  |  Branch (2962:12): [True: 29.5M, Folded]
  ------------------
 2963|  29.5M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 2964|  29.5M|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 2965|  29.5M|#endif
 2966|  29.5M|      Group g{ctrl + seq.offset()};
 2967|  29.5M|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (2967:23): [True: 2.38M, False: 29.5M]
  ------------------
 2968|  2.38M|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  190|  2.38M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 6.93k, False: 2.38M]
  |  |  |  Branch (190:48): [Folded, False: 2.38M]
  |  |  |  Branch (190:57): [True: 6.93k, False: 2.38M]
  |  |  ------------------
  ------------------
 2969|  6.93k|          return iterator_at(seq.offset(i));
 2970|  2.38M|      }
 2971|  29.5M|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  190|  29.5M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 26.4M, False: 3.14M]
  |  |  |  Branch (190:48): [Folded, False: 29.5M]
  |  |  |  Branch (190:57): [True: 26.4M, False: 3.14M]
  |  |  ------------------
  ------------------
 2972|  3.14M|      seq.next();
 2973|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  3.14M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2974|  3.14M|    }
 2975|  26.4M|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE10slot_arrayEv:
 3437|  90.3M|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  90.3M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|  90.3M|    return static_cast<slot_type*>(common().slot_array());
 3440|  90.3M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE11iterator_atEm:
 3383|  26.4M|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|  26.4M|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|  26.4M|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE7hash_ofIS9_EEmRKT_:
 3061|  52.8M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|  52.8M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|  52.8M|                                               common().seed().seed()}(key);
 3064|  52.8M|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8hash_refEv:
 3476|  93.1M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
unigram_model.cc:_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8iteratorESF_:
 1986|  26.4M|    friend bool operator!=(const iterator& a, const iterator& b) {
 1987|  26.4M|      return !(a == b);
 1988|  26.4M|    }
unigram_model.cc:_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8iteratorESF_:
 1979|  26.4M|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|  26.4M|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|  26.4M|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|  26.4M|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|  26.4M|                          a.generation_ptr(), b.generation_ptr());
 1984|  26.4M|      return a.ctrl_ == b.ctrl_;
 1985|  26.4M|    }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE3endEv:
 2310|  52.8M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|  52.8M|    AssertNotDebugCapacity();
 2312|  52.8M|    return iterator(common().generation_ptr());
 2313|  52.8M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8iteratorC2EPKh:
 2014|  52.8M|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8iteratorptEv:
 1958|  6.93k|    pointer operator->() const {
 1959|  6.93k|      assert_is_full("operator->");
 1960|  6.93k|      return &operator*();
 1961|  6.93k|    }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8iterator14assert_is_fullEPKc:
 2016|  13.8k|    void assert_is_full(const char* operation) const {
 2017|  13.8k|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|  13.8k|    }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8iteratordeEv:
 1952|  6.93k|    reference operator*() const {
 1953|  6.93k|      assert_is_full("operator*()");
 1954|  6.93k|      return unchecked_deref();
 1955|  6.93k|    }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8iterator15unchecked_derefEv:
 2039|  6.93k|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE6insertEONSt3__14pairIS9_SA_EE:
 2434|  26.4M|  {
 2435|  26.4M|    return emplace(std::move(value));
 2436|  26.4M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE7emplaceIJNSt3__14pairIS9_SA_EEETnNSE_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSF_INSC_8iteratorEbEEDpOSI_:
 2526|  26.4M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2527|  26.4M|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2528|  26.4M|                               std::forward<Args>(args)...);
 2529|  26.4M|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE19EmplaceDecomposableclIS9_JRKNSt3__121piecewise_construct_tENSF_5tupleIJOS9_EEENSJ_IJOSA_EEEEEENSF_4pairINSC_8iteratorEbEERKT_DpOT0_:
 2901|  26.4M|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 2902|  26.4M|      auto res = s.find_or_prepare_insert(key);
 2903|  26.4M|      if (res.second) {
  ------------------
  |  Branch (2903:11): [True: 26.4M, False: 0]
  ------------------
 2904|  26.4M|        s.emplace_at(res.first, std::forward<Args>(args)...);
 2905|  26.4M|      }
 2906|  26.4M|      return res;
 2907|  26.4M|    }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE22find_or_prepare_insertIS9_EENSt3__14pairINSC_8iteratorEbEERKT_:
 3358|  26.4M|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|  26.4M|    AssertOnFind(key);
 3360|  26.4M|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 730, False: 26.4M]
  ------------------
 3361|  26.4M|    return find_or_prepare_insert_large(key);
 3362|  26.4M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE28find_or_prepare_insert_smallIS9_EENSt3__14pairINSC_8iteratorEbEERKT_:
 3207|    730|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|    730|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|    730|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|    730|    if constexpr (SooEnabled()) {
 3210|    730|      return find_or_prepare_insert_soo(key);
 3211|    730|    }
 3212|    730|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 0, False: 730]
  ------------------
 3213|      0|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3213:11): [True: 0, False: 0]
  ------------------
 3214|      0|        common().infoz().RecordInsertHit();
 3215|      0|        return {single_iterator(), false};
 3216|      0|      }
 3217|      0|    }
 3218|    730|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|    730|                common(), GetPolicyFunctions(),
 3220|    730|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|    730|            true};
 3222|    730|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE26find_or_prepare_insert_sooIS9_EENSt3__14pairINSC_8iteratorEbEERKT_:
 3181|    730|  std::pair<iterator, bool> find_or_prepare_insert_soo(const K& key) {
 3182|    730|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|    730|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3183|    730|    bool force_sampling;
 3184|    730|    if (empty()) {
  ------------------
  |  Branch (3184:9): [True: 365, False: 365]
  ------------------
 3185|    365|      if (!should_sample_soo()) {
  ------------------
  |  Branch (3185:11): [True: 365, False: 0]
  ------------------
 3186|    365|        common().set_full_soo();
 3187|    365|        return {single_iterator(), true};
 3188|    365|      }
 3189|      0|      force_sampling = true;
 3190|    365|    } else if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3190:16): [True: 0, False: 365]
  ------------------
 3191|      0|      return {single_iterator(), false};
 3192|    365|    } else {
 3193|    365|      force_sampling = false;
 3194|    365|    }
 3195|    365|    ABSL_SWISSTABLE_ASSERT(capacity() == 1);
  ------------------
  |  |  248|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3196|    365|    constexpr bool kUseMemcpy =
 3197|    365|        PolicyTraits::transfer_uses_memcpy() && SooEnabled();
  ------------------
  |  Branch (3197:9): [True: 0, Folded]
  |  Branch (3197:49): [True: 0, Folded]
  ------------------
 3198|    365|    size_t index = GrowSooTableToNextCapacityAndPrepareInsert<
 3199|    365|        kUseMemcpy ? OptimalMemcpySizeForSooSlotTransfer(sizeof(slot_type)) : 0,
 3200|    365|        kUseMemcpy>(common(), GetPolicyFunctions(),
 3201|    365|                    HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key},
 3202|    365|                    force_sampling);
 3203|    365|    return {iterator_at(index), true};
 3204|    730|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE17should_sample_sooEv:
 2980|    365|  bool should_sample_soo() const {
 2981|    365|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2982|    365|    if (!ShouldSampleHashtablezInfoForAlloc<CharAlloc>()) return false;
  ------------------
  |  Branch (2982:9): [Folded, False: 365]
  ------------------
 2983|    365|    return ABSL_PREDICT_FALSE(ShouldSampleNextTable());
  ------------------
  |  |  189|    365|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:49): [Folded, False: 365]
  |  |  |  Branch (189:58): [True: 0, False: 365]
  |  |  ------------------
  ------------------
 2984|    365|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE18GetPolicyFunctionsEv:
 3558|  26.4M|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|  26.4M|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|  26.4M|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|  26.4M|                  "or use absl::node_hash_{map,set}.");
 3562|  26.4M|    static_assert(alignof(slot_type) <=
 3563|  26.4M|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|  26.4M|    static_assert(sizeof(key_type) <=
 3565|  26.4M|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|  26.4M|    static_assert(sizeof(value_type) <=
 3567|  26.4M|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|  26.4M|    static constexpr size_t kBackingArrayAlignment =
 3569|  26.4M|        BackingArrayAlignment(alignof(slot_type));
 3570|  26.4M|    static constexpr PolicyFunctions value = {
 3571|  26.4M|        static_cast<uint32_t>(sizeof(key_type)),
 3572|  26.4M|        static_cast<uint32_t>(sizeof(value_type)),
 3573|  26.4M|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|  26.4M|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|  26.4M|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|  26.4M|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|  26.4M|                                : &raw_hash_set::get_hash_ref_fn,
 3580|  26.4M|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|  26.4M|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [True: 0, Folded]
  ------------------
 3582|  26.4M|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|  26.4M|            : &raw_hash_set::transfer_n_slots_fn,
 3584|  26.4M|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|  26.4M|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|  26.4M|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|  26.4M|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|  26.4M|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|  26.4M|    return value;
 3590|  26.4M|  }
_ZN4absl12lts_2026010718container_internal20TransferNRelocatableILm16EEEvPvS3_S3_m:
 1722|  8.02k|                                                  size_t count) {
 1723|       |  // TODO(b/382423690): Experiment with making specialization for power of 2 and
 1724|       |  // non power of 2. This would require passing the size of the slot.
 1725|  8.02k|  memcpy(dst, src, SizeOfSlot * count);
 1726|  8.02k|}
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3511|  4.12k|                                    size_t source_offset, size_t h1)) {
 3512|  4.12k|    const size_t new_capacity = common.capacity();
 3513|  4.12k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3514|  4.12k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  270|  4.12k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3515|  4.12k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  270|  4.12k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3516|       |
 3517|  4.12k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3518|  4.12k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3519|  4.12k|    ctrl_t* new_ctrl = common.control();
 3520|  4.12k|    slot_type* new_slots = set->slot_array();
 3521|       |
 3522|  2.88M|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3522:34): [True: 2.88M, False: 4.12k]
  ------------------
 3523|  2.88M|         group_index += Group::kWidth) {
 3524|  2.88M|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3525|  2.88M|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3526|  2.88M|                  Group::kWidth);
 3527|  2.88M|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3528|  2.88M|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3529|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3530|       |      // We will share a lot of code in expense of one function call per group.
 3531|  40.3M|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3531:38): [True: 40.3M, False: 2.88M]
  ------------------
 3532|  40.3M|        size_t old_index = group_index + in_fixed_group_index;
 3533|  40.3M|        slot_type* old_slot = old_slots_ptr + old_index;
 3534|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3535|       |        // only one new bit of h1.
 3536|  40.3M|        size_t hash = set->hash_of(old_slot);
 3537|  40.3M|        size_t h1 = H1(hash);
 3538|  40.3M|        h2_t h2 = H2(hash);
 3539|  40.3M|        size_t new_index = TryFindNewIndexWithoutProbing(
 3540|  40.3M|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3541|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3542|       |        // till and included the old_index.
 3543|  40.3M|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  189|  40.3M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 7.29k, False: 40.3M]
  |  |  |  Branch (189:49): [Folded, False: 40.3M]
  |  |  |  Branch (189:58): [True: 7.29k, False: 40.3M]
  |  |  ------------------
  ------------------
 3544|  7.29k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3545|  7.29k|          continue;
 3546|  7.29k|        }
 3547|  40.3M|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  248|  40.3M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3548|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  248|  40.3M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3549|  40.3M|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3550|  40.3M|        auto* new_slot = new_slots + new_index;
 3551|  40.3M|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3552|  40.3M|        set->transfer(new_slot, old_slot);
 3553|  40.3M|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3554|  40.3M|      }
 3555|  2.88M|    }
 3556|  4.12k|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE7to_slotEPv:
 3073|  4.12k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|  4.12k|    return static_cast<slot_type*>(buf);
 3075|  4.12k|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE7hash_ofEPNS1_13map_slot_typeIS9_SA_EE:
 3065|  40.3M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3066|  40.3M|    return PolicyTraits::apply(
 3067|  40.3M|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3068|  40.3M|        PolicyTraits::element(slot));
 3069|  40.3M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8transferEPNS1_13map_slot_typeIS9_SA_EESF_:
 2941|  40.3M|  inline void transfer(slot_type* to, slot_type* from) {
 2942|  40.3M|    common().RunWithReentrancyGuard([&] {
 2943|  40.3M|      allocator_type alloc(char_alloc_ref());
 2944|  40.3M|      PolicyTraits::transfer(&alloc, to, from);
 2945|  40.3M|    });
 2946|  40.3M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS9_EEJEE8transferEPNS1_13map_slot_typeISB_SC_EESH_EUlvE_EEvT_:
 1099|  40.3M|  void RunWithReentrancyGuard(F f) {
 1100|  40.3M|#ifdef NDEBUG
 1101|  40.3M|    f();
 1102|  40.3M|    return;
 1103|      0|#endif
 1104|      0|    const size_t cap = capacity();
 1105|      0|    set_capacity(InvalidCapacity::kReentrance);
 1106|      0|    f();
 1107|      0|    set_capacity(cap);
 1108|      0|  }
unigram_model.cc:_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8transferEPNS1_13map_slot_typeIS9_SA_EESF_ENKUlvE_clEv:
 2942|  40.3M|    common().RunWithReentrancyGuard([&] {
 2943|  40.3M|      allocator_type alloc(char_alloc_ref());
 2944|  40.3M|      PolicyTraits::transfer(&alloc, to, from);
 2945|  40.3M|    });
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE14char_alloc_refEv:
 3479|  66.7M|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8hash_refEv:
 3475|    365|  hasher& hash_ref() { return settings_.template get<1>(); }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE28find_or_prepare_insert_largeIS9_EENSt3__14pairINSC_8iteratorEbEERKT_:
 3225|  26.4M|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|  26.4M|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  26.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|  26.4M|    prefetch_heap_block();
 3228|  26.4M|    const size_t hash = hash_of(key);
 3229|  26.4M|    auto seq = probe(common(), hash);
 3230|  26.4M|    const h2_t h2 = H2(hash);
 3231|  26.4M|    const ctrl_t* ctrl = control();
 3232|  26.4M|    size_t index;
 3233|  26.4M|    bool inserted;
 3234|       |    // We use a lambda function to be able to exit from the nested loop without
 3235|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3236|  26.4M|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|  26.4M|      while (true) {
 3238|  26.4M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|  26.4M|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|  26.4M|#endif
 3241|  26.4M|        Group g{ctrl + seq.offset()};
 3242|  26.4M|        for (uint32_t i : g.Match(h2)) {
 3243|  26.4M|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|  26.4M|            index = seq.offset(i);
 3245|  26.4M|            inserted = false;
 3246|  26.4M|            common().infoz().RecordInsertHit();
 3247|  26.4M|            return;
 3248|  26.4M|          }
 3249|  26.4M|        }
 3250|  26.4M|        auto mask_empty = g.MaskEmpty();
 3251|  26.4M|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|  26.4M|          size_t target_group_offset = seq.offset();
 3253|  26.4M|          index = SwisstableGenerationsEnabled()
 3254|  26.4M|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|  26.4M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|  26.4M|                            FindInfo{target_group_offset, seq.index()},
 3257|  26.4M|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|  26.4M|                      : PrepareInsertLarge(
 3259|  26.4M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|  26.4M|                            FindInfo{target_group_offset, seq.index()});
 3261|  26.4M|          inserted = true;
 3262|  26.4M|          return;
 3263|  26.4M|        }
 3264|  26.4M|        seq.next();
 3265|  26.4M|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|  26.4M|      }
 3267|  26.4M|    }();
 3268|  26.4M|    return {iterator_at(index), inserted};
 3269|  26.4M|  }
unigram_model.cc:_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE28find_or_prepare_insert_largeIS9_EENSt3__14pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|  26.4M|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|  29.5M|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 29.5M, Folded]
  ------------------
 3238|  29.5M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|  29.5M|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|  29.5M|#endif
 3241|  29.5M|        Group g{ctrl + seq.offset()};
 3242|  29.5M|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 2.38M, False: 29.5M]
  ------------------
 3243|  2.38M|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|  2.38M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 2.38M]
  |  |  |  Branch (190:48): [Folded, False: 2.38M]
  |  |  |  Branch (190:57): [True: 0, False: 2.38M]
  |  |  ------------------
  ------------------
 3244|      0|            index = seq.offset(i);
 3245|      0|            inserted = false;
 3246|      0|            common().infoz().RecordInsertHit();
 3247|      0|            return;
 3248|      0|          }
 3249|  2.38M|        }
 3250|  29.5M|        auto mask_empty = g.MaskEmpty();
 3251|  29.5M|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|  29.5M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 26.4M, False: 3.14M]
  |  |  |  Branch (190:48): [Folded, False: 29.5M]
  |  |  |  Branch (190:57): [True: 26.4M, False: 3.14M]
  |  |  ------------------
  ------------------
 3252|  26.4M|          size_t target_group_offset = seq.offset();
 3253|  26.4M|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 26.4M]
  ------------------
 3254|  26.4M|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|      0|                            FindInfo{target_group_offset, seq.index()},
 3257|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|  26.4M|                      : PrepareInsertLarge(
 3259|  26.4M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|  26.4M|                            FindInfo{target_group_offset, seq.index()});
 3261|  26.4M|          inserted = true;
 3262|  26.4M|          return;
 3263|  26.4M|        }
 3264|  3.14M|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  3.14M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|  3.14M|      }
 3267|  26.4M|    }();
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE10emplace_atIJRKNSt3__121piecewise_construct_tENSE_5tupleIJOS9_EEENSI_IJOSA_EEEEEEvNSC_8iteratorEDpOT_:
 3373|  26.4M|  void emplace_at(iterator iter, Args&&... args) {
 3374|  26.4M|    construct(iter.slot(), std::forward<Args>(args)...);
 3375|       |
 3376|       |    // When is_small, find calls find_small and if size is 0, then it will
 3377|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3378|       |    assert((is_small() ||
 3379|  26.4M|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|  26.4M|           "constructed value does not match the lookup key");
 3381|  26.4M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE9constructIJRKNSt3__121piecewise_construct_tENSE_5tupleIJOS9_EEENSI_IJOSA_EEEEEEvPNS1_13map_slot_typeIS9_SA_EEDpOT_:
 2929|  26.4M|  inline void construct(slot_type* slot, Args&&... args) {
 2930|  26.4M|    common().RunWithReentrancyGuard([&] {
 2931|  26.4M|      allocator_type alloc(char_alloc_ref());
 2932|  26.4M|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|  26.4M|    });
 2934|  26.4M|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS9_EEJEE9constructIJRKNSt3__121piecewise_construct_tENSG_5tupleIJOSB_EEENSK_IJOSC_EEEEEEvPNS1_13map_slot_typeISB_SC_EEDpOT_EUlvE_EEvT_:
 1099|  26.4M|  void RunWithReentrancyGuard(F f) {
 1100|  26.4M|#ifdef NDEBUG
 1101|  26.4M|    f();
 1102|  26.4M|    return;
 1103|      0|#endif
 1104|      0|    const size_t cap = capacity();
 1105|      0|    set_capacity(InvalidCapacity::kReentrance);
 1106|      0|    f();
 1107|      0|    set_capacity(cap);
 1108|      0|  }
unigram_model.cc:_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE9constructIJRKNSt3__121piecewise_construct_tENSE_5tupleIJOS9_EEENSI_IJOSA_EEEEEEvPNS1_13map_slot_typeIS9_SA_EEDpOT_ENKUlvE_clEv:
 2930|  26.4M|    common().RunWithReentrancyGuard([&] {
 2931|  26.4M|      allocator_type alloc(char_alloc_ref());
 2932|  26.4M|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|  26.4M|    });
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8iterator4slotEv:
 2042|  26.4M|    slot_type* slot() const { return slot_; }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEED2Ev:
 2294|    365|  ~raw_hash_set() {
 2295|    365|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|    365|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE15destructor_implEv:
 3019|    365|  void destructor_impl() {
 3020|    365|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 365]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|    365|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 0, False: 365]
  ------------------
 3025|    365|    if (is_small()) {
  ------------------
  |  Branch (3025:9): [True: 0, False: 365]
  ------------------
 3026|      0|      if (!empty()) {
  ------------------
  |  Branch (3026:11): [True: 0, False: 0]
  ------------------
 3027|      0|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|      0|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3028|      0|      }
 3029|      0|      if constexpr (SooEnabled()) return;
 3030|    365|    } else {
 3031|    365|      destroy_slots();
 3032|    365|    }
 3033|      0|    dealloc();
 3034|    365|  }
unigram_model.cc:_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE8capacityEv:
 2331|  1.09k|  size_t capacity() const {
 2332|  1.09k|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|  1.09k|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|  1.09k|        DefaultCapacity();
 2336|  1.09k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|  1.09k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|  1.09k|    return cap;
 2338|  1.09k|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE13destroy_slotsEv:
 2992|    365|  void destroy_slots() {
 2993|    365|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2994|    365|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (2994:9): [True: 365, Folded]
  ------------------
 2995|      0|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 2996|      0|      this->destroy(static_cast<slot_type*>(slot));
 2997|      0|    };
 2998|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2999|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3000|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 3001|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3002|       |      common().set_capacity(common_copy.capacity());
 3003|      0|    } else {
 3004|      0|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3005|      0|    }
 3006|      0|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE7deallocEv:
 3008|    365|  void dealloc() {
 3009|    365|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3010|       |    // Unpoison before returning the memory to the allocator.
 3011|    365|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3012|    365|    infoz().Unregister();
 3013|    365|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3014|    365|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3015|    365|                                      sizeof(slot_type), alignof(slot_type),
 3016|    365|                                      common().has_infoz());
 3017|    365|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEE5infozEv:
 3470|    365|  HashtablezInfoHandle infoz() {
 3471|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|    365|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3472|    365|    return common().infoz();
 3473|    365|  }
unigram_model.cc:_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEPS7_EEJEEC2Ev:
 2109|    365|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026010718container_internal12CommonFields13CreateDefaultILb1EEES2_v:
  939|    365|  static CommonFields CreateDefault() {
  940|    365|    return kSooEnabled ? CommonFields{soo_tag_t{}}
  ------------------
  |  Branch (940:12): [True: 365, Folded]
  ------------------
  941|    365|                       : CommonFields{non_soo_tag_t{}};
  942|    365|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5beginEv:
 2301|  2.45k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2302|  2.45k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  189|  2.45k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 632, False: 1.82k]
  |  |  |  Branch (189:49): [Folded, False: 2.45k]
  |  |  |  Branch (189:58): [True: 632, False: 1.82k]
  |  |  ------------------
  ------------------
 2303|  1.82k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2303:9): [True: 361, False: 1.46k]
  ------------------
 2304|  1.46k|    iterator it = {control(), common().slots_union(),
 2305|  1.46k|                   common().generation_ptr()};
 2306|  1.46k|    it.skip_empty_or_deleted();
 2307|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  248|  1.46k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2308|  1.46k|    return it;
 2309|  1.82k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2005|  1.46k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2006|  1.46k|          ctrl_(ctrl),
 2007|  1.46k|          slot_(to_slot(slot.get())) {
 2008|       |      // This assumption helps the compiler know that any non-end iterator is
 2009|       |      // not equal to any end iterator.
 2010|  1.46k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  1.46k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2011|  1.46k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator21skip_empty_or_deletedEv:
 2022|  19.9k|    void skip_empty_or_deleted() {
 2023|  32.2k|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2023:14): [True: 12.3k, False: 19.9k]
  ------------------
 2024|  12.3k|        ++ctrl_;
 2025|  12.3k|        ++slot_;
 2026|  12.3k|      }
 2027|  19.9k|    }
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorESD_:
 1986|  20.9k|    friend bool operator!=(const iterator& a, const iterator& b) {
 1987|  20.9k|      return !(a == b);
 1988|  20.9k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorppEv:
 1964|  18.4k|    iterator& operator++() {
 1965|  18.4k|      assert_is_full("operator++");
 1966|  18.4k|      ++ctrl_;
 1967|  18.4k|      ++slot_;
 1968|  18.4k|      skip_empty_or_deleted();
 1969|  18.4k|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  189|  18.4k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1.82k, False: 16.6k]
  |  |  |  Branch (189:49): [Folded, False: 18.4k]
  |  |  |  Branch (189:58): [True: 1.82k, False: 16.6k]
  |  |  ------------------
  ------------------
 1970|  18.4k|      return *this;
 1971|  18.4k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS4_4pairIS8_S8_EEEEJEED2Ev:
 2294|    376|  ~raw_hash_set() {
 2295|    376|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|    376|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS4_4pairIS8_S8_EEEEJEE15destructor_implEv:
 3019|    376|  void destructor_impl() {
 3020|    376|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 376]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|    376|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 376, False: 0]
  ------------------
 3025|      0|    if (is_small()) {
  ------------------
  |  Branch (3025:9): [True: 0, False: 0]
  ------------------
 3026|      0|      if (!empty()) {
  ------------------
  |  Branch (3026:11): [True: 0, False: 0]
  ------------------
 3027|      0|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|      0|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3028|      0|      }
 3029|       |      if constexpr (SooEnabled()) return;
 3030|      0|    } else {
 3031|      0|      destroy_slots();
 3032|      0|    }
 3033|      0|    dealloc();
 3034|      0|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS4_4pairIS8_S8_EEEEJEE8capacityEv:
 2331|    376|  size_t capacity() const {
 2332|    376|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|    376|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|    376|        DefaultCapacity();
 2336|    376|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|    376|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|    376|    return cap;
 2338|    376|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS4_4pairIS8_S8_EEEEJEE6commonEv:
 3431|    376|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS4_4pairIS8_S8_EEEEJEEC2Ev:
 2109|    376|      std::is_nothrow_default_constructible<allocator_type>::value) {}

_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEELb1EEEvEEOT_:
  112|      2|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEELb1EEEEENS8_10in_place_tEOT_:
  100|      2|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|      2|    absl::functional_internal::AssertNonNull(f);
  102|      2|    ptr_.obj = &f;
  103|      2|  }
_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEELb1EEEvEEOT_:
  112|  1.49k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEELb1EEEEENS8_10in_place_tEOT_:
  100|  1.49k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  1.49k|    absl::functional_internal::AssertNonNull(f);
  102|  1.49k|    ptr_.obj = &f;
  103|  1.49k|  }
unigram_model.cc:_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashESD_Lb0EEEvEEOT_:
  112|    365|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
unigram_model.cc:_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashESD_Lb0EEEEENSt3__110in_place_tEOT_:
  100|    365|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|    365|    absl::functional_internal::AssertNonNull(f);
  102|    365|    ptr_.obj = &f;
  103|    365|  }

_ZN4absl12lts_2026010719functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS3_10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEELb1EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|      1|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|      1|  using T = std::remove_reference_t<Obj>;
   76|      1|  return static_cast<R>(std::invoke(
   77|      1|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|      1|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|      1|}
_ZN4absl12lts_2026010719functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS3_10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEELb1EEEEEvRKT_:
  136|      2|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026010719functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS3_10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEELb1EEEEEvRKT_:
  136|  1.49k|void AssertNonNull(const F&) {}
unigram_model.cc:_ZN4absl12lts_2026010719functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS3_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashESB_Lb0EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|    365|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|    365|  using T = std::remove_reference_t<Obj>;
   76|    365|  return static_cast<R>(std::invoke(
   77|    365|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|    365|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|    365|}
unigram_model.cc:_ZN4absl12lts_2026010719functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS3_6HashEqIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEvE4HashESB_Lb0EEEEEvRKT_:
  136|    365|void AssertNonNull(const F&) {}

_ZN4absl12lts_2026010713hash_internal15MixingHashState18combine_contiguousES2_PKhm:
 1343|  7.35M|                                            size_t size) {
 1344|  7.35M|    return MixingHashState(
 1345|  7.35M|        CombineContiguousImpl(hash_state.state_, first, size,
 1346|  7.35M|                              std::integral_constant<int, sizeof(size_t)>{}));
 1347|  7.35M|  }
_ZN4absl12lts_2026010713hash_internal15MixingHashStateC2Em:
 1394|   201M|  explicit MixingHashState(uint64_t state) : state_(state) {}
_ZN4absl12lts_2026010713hash_internal15MixingHashState11combine_rawES2_m:
 1400|  93.1M|                                     uint64_t value) {
 1401|  93.1M|    return MixingHashState(CombineRawImpl(hash_state.state_, value));
 1402|  93.1M|  }
_ZN4absl12lts_2026010713hash_internal15MixingHashState4SeedEv:
 1446|  93.1M|  ABSL_ATTRIBUTE_ALWAYS_INLINE static size_t Seed() {
 1447|  93.1M|#if (!defined(__clang__) || __clang_major__ > 11) && \
 1448|  93.1M|    (!defined(__apple_build_version__) ||            \
 1449|  93.1M|     __apple_build_version__ >= 19558921)  // Xcode 12
 1450|  93.1M|    return static_cast<size_t>(reinterpret_cast<uintptr_t>(&kSeed));
 1451|       |#else
 1452|       |    // Workaround the absence of
 1453|       |    // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
 1454|       |    return static_cast<size_t>(reinterpret_cast<uintptr_t>(kSeed));
 1455|       |#endif
 1456|  93.1M|  }
_ZN4absl12lts_2026010713hash_internal19PrecombineLengthMixEmm:
  989|  7.20M|inline uint64_t PrecombineLengthMix(uint64_t state, size_t len) {
  990|  7.20M|  ABSL_ASSUME(len + sizeof(uint64_t) <= sizeof(kStaticRandomData));
  ------------------
  |  |  270|  7.20M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  991|  7.20M|  uint64_t data = absl::base_internal::UnalignedLoad64(
  992|  7.20M|      reinterpret_cast<const unsigned char*>(&kStaticRandomData[0]) + len);
  993|  7.20M|  return state ^ data;
  994|  7.20M|}
_ZN4absl12lts_2026010713hash_internal3MixEmm:
  996|   104M|ABSL_ATTRIBUTE_ALWAYS_INLINE inline uint64_t Mix(uint64_t lhs, uint64_t rhs) {
  997|       |  // Though the 128-bit product needs multiple instructions on non-x86-64
  998|       |  // platforms, it is still a good balance between speed and hash quality.
  999|   104M|  absl::uint128 m = lhs;
 1000|   104M|  m *= rhs;
 1001|   104M|  return Uint128High64(m) ^ Uint128Low64(m);
 1002|   104M|}
_ZN4absl12lts_2026010713hash_internal5Read8EPKh:
 1012|   342k|inline uint64_t Read8(const unsigned char* p) {
 1013|   342k|  return absl::base_internal::UnalignedLoad64(p);
 1014|   342k|}
_ZN4absl12lts_2026010713hash_internal9Read9To16EPKhm:
 1023|  65.9k|                                               size_t len) {
 1024|  65.9k|  return {Read8(p), Read8(p + len - 8)};
 1025|  65.9k|}
_ZN4absl12lts_2026010713hash_internal8Read4To8EPKhm:
 1029|   712k|inline uint64_t Read4To8(const unsigned char* p, size_t len) {
 1030|       |  // If `len < 8`, we duplicate bytes. We always put low memory at the end.
 1031|       |  // E.g., on little endian platforms:
 1032|       |  // `ABCD` will be read as `ABCDABCD`.
 1033|       |  // `ABCDE` will be read as `BCDEABCD`.
 1034|       |  // `ABCDEF` will be read as `CDEFABCD`.
 1035|       |  // `ABCDEFG` will be read as `DEFGABCD`.
 1036|       |  // `ABCDEFGH` will be read as `EFGHABCD`.
 1037|       |  // We also do not care about endianness. On big-endian platforms, bytes will
 1038|       |  // be permuted differently. We always shift low memory by 32, because that
 1039|       |  // can be pipelined earlier. Reading high memory requires computing
 1040|       |  // `p + len - 4`.
 1041|   712k|  uint64_t most_significant =
 1042|   712k|      static_cast<uint64_t>(absl::base_internal::UnalignedLoad32(p)) << 32;
 1043|   712k|  uint64_t least_significant =
 1044|   712k|      absl::base_internal::UnalignedLoad32(p + len - 4);
 1045|   712k|  return most_significant | least_significant;
 1046|   712k|}
_ZN4absl12lts_2026010713hash_internal8Read1To3EPKhm:
 1049|  6.37M|inline uint32_t Read1To3(const unsigned char* p, size_t len) {
 1050|       |  // The trick used by this implementation is to avoid branches.
 1051|       |  // We always read three bytes by duplicating.
 1052|       |  // E.g.,
 1053|       |  // `A` is read as `AAA`.
 1054|       |  // `AB` is read as `ABB`.
 1055|       |  // `ABC` is read as `ABC`.
 1056|       |  // We always shift `p[0]` so that it can be pipelined better.
 1057|       |  // Other bytes require extra computation to find indices.
 1058|  6.37M|  uint32_t mem0 = (static_cast<uint32_t>(p[0]) << 16) | p[len - 1];
 1059|  6.37M|  uint32_t mem1 = static_cast<uint32_t>(p[len / 2]) << 8;
 1060|  6.37M|  return mem0 | mem1;
 1061|  6.37M|}
_ZN4absl12lts_2026010713hash_internal14CombineRawImplEmm:
 1064|   100M|                                                            uint64_t value) {
 1065|   100M|  return Mix(state ^ value, kMul);
 1066|   100M|}
_ZN4absl12lts_2026010713hash_internal26CombineSmallContiguousImplEmPKhm:
 1079|  7.08M|    uint64_t state, const unsigned char* first, size_t len) {
 1080|  7.08M|  ABSL_ASSUME(len <= 8);
  ------------------
  |  |  270|  7.08M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1081|  7.08M|  uint64_t v;
 1082|  7.08M|  if (len >= 4) {
  ------------------
  |  Branch (1082:7): [True: 712k, False: 6.37M]
  ------------------
 1083|   712k|    v = Read4To8(first, len);
 1084|  6.37M|  } else if (len > 0) {
  ------------------
  |  Branch (1084:14): [True: 6.37M, False: 369]
  ------------------
 1085|  6.37M|    v = Read1To3(first, len);
 1086|  6.37M|  } else {
 1087|       |    // Empty string must modify the state.
 1088|    369|    v = 0x57;
 1089|    369|  }
 1090|  7.08M|  return CombineRawImpl(state, v);
 1091|  7.08M|}
_ZN4absl12lts_2026010713hash_internal26CombineContiguousImpl9to16EmPKhm:
 1094|  65.9k|    uint64_t state, const unsigned char* first, size_t len) {
 1095|  65.9k|  ABSL_ASSUME(len >= 9);
  ------------------
  |  |  270|  65.9k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1096|  65.9k|  ABSL_ASSUME(len <= 16);
  ------------------
  |  |  270|  65.9k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1097|       |  // Note: any time one half of the mix function becomes zero it will fail to
 1098|       |  // incorporate any bits from the other half. However, there is exactly 1 in
 1099|       |  // 2^64 values for each side that achieve this, and only when the size is
 1100|       |  // exactly 16 -- for smaller sizes there is an overlapping byte that makes
 1101|       |  // this impossible unless the seed is *also* incredibly unlucky.
 1102|  65.9k|  auto p = Read9To16(first, len);
 1103|  65.9k|  return Mix(state ^ p.first, kMul ^ p.second);
 1104|  65.9k|}
_ZN4absl12lts_2026010713hash_internal27CombineContiguousImpl17to32EmPKhm:
 1107|  52.7k|    uint64_t state, const unsigned char* first, size_t len) {
 1108|  52.7k|  ABSL_ASSUME(len >= 17);
  ------------------
  |  |  270|  52.7k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1109|  52.7k|  ABSL_ASSUME(len <= 32);
  ------------------
  |  |  270|  52.7k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1110|       |  // Do two mixes of overlapping 16-byte ranges in parallel to minimize
 1111|       |  // latency.
 1112|  52.7k|  const uint64_t m0 =
 1113|  52.7k|      Mix(Read8(first) ^ kStaticRandomData[1], Read8(first + 8) ^ state);
 1114|       |
 1115|  52.7k|  const unsigned char* tail_16b_ptr = first + (len - 16);
 1116|  52.7k|  const uint64_t m1 = Mix(Read8(tail_16b_ptr) ^ kStaticRandomData[3],
 1117|  52.7k|                          Read8(tail_16b_ptr + 8) ^ state);
 1118|  52.7k|  return m0 ^ m1;
 1119|  52.7k|}
_ZN4absl12lts_2026010713hash_internal21CombineContiguousImplEmPKhmNSt3__117integral_constantIiLi8EEE:
 1203|  7.35M|    std::integral_constant<int, 8> /* sizeof_size_t */) {
 1204|       |  // For large values we use LowLevelHash or CityHash depending on the platform,
 1205|       |  // for small ones we use custom low latency hash.
 1206|  7.35M|  if (len <= 8) {
  ------------------
  |  Branch (1206:7): [True: 7.08M, False: 266k]
  ------------------
 1207|  7.08M|    return CombineSmallContiguousImpl(PrecombineLengthMix(state, len), first,
 1208|  7.08M|                                      len);
 1209|  7.08M|  }
 1210|   266k|  if (len <= 16) {
  ------------------
  |  Branch (1210:7): [True: 65.9k, False: 200k]
  ------------------
 1211|  65.9k|    return CombineContiguousImpl9to16(PrecombineLengthMix(state, len), first,
 1212|  65.9k|                                      len);
 1213|  65.9k|  }
 1214|   200k|  if (len <= 32) {
  ------------------
  |  Branch (1214:7): [True: 52.7k, False: 147k]
  ------------------
 1215|  52.7k|    return CombineContiguousImpl17to32(PrecombineLengthMix(state, len), first,
 1216|  52.7k|                                       len);
 1217|  52.7k|  }
 1218|       |  // We must not mix length into the state here because calling
 1219|       |  // CombineContiguousImpl twice with PiecewiseChunkSize() must be equivalent
 1220|       |  // to calling CombineLargeContiguousImpl once with 2 * PiecewiseChunkSize().
 1221|   147k|  return CombineLargeContiguousImplOn64BitLengthGt32(state, first, len);
 1222|   200k|}
_ZN4absl12lts_2026010713hash_internal15MixingHashState14hash_with_seedINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETnNS4_9enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSA_m:
 1367|  7.35M|  static size_t hash_with_seed(const T& value, size_t seed) {
 1368|  7.35M|    return static_cast<size_t>(combine(MixingHashState{seed}, value).state_);
 1369|  7.35M|  }
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEES3_S3_RKT_DpRKT0_:
 1492|  7.35M|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1493|  7.35M|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1494|  7.35M|                        std::move(state), value),
 1495|  7.35M|                    values...);
 1496|  7.35M|}
_ZN4absl12lts_2026010713hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEENS6_9enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESC_E4typeESC_RKT0_:
 1270|  7.35M|        H> {
 1271|  7.35M|      return AbslHashValue(std::move(state), value);
 1272|  7.35M|    }
_ZN4absl12lts_2026010713hash_internal13AbslHashValueINS1_15MixingHashStateEEET_S4_NSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  645|  7.35M|H AbslHashValue(H hash_state, absl::string_view str) {
  646|  7.35M|  return H::combine_contiguous(std::move(hash_state), str.data(), str.size());
  647|  7.35M|}
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE18combine_contiguousIcEES3_S3_PKT_m:
 1500|  7.35M|H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
 1501|  7.35M|  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
 1502|  7.35M|}
_ZN4absl12lts_2026010713hash_internal19hash_range_or_bytesINS1_15MixingHashStateEcEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES7_PKS6_m:
  962|  7.35M|hash_range_or_bytes(H hash_state, const T* data, size_t size) {
  963|  7.35M|  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
  964|  7.35M|  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
  965|  7.35M|}
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineES3_:
  283|   193M|  static H combine(H state) { return state; }
_ZNK4absl12lts_2026010713hash_internal12HashWithSeed4hashINS1_4HashINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEES9_EEmRKT_RKT0_m:
  396|  7.35M|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  397|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  398|  7.35M|    return hasher.hash_with_seed(value, seed);
  399|  7.35M|  }
_ZNK4absl12lts_2026010713hash_internal8HashImplINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE14hash_with_seedERKS7_m:
 1481|  7.35M|  size_t hash_with_seed(const T& value, size_t seed) const {
 1482|  7.35M|    return MixingHashState::hash_with_seed(value, seed);
 1483|  7.35M|  }
_ZNK4absl12lts_2026010713hash_internal12HashWithSeed4hashINS0_18container_internal10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEmRKT_RKT0_m:
  396|    690|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  397|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  398|    690|    return hasher.hash_with_seed(value, seed);
  399|    690|  }
_ZNK4absl12lts_2026010713hash_internal12HashWithSeed4hashINS0_18container_internal10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEmRKT_RKT0_m:
  396|  7.35M|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  397|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  398|  7.35M|    return hasher.hash_with_seed(value, seed);
  399|  7.35M|  }
unigram_model.cc:_ZNK4absl12lts_2026010713hash_internal8HashImplIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEEclERKS8_:
 1474|  93.1M|  size_t operator()(const T& value) const {
 1475|  93.1M|    return MixingHashState::hash(value);
 1476|  93.1M|  }
unigram_model.cc:_ZN4absl12lts_2026010713hash_internal15MixingHashState4hashIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEEEmRKT_:
 1351|  93.1M|  static size_t hash(const T& value) {
 1352|  93.1M|    return hash_with_seed(value, Seed());
 1353|  93.1M|  }
unigram_model.cc:_ZN4absl12lts_2026010713hash_internal15MixingHashState14hash_with_seedIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisETnNSt3__19enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSC_m:
 1367|  93.1M|  static size_t hash_with_seed(const T& value, size_t seed) {
 1368|  93.1M|    return static_cast<size_t>(combine(MixingHashState{seed}, value).state_);
 1369|  93.1M|  }
unigram_model.cc:_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineIPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEJEEES3_S3_RKT_DpRKT0_:
 1492|  93.1M|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1493|  93.1M|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1494|  93.1M|                        std::move(state), value),
 1495|  93.1M|                    values...);
 1496|  93.1M|}
unigram_model.cc:_ZN4absl12lts_2026010713hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateEPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEEENSt3__19enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESE_E4typeESE_RKT0_:
 1270|  93.1M|        H> {
 1271|  93.1M|      return AbslHashValue(std::move(state), value);
 1272|  93.1M|    }
unigram_model.cc:_ZN4absl12lts_2026010713hash_internal13AbslHashValueINS1_15MixingHashStateEPKN13sentencepiece7unigram12_GLOBAL__N_110HypothesisEEENSt3__19enable_ifIXsr3std10is_pointerIT0_EE5valueET_E4typeESD_SC_:
  528|  93.1M|                                                             T ptr) {
  529|  93.1M|  auto v = reinterpret_cast<uintptr_t>(ptr);
  530|       |  // Due to alignment, pointers tend to have low bits as zero, and the next few
  531|       |  // bits follow a pattern since they are also multiples of some base value.
  532|       |  // The PointerAlignment test verifies that our mixing is good enough to handle
  533|       |  // these cases.
  534|  93.1M|  return H::combine(std::move(hash_state), v);
  535|  93.1M|}
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineImJEEES3_S3_RKT_DpRKT0_:
 1492|  93.1M|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1493|  93.1M|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1494|  93.1M|                        std::move(state), value),
 1495|  93.1M|                    values...);
 1496|  93.1M|}
_ZN4absl12lts_2026010713hash_internal10HashSelect24UniquelyRepresentedProbe6InvokeINS1_15MixingHashStateEmEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES9_RKS8_:
 1260|  93.1M|        -> absl::enable_if_t<is_uniquely_represented<T>::value, H> {
 1261|  93.1M|      return hash_internal::hash_bytes(std::move(state), value);
 1262|  93.1M|    }
_ZN4absl12lts_2026010713hash_internal10hash_bytesINS1_15MixingHashStateEmTnNSt3__19enable_ifIXsr12FitsIn64BitsIT0_EE5valueEiE4typeELi0EEET_S9_RKS6_:
  406|  93.1M|H hash_bytes(H hash_state, const T& value) {
  407|  93.1M|  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
  408|  93.1M|  uint64_t v;
  409|       |  if constexpr (sizeof(T) == 1) {
  410|       |    v = *start;
  411|       |  } else if constexpr (sizeof(T) == 2) {
  412|       |    v = absl::base_internal::UnalignedLoad16(start);
  413|       |  } else if constexpr (sizeof(T) == 4) {
  414|       |    v = absl::base_internal::UnalignedLoad32(start);
  415|  93.1M|  } else {
  416|  93.1M|    static_assert(sizeof(T) == 8);
  417|  93.1M|    v = absl::base_internal::UnalignedLoad64(start);
  418|  93.1M|  }
  419|  93.1M|  return CombineRaw()(std::move(hash_state), v);
  420|  93.1M|}
_ZNK4absl12lts_2026010713hash_internal10CombineRawclINS1_15MixingHashStateEEET_S5_m:
  388|  93.1M|  H operator()(H state, uint64_t value) const {
  389|  93.1M|    return H::combine_raw(std::move(state), value);
  390|  93.1M|  }

_ZN4absl12lts_2026010712log_internal21GetReferenceableValueEm:
  550|  19.7M|inline constexpr unsigned long GetReferenceableValue(unsigned long t) {
  551|  19.7M|  return t;
  552|  19.7M|}
_ZN4absl12lts_2026010712log_internal12Check_LTImplImmEEPKcRKT_RKT0_S4_:
  489|  9.86M|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  9.86M|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  9.86M|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  9.86M|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  190|  9.86M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 9.86M, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 9.86M]
  |  |  |  Branch (190:57): [True: 9.86M, False: 0]
  |  |  ------------------
  ------------------
  493|  9.86M|               ? nullptr                                                   \
  494|  9.86M|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  9.86M|                                                        U2(v2), exprtext); \
  496|  9.86M|  }                                                                        \

_ZN4absl12lts_2026010712log_internal10LogMessage14InternalStreamEv:
  117|    661|  LogMessage& InternalStream() { return *this; }
_ZN4absl12lts_2026010712log_internal10LogMessagelsEi:
  132|    413|  LogMessage& operator<<(signed int v) { return operator<< <signed int>(v); }
_ZN4absl12lts_2026010712log_internal10LogMessagelsEm:
  145|    778|  LogMessage& operator<<(unsigned long v) {
  146|    778|    return operator<< <unsigned long>(v);
  147|    778|  }
_ZN4absl12lts_2026010712log_internal10LogMessagelsEf:
  157|    240|  LogMessage& operator<<(float v) { return operator<< <float>(v); }
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi2EEERS2_RAT__Kc:
  350|    533|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|    533|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|    533|  return *this;
  353|    533|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi32EEERS2_RAT__Kc:
  350|     48|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|     48|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|     48|  return *this;
  353|     48|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi21EEERS2_RAT__Kc:
  350|    365|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|    365|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|    365|  return *this;
  353|    365|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi20EEERS2_RAT__Kc:
  350|    365|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|    365|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|    365|  return *this;
  353|    365|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi11EEERS2_RAT__Kc:
  350|    365|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|    365|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|    365|  return *this;
  353|    365|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi56EEERS2_RAT__Kc:
  350|    120|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|    120|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|    120|  return *this;
  353|    120|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi10EEERS2_RAT__Kc:
  350|    360|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|    360|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|    360|  return *this;
  353|    360|}

_ZNKO4absl12lts_2026010712log_internal7VoidifyaaIRNS1_10LogMessageEEEvOT_:
   39|    661|  ABSL_ATTRIBUTE_COLD void operator&&(T&& message) const&& {
   40|       |    // The dispatching of the completed `absl::LogEntry` to applicable
   41|       |    // `absl::LogSink`s happens here.
   42|    661|    message.Flush();
   43|    661|  }

_ZN4absl12lts_2026010711countr_zeroItEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  123|  73.8M|    countr_zero(T x) noexcept {
  124|  73.8M|  return numeric_internal::CountTrailingZeroes(x);
  125|  73.8M|}

_ZN4absl12lts_202601077uint128mLES1_:
  646|   104M|inline uint128& uint128::operator*=(uint128 other) {
  647|   104M|  *this = *this * other;
  648|   104M|  return *this;
  649|   104M|}
_ZN4absl12lts_2026010712Uint128Low64ENS0_7uint128E:
  661|   104M|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl12lts_2026010713Uint128High64ENS0_7uint128E:
  663|   104M|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZNK4absl12lts_202601077uint128cvoEv:
  794|   208M|constexpr uint128::operator unsigned __int128() const {
  795|   208M|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  796|   208M|}
_ZN4absl12lts_20260107mlENS0_7uint128ES1_:
 1059|   104M|constexpr uint128 operator*(uint128 lhs, uint128 rhs) {
 1060|       |  // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
 1061|       |  // can be used for uint128 storage.
 1062|   104M|  return static_cast<unsigned __int128>(lhs) *
 1063|   104M|         static_cast<unsigned __int128>(rhs);
 1064|   104M|}
_ZN4absl12lts_202601077uint128C2Em:
  683|   208M|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
_ZN4absl12lts_202601077uint128C2Eo:
  692|   104M|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  693|   104M|      hi_{static_cast<uint64_t>(v >> 64)} {}

_ZN4absl12lts_2026010716numeric_internal28CountTrailingZeroesNonzero16Et:
  339|  73.8M|CountTrailingZeroesNonzero16(uint16_t x) {
  340|  73.8M|#if ABSL_HAVE_BUILTIN(__builtin_ctzg)
  341|  73.8M|  return __builtin_ctzg(x);
  342|       |#elif ABSL_HAVE_BUILTIN(__builtin_ctzs)
  343|       |  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
  344|       |                "__builtin_ctzs does not take 16-bit arg");
  345|       |  return __builtin_ctzs(x);
  346|       |#else
  347|       |  return CountTrailingZeroesNonzero32(x);
  348|       |#endif
  349|  73.8M|}
_ZN4absl12lts_2026010716numeric_internal19CountTrailingZeroesItEEiT_:
  353|  73.8M|CountTrailingZeroes(T x) noexcept {
  354|  73.8M|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  355|  73.8M|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  356|  73.8M|                "T must have a power-of-2 size");
  357|  73.8M|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  358|  73.8M|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (358:10): [True: 0, False: 73.8M]
  ------------------
  359|  73.8M|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (359:20): [True: 73.8M, Folded]
  ------------------
  360|  73.8M|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  361|  73.8M|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (361:27): [True: 0, Folded]
  ------------------
  362|      0|                              ? CountTrailingZeroesNonzero32(
  363|      0|                                    static_cast<uint32_t>(x))
  364|      0|                              : CountTrailingZeroesNonzero64(x)));
  365|  73.8M|}

_ZN4absl12lts_2026010719str_format_internal14ExtractCharSetILNS0_23FormatConversionCharSetE655355EEES3_NS1_16ArgConvertResultIXT_EEE:
  208|  3.60k|constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
  209|  3.60k|  return C;
  210|  3.60k|}
_ZN4absl12lts_2026010719str_format_internal13FormatArgImplC2IhEERKT_:
  500|  1.62k|  explicit FormatArgImpl(const T& value) {
  501|  1.62k|    using D = typename DecayType<T>::type;
  502|  1.62k|    static_assert(
  503|  1.62k|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  504|  1.62k|        "Decayed types must be stored by value");
  505|  1.62k|    Init(static_cast<D>(value));
  506|  1.62k|  }
_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl4InitIhEEvRKT_:
  553|  1.62k|  void Init(const T& value) {
  554|  1.62k|    data_ = Manager<T>::SetValue(value);
  555|  1.62k|    dispatcher_ = &Dispatch<T>;
  556|  1.62k|  }
_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl7ManagerIhLNS2_13StoragePolicyE2EE8SetValueERKh:
  539|  1.62k|    static Data SetValue(const T& value) {
  540|  1.62k|      Data data;
  541|  1.62k|      memcpy(data.buf, &value, sizeof(value));
  542|  1.62k|      return data;
  543|  1.62k|    }
_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl8DispatchIhEEbNS2_4DataENS1_24FormatConversionSpecImplEPv:
  594|  1.62k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  595|       |    // A `none` conv indicates that we want the `int` conversion.
  596|  1.62k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  189|  1.62k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1.62k]
  |  |  |  Branch (189:49): [Folded, False: 1.62k]
  |  |  |  Branch (189:58): [True: 0, False: 1.62k]
  |  |  ------------------
  ------------------
  597|  1.62k|                           FormatConversionCharInternal::kNone)) {
  598|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  599|      0|                      std::is_enum<T>());
  600|      0|    }
  601|  1.62k|    if (ABSL_PREDICT_FALSE(!Contains(ArgumentToConv<T>(),
  ------------------
  |  |  189|  1.62k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1.62k]
  |  |  |  Branch (189:49): [Folded, False: 1.62k]
  |  |  |  Branch (189:58): [True: 0, False: 1.62k]
  |  |  ------------------
  ------------------
  602|  1.62k|                                     spec.conversion_char()))) {
  603|      0|      return false;
  604|      0|    }
  605|  1.62k|    return str_format_internal::FormatConvertImpl(
  606|  1.62k|               Manager<T>::Value(arg), spec,
  607|  1.62k|               static_cast<FormatSinkImpl*>(out))
  608|  1.62k|        .value;
  609|  1.62k|  }
_ZN4absl12lts_2026010719str_format_internal14ArgumentToConvIhEENS0_23FormatConversionCharSetEv:
  425|  1.62k|constexpr FormatConversionCharSet ArgumentToConv() {
  426|  1.62k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  427|  1.62k|      std::declval<const Arg&>(),
  428|  1.62k|      std::declval<const FormatConversionSpecImpl&>(),
  429|  1.62k|      std::declval<FormatSinkImpl*>()));
  430|  1.62k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  431|  1.62k|}
_ZN4absl12lts_2026010719str_format_internal13FormatArgImpl7ManagerIhLNS2_13StoragePolicyE2EE5ValueENS2_4DataE:
  545|  1.62k|    static T Value(Data arg) {
  546|  1.62k|      T value;
  547|  1.62k|      memcpy(&value, arg.buf, sizeof(T));
  548|  1.62k|      return value;
  549|  1.62k|    }

_ZN4absl12lts_2026010719str_format_internal21UntypedFormatSpecImplC2ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   56|  2.28k|      : data_(s.data()), size_(s.size()) {}
_ZN4absl12lts_2026010719str_format_internal21UntypedFormatSpecImpl7ExtractINS1_18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE655355EEEEEERKS2_RKT_:
   73|  1.62k|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|  1.62k|    return s.spec_;
   75|  1.62k|  }
_ZN4absl12lts_2026010719str_format_internal18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE655355EEEC2EUa9enable_ifIXclL_ZNS1_15ValidFormatImplIJLS3_655355EEEEbNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEfL0p_EEEPKc:
  159|  1.62k|      : Base(s) {}

_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl15conversion_charEv:
  290|  30.8k|  FormatConversionChar conversion_char() const {
  291|       |    // Keep this field first in the struct . It generates better code when
  292|       |    // accessing it when ConversionSpec is passed by value in registers.
  293|  30.8k|    static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
  294|  30.8k|    return conv_;
  295|  30.8k|  }
_ZN4absl12lts_2026010719str_format_internal29FormatConversionCharToConvIntENS0_20FormatConversionCharE:
  360|  4.26k|constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
  361|  4.26k|  return uint64_t{1} << (1 + static_cast<uint8_t>(c));
  362|  4.26k|}
_ZN4absl12lts_2026010719str_format_internal8ContainsENS0_23FormatConversionCharSetENS0_20FormatConversionCharE:
  442|  4.26k|constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) {
  443|  4.26k|  return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
  444|  4.26k|}

_ZN4absl12lts_2026010716strings_internal9JoinRangeINSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEEEESA_RKT_NS3_17basic_string_viewIcS7_EE:
  322|    301|std::string JoinRange(const Range& range, absl::string_view separator) {
  323|    301|  using std::begin;
  324|    301|  using std::end;
  325|    301|  return JoinRange(begin(range), end(range), separator);
  326|    301|}
_ZN4absl12lts_2026010716strings_internal9JoinRangeINSt3__111__wrap_iterIPKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEESA_T_SE_NS3_17basic_string_viewIcS7_EE:
  306|    301|                      absl::string_view separator) {
  307|       |  // No formatter was explicitly given, so a default must be chosen.
  308|    301|  typedef typename std::iterator_traits<Iterator>::value_type ValueType;
  309|    301|  typedef typename DefaultFormatter<ValueType>::Type Formatter;
  310|    301|  return JoinAlgorithm(first, last, separator, Formatter());
  311|    301|}
_ZN4absl12lts_2026010716strings_internal13JoinAlgorithmINSt3__111__wrap_iterIPKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvEESA_T_SE_NS3_17basic_string_viewIcS7_EENS1_11NoFormatterE:
  236|    301|                          NoFormatter) {
  237|    301|  std::string result;
  238|    301|  if (start != end) {
  ------------------
  |  Branch (238:7): [True: 246, False: 55]
  ------------------
  239|       |    // Sums size
  240|    246|    auto&& start_value = *start;
  241|       |    // Use uint64_t to prevent size_t overflow. We assume it is not possible for
  242|       |    // in memory strings to overflow a uint64_t.
  243|    246|    uint64_t result_size = start_value.size();
  244|    751|    for (Iterator it = start; ++it != end;) {
  ------------------
  |  Branch (244:31): [True: 505, False: 246]
  ------------------
  245|    505|      result_size += s.size();
  246|    505|      result_size += (*it).size();
  247|    505|    }
  248|       |
  249|    246|    if (result_size > 0) {
  ------------------
  |  Branch (249:9): [True: 246, False: 0]
  ------------------
  250|    246|      constexpr uint64_t kMaxSize =
  251|    246|          uint64_t{(std::numeric_limits<size_t>::max)()};
  252|    246|      ABSL_INTERNAL_CHECK(result_size <= kMaxSize, "size_t overflow");
  ------------------
  |  |   85|    246|  do {                                                             \
  |  |   86|    246|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  189|    246|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 246]
  |  |  |  |  |  Branch (189:49): [Folded, False: 246]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 246]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   87|      0|      std::string death_message = "Check " #condition " failed: "; \
  |  |   88|      0|      death_message += std::string(message);                       \
  |  |   89|      0|      ABSL_INTERNAL_LOG(FATAL, death_message);                     \
  |  |  ------------------
  |  |  |  |   76|      0|  do {                                                                    \
  |  |  |  |   77|      0|    constexpr const char* absl_raw_log_internal_filename = __FILE__;      \
  |  |  |  |   78|      0|    ::absl::raw_log_internal::internal_log_function(                      \
  |  |  |  |   79|      0|        ABSL_RAW_LOG_INTERNAL_##severity, absl_raw_log_internal_filename, \
  |  |  |  |  ------------------
  |  |  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  |  |  ------------------
  |  |  |  |   80|      0|        __LINE__, message);                                               \
  |  |  |  |   81|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                   \
  |  |  |  |  ------------------
  |  |  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|    246|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 246]
  |  |  ------------------
  ------------------
  253|       |
  254|    246|      StringResizeAndOverwrite(
  255|    246|          result, static_cast<size_t>(result_size),
  256|    246|          [&start, &end, &start_value, s](char* result_buf,
  257|    246|                                          size_t result_buf_size) {
  258|       |            // Joins strings
  259|    246|            memcpy(result_buf, start_value.data(), start_value.size());
  260|    246|            result_buf += start_value.size();
  261|    246|            for (Iterator it = start; ++it != end;) {
  262|    246|              memcpy(result_buf, s.data(), s.size());
  263|    246|              result_buf += s.size();
  264|    246|              auto&& value = *it;
  265|    246|              memcpy(result_buf, value.data(), value.size());
  266|    246|              result_buf += value.size();
  267|    246|            }
  268|    246|            return result_buf_size;
  269|    246|          });
  270|    246|    }
  271|    246|  }
  272|    301|  return result;
  273|    301|}
_ZZN4absl12lts_2026010716strings_internal13JoinAlgorithmINSt3__111__wrap_iterIPKNS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvEESA_T_SE_NS3_17basic_string_viewIcS7_EENS1_11NoFormatterEENKUlPcmE_clESI_m:
  257|    246|                                          size_t result_buf_size) {
  258|       |            // Joins strings
  259|    246|            memcpy(result_buf, start_value.data(), start_value.size());
  260|    246|            result_buf += start_value.size();
  261|    751|            for (Iterator it = start; ++it != end;) {
  ------------------
  |  Branch (261:39): [True: 505, False: 246]
  ------------------
  262|    505|              memcpy(result_buf, s.data(), s.size());
  263|    505|              result_buf += s.size();
  264|    505|              auto&& value = *it;
  265|    505|              memcpy(result_buf, value.data(), value.size());
  266|    505|              result_buf += value.size();
  267|    505|            }
  268|    246|            return result_buf_size;
  269|    246|          });

_ZN4absl12lts_2026010716strings_internal23ConvertibleToStringViewC2ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   69|    564|      : value_(s) {}
_ZNK4absl12lts_2026010716strings_internal23ConvertibleToStringView5valueEv:
   77|    564|  absl::string_view value() const { return value_; }
_ZN4absl12lts_2026010716strings_internal8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEC2ES9_S3_S4_:
  296|    564|      : text_(std::move(input_text)),
  297|    564|        delimiter_(std::move(d)),
  298|    564|        predicate_(std::move(p)) {}
_ZNK4absl12lts_2026010716strings_internal8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEcvT_INS5_6vectorIS9_NS5_9allocatorIS9_EEEETnNS5_9enable_ifIXaantsr22ShouldUseLifetimeBoundIS9_SB_EE5valuesr23SplitterIsConvertibleToISB_EE5valueEDnE4typeELDn0EEEv:
  329|    564|  operator Container() const {
  330|    564|    return ConvertToContainer<Container, typename Container::value_type,
  331|    564|                              HasMappedType<Container>::value>()(*this);
  332|    564|  }
_ZNK4absl12lts_2026010716strings_internal8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE18ConvertToContainerINS5_6vectorIS9_NS5_9allocatorIS9_EEEES9_Lb0EEclERKSA_:
  429|    564|        const Splitter& splitter) const {
  430|    564|      struct raw_view {
  431|    564|        const char* data;
  432|    564|        size_t size;
  433|    564|        operator absl::string_view() const {  // NOLINT(runtime/explicit)
  434|    564|          return {data, size};
  435|    564|        }
  436|    564|      };
  437|    564|      std::vector<absl::string_view, A> v;
  438|    564|      std::array<raw_view, 16> ar;
  439|  1.12k|      for (auto it = splitter.begin(); !it.at_end();) {
  ------------------
  |  Branch (439:40): [True: 564, False: 564]
  ------------------
  440|    564|        size_t index = 0;
  441|  1.06k|        do {
  442|  1.06k|          ar[index].data = it->data();
  443|  1.06k|          ar[index].size = it->size();
  444|  1.06k|          ++it;
  445|  1.06k|        } while (++index != ar.size() && !it.at_end());
  ------------------
  |  Branch (445:18): [True: 1.06k, False: 0]
  |  Branch (445:42): [True: 504, False: 564]
  ------------------
  446|       |        // We static_cast index to a signed type to work around overzealous
  447|       |        // compiler warnings about signedness.
  448|    564|        v.insert(v.end(), ar.begin(),
  449|    564|                 ar.begin() + static_cast<ptrdiff_t>(index));
  450|    564|      }
  451|    564|      return v;
  452|    564|    }
_ZNK4absl12lts_2026010716strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEE6at_endEv:
  127|  2.19k|  bool at_end() const { return state_ == kEndState; }
_ZNK4absl12lts_2026010716strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEptEv:
  130|  2.13k|  pointer operator->() const { return &curr_; }
_ZZNK4absl12lts_2026010716strings_internal8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE18ConvertToContainerINS5_6vectorIS9_NS5_9allocatorIS9_EEEES9_Lb0EEclERKSA_ENK8raw_viewcvS9_Ev:
  433|  1.06k|        operator absl::string_view() const {  // NOLINT(runtime/explicit)
  434|  1.06k|          return {data, size};
  435|  1.06k|        }
_ZNK4absl12lts_2026010716strings_internal8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE5beginEv:
  307|    564|  const_iterator begin() const { return {const_iterator::kInitState, this}; }
_ZN4absl12lts_2026010716strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEC2ENSC_5StateEPKSB_:
  100|    564|      : pos_(0),
  101|    564|        state_(state),
  102|    564|        splitter_(splitter),
  103|    564|        delimiter_(splitter->delimiter()),
  104|    564|        predicate_(splitter->predicate()) {
  105|       |    // Hack to maintain backward compatibility. This one block makes it so an
  106|       |    // empty absl::string_view whose .data() happens to be nullptr behaves
  107|       |    // *differently* from an otherwise empty absl::string_view whose .data() is
  108|       |    // not nullptr. This is an undesirable difference in general, but this
  109|       |    // behavior is maintained to avoid breaking existing code that happens to
  110|       |    // depend on this old behavior/bug. Perhaps it will be fixed one day. The
  111|       |    // difference in behavior is as follows:
  112|       |    //   Split(absl::string_view(""), '-');  // {""}
  113|       |    //   Split(absl::string_view(), '-');    // {}
  114|    564|    if (splitter_->text().data() == nullptr) {
  ------------------
  |  Branch (114:9): [True: 0, False: 564]
  ------------------
  115|      0|      state_ = kEndState;
  116|      0|      pos_ = splitter_->text().size();
  117|      0|      return;
  118|      0|    }
  119|       |
  120|    564|    if (state_ == kEndState) {
  ------------------
  |  Branch (120:9): [True: 0, False: 564]
  ------------------
  121|      0|      pos_ = splitter_->text().size();
  122|    564|    } else {
  123|    564|      ++(*this);
  124|    564|    }
  125|    564|  }
_ZNK4absl12lts_2026010716strings_internal8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE9delimiterEv:
  301|    564|  const Delimiter& delimiter() const { return delimiter_; }
_ZNK4absl12lts_2026010716strings_internal8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE9predicateEv:
  302|    564|  const Predicate& predicate() const { return predicate_; }
_ZNK4absl12lts_2026010716strings_internal8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE4textEv:
  300|  1.63k|  absl::string_view text() const { return text_; }
_ZN4absl12lts_2026010716strings_internal13SplitIteratorINS1_8SplitterINS0_6ByCharENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEppEv:
  132|  1.63k|  SplitIterator& operator++() {
  133|  1.63k|    do {
  134|  1.63k|      if (state_ == kLastState) {
  ------------------
  |  Branch (134:11): [True: 564, False: 1.06k]
  ------------------
  135|    564|        state_ = kEndState;
  136|    564|        return *this;
  137|    564|      }
  138|  1.06k|      const absl::string_view text = splitter_->text();
  139|  1.06k|      const absl::string_view d = delimiter_.Find(text, pos_);
  140|  1.06k|      if (d.data() == text.data() + text.size()) state_ = kLastState;
  ------------------
  |  Branch (140:11): [True: 564, False: 504]
  ------------------
  141|  1.06k|      curr_ = text.substr(pos_,
  142|  1.06k|                          static_cast<size_t>(d.data() - (text.data() + pos_)));
  143|  1.06k|      pos_ += curr_.size() + d.size();
  144|  1.06k|    } while (!predicate_(curr_));
  ------------------
  |  Branch (144:14): [True: 0, False: 1.06k]
  ------------------
  145|  1.06k|    return *this;
  146|  1.63k|  }

_ZN4absl12lts_2026010710StartsWithENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   59|  1.66M|                                 absl::string_view prefix) noexcept {
   60|  1.66M|  if (prefix.empty()) {
  ------------------
  |  Branch (60:7): [True: 0, False: 1.66M]
  ------------------
   61|      0|    return true;
   62|      0|  }
   63|  1.66M|  if (text.size() < prefix.size()) {
  ------------------
  |  Branch (63:7): [True: 536k, False: 1.13M]
  ------------------
   64|   536k|    return false;
   65|   536k|  }
   66|  1.13M|  absl::string_view possible_match = text.substr(0, prefix.size());
   67|       |
   68|  1.13M|  return possible_match == prefix;
   69|  1.66M|}
_ZN4absl12lts_202601078EndsWithENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   75|   121M|                               absl::string_view suffix) noexcept {
   76|   121M|  if (suffix.empty()) {
  ------------------
  |  Branch (76:7): [True: 0, False: 121M]
  ------------------
   77|      0|    return true;
   78|      0|  }
   79|   121M|  if (text.size() < suffix.size()) {
  ------------------
  |  Branch (79:7): [True: 7, False: 121M]
  ------------------
   80|      7|    return false;
   81|      7|  }
   82|   121M|  absl::string_view possible_match = text.substr(text.size() - suffix.size());
   83|   121M|  return possible_match == suffix;
   84|   121M|}

_ZN4absl12lts_2026010724StringResizeAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_16strings_internal13JoinAlgorithmINS2_11__wrap_iterIPKS8_EEvEES8_T_SF_NS2_17basic_string_viewIcS5_EENS9_11NoFormatterEEUlPcmE_EEvRSF_NSF_9size_typeET0_:
  182|    246|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  183|    246|  strings_internal::StringResizeAndOverwriteImpl(str, n, std::move(op));
  184|       |#if defined(ABSL_HAVE_MEMORY_SANITIZER)
  185|       |  __msan_check_mem_is_initialized(str.data(), str.size());
  186|       |#endif
  187|    246|}
_ZN4absl12lts_2026010716strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS1_13JoinAlgorithmINS3_11__wrap_iterIPKS9_EEvEES9_T_SF_NS3_17basic_string_viewIcS6_EENS1_11NoFormatterEEUlPcmE_EEvRSF_NSF_9size_typeET0_:
  145|    246|void StringResizeAndOverwriteImpl(T& str, typename T::size_type n, Op op) {
  146|       |#ifdef ABSL_INTERNAL_HAS_RESIZE_AND_OVERWRITE
  147|       |  str.resize_and_overwrite(n, std::move(op));
  148|       |#else
  149|       |  if constexpr (strings_internal::
  150|       |                    has__google_nonstandard_backport_resize_and_overwrite<
  151|       |                        T>::value) {
  152|       |    str.__google_nonstandard_backport_resize_and_overwrite(n, std::move(op));
  153|       |  } else if constexpr (strings_internal::has__resize_and_overwrite<T>::value) {
  154|       |    str.__resize_and_overwrite(n, std::move(op));
  155|    246|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  156|    246|    str.__resize_default_init(n);
  157|    246|    str.__resize_default_init(
  158|    246|        static_cast<typename T::size_type>(std::move(op)(str.data(), n)));
  159|       |  } else if constexpr (strings_internal::has_Resize_and_overwrite<T>::value) {
  160|       |    str._Resize_and_overwrite(n, std::move(op));
  161|       |  } else {
  162|       |    strings_internal::StringResizeAndOverwriteFallback(str, n, std::move(op));
  163|       |  }
  164|    246|#endif
  165|    246|}

_ZN4absl12lts_202601078AlphaNumC2EPKc:
  365|    256|      : piece_(NullSafeStringView(c_str)) {}
_ZN4absl12lts_202601078AlphaNumC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  368|  3.34M|      : piece_(pc) {}
_ZN4absl12lts_202601076StrCatIJEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_8AlphaNumESB_SB_SB_SB_DpRKT_:
  567|    128|                                        const AlphaNum& e, const AV&... args) {
  568|    128|  return strings_internal::CatPieces(
  569|    128|      {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
  570|    128|       static_cast<const AlphaNum&>(args).Piece()...});
  571|    128|}
_ZNK4absl12lts_202601078AlphaNum5PieceEv:
  397|    640|  absl::string_view Piece() const { return piece_; }
_ZN4absl12lts_202601078AlphaNumC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE:
  387|    384|      : piece_(str) {}

_ZN4absl12lts_2026010717UntypedFormatSpecC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  111|  2.28k|  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
_ZN4absl12lts_202601079StrFormatIJhEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSB_:
  363|  1.62k|                                    const Args&... args) {
  364|  1.62k|  return str_format_internal::FormatPack(
  365|  1.62k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  366|  1.62k|      {str_format_internal::FormatArgImpl(args)...});
  367|  1.62k|}

_ZN4absl12lts_202601077StrJoinINSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEEEES9_RKT_NS2_17basic_string_viewIcS6_EE:
  276|    301|std::string StrJoin(const Range& range, absl::string_view separator) {
  277|    301|  return strings_internal::JoinRange(range, separator);
  278|    301|}

_ZN4absl12lts_202601078StrSplitIcEENS0_16strings_internal8SplitterINS2_15SelectDelimiterIT_E4typeENS0_10AllowEmptyENSt3__117basic_string_viewIcNS9_11char_traitsIcEEEEEENS2_23ConvertibleToStringViewES5_:
  534|    564|StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
  535|    564|  using DelimiterType =
  536|    564|      typename strings_internal::SelectDelimiter<Delimiter>::type;
  537|    564|  return strings_internal::Splitter<DelimiterType, AllowEmpty,
  538|    564|                                    absl::string_view>(
  539|    564|      text.value(), DelimiterType(d), AllowEmpty());
  540|    564|}
_ZN4absl12lts_202601076ByCharC2Ec:
  176|    564|  explicit ByChar(char c) : c_(c) {}
_ZNK4absl12lts_2026010710AllowEmptyclENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  348|  1.06k|  bool operator()(absl::string_view) const { return true; }

_ZN4absl12lts_2026010713ClippedSubstrENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEmm:
   43|  53.1M|                                 size_t pos, size_t n = string_view::npos) {
   44|  53.1M|  pos = (std::min)(pos, static_cast<size_t>(s.size()));
   45|  53.1M|  return s.substr(pos, n);
   46|  53.1M|}
_ZN4absl12lts_2026010718NullSafeStringViewEPKc:
   53|    256|constexpr string_view NullSafeStringView(const char* absl_nullable p) {
   54|    256|  return p ? string_view(p) : string_view();
  ------------------
  |  Branch (54:10): [True: 256, False: 0]
  ------------------
   55|    256|}

_ZN4absl12lts_2026010713ConsumePrefixEPNSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   49|  1.66M|                                    absl::string_view expected) {
   50|  1.66M|  if (!absl::StartsWith(*str, expected)) return false;
  ------------------
  |  Branch (50:7): [True: 1.12M, False: 538k]
  ------------------
   51|   538k|  str->remove_prefix(expected.size());
   52|   538k|  return true;
   53|  1.66M|}

_ZN4absl12lts_202601074SpanIKNS0_19str_format_internal13FormatArgImplEEC2IS4_S4_EESt16initializer_listIS3_E:
  310|  2.28k|      : Span(v.begin(), v.size()) {}
_ZN4absl12lts_202601074SpanIKNS0_19str_format_internal13FormatArgImplEEC2EPS4_m:
  230|  2.28k|      : ptr_(array), len_(length) {}

_ZN5Darts7Details15DoubleArrayUnitC2Ev:
   52|   524k|  DoubleArrayUnit() : unit_() {}
_ZNK5Darts7Details15DoubleArrayUnit8has_leafEv:
   56|  19.4M|  bool has_leaf() const {
   57|  19.4M|    return ((unit_ >> 8) & 1) == 1;
   58|  19.4M|  }
_ZNK5Darts7Details15DoubleArrayUnit5valueEv:
   61|  10.3M|  value_type value() const {
   62|  10.3M|    return static_cast<value_type>(unit_ & ((1U << 31) - 1));
   63|  10.3M|  }
_ZNK5Darts7Details15DoubleArrayUnit5labelEv:
   68|  90.5M|  id_type label() const {
   69|  90.5M|    return unit_ & ((1U << 31) | 0xFF);
   70|  90.5M|  }
_ZNK5Darts7Details15DoubleArrayUnit6offsetEv:
   72|  99.0M|  id_type offset() const {
   73|  99.0M|    return (unit_ >> 10) << ((unit_ & (1U << 9)) >> 6);
   74|  99.0M|  }
_ZN5Darts7Details9BitVectorC2Ev:
  796|  1.62k|  BitVector() : units_(), ranks_(), num_ones_(0), size_(0) {}
_ZN5Darts7Details9BitVectorD2Ev:
  797|  1.62k|  ~BitVector() {
  798|  1.62k|    clear();
  799|  1.62k|  }
_ZNK5Darts7Details9BitVectorixEm:
  801|  62.5k|  bool operator[](std::size_t id) const {
  802|  62.5k|    return (units_[id / UNIT_SIZE] >> (id % UNIT_SIZE) & 1) == 1;
  803|  62.5k|  }
_ZNK5Darts7Details9BitVector8num_onesEv:
  822|  3.24k|  std::size_t num_ones() const {
  823|  3.24k|    return num_ones_;
  824|  3.24k|  }
_ZNK5Darts7Details9BitVector4sizeEv:
  825|  47.2k|  std::size_t size() const {
  826|  47.2k|    return size_;
  827|  47.2k|  }
_ZN5Darts7Details9BitVector6appendEv:
  829|  47.2k|  void append() {
  830|  47.2k|    if ((size_ % UNIT_SIZE) == 0) {
  ------------------
  |  Branch (830:9): [True: 2.54k, False: 44.7k]
  ------------------
  831|  2.54k|      units_.append(0);
  832|  2.54k|    }
  833|  47.2k|    ++size_;
  834|  47.2k|  }
_ZN5Darts7Details9BitVector5clearEv:
  837|  4.86k|  void clear() {
  838|  4.86k|    units_.clear();
  839|  4.86k|    ranks_.clear();
  840|  4.86k|  }
_ZN5Darts7Details9BitVector9pop_countEj:
  854|  2.54k|  static id_type pop_count(id_type unit) {
  855|  2.54k|    unit = ((unit & 0xAAAAAAAA) >> 1) + (unit & 0x55555555);
  856|  2.54k|    unit = ((unit & 0xCCCCCCCC) >> 2) + (unit & 0x33333333);
  857|  2.54k|    unit = ((unit >> 4) + unit) & 0x0F0F0F0F;
  858|  2.54k|    unit += unit >> 8;
  859|  2.54k|    unit += unit >> 16;
  860|  2.54k|    return unit & 0xFF;
  861|  2.54k|  }
_ZN5Darts7Details8DawgNodeC2Ev:
  942|  47.2k|  DawgNode() : child_(0), sibling_(0), label_('\0'),
  943|  47.2k|    is_state_(false), has_sibling_(false) {}
_ZN5Darts7Details8DawgNode9set_childEj:
  945|  76.9k|  void set_child(id_type child) {
  946|  76.9k|    child_ = child;
  947|  76.9k|  }
_ZN5Darts7Details8DawgNode11set_siblingEj:
  948|  45.6k|  void set_sibling(id_type sibling) {
  949|  45.6k|    sibling_ = sibling;
  950|  45.6k|  }
_ZN5Darts7Details8DawgNode9set_valueEi:
  951|  16.0k|  void set_value(value_type value) {
  952|  16.0k|    child_ = value;
  953|  16.0k|  }
_ZN5Darts7Details8DawgNode9set_labelEh:
  954|  47.2k|  void set_label(uchar_type label) {
  955|  47.2k|    label_ = label;
  956|  47.2k|  }
_ZN5Darts7Details8DawgNode12set_is_stateEb:
  957|  31.2k|  void set_is_state(bool is_state) {
  958|  31.2k|    is_state_ = is_state;
  959|  31.2k|  }
_ZN5Darts7Details8DawgNode15set_has_siblingEb:
  960|  14.3k|  void set_has_sibling(bool has_sibling) {
  961|  14.3k|    has_sibling_ = has_sibling;
  962|  14.3k|  }
_ZNK5Darts7Details8DawgNode5childEv:
  964|   115k|  id_type child() const {
  965|   115k|    return child_;
  966|   115k|  }
_ZNK5Darts7Details8DawgNode7siblingEv:
  967|   183k|  id_type sibling() const {
  968|   183k|    return sibling_;
  969|   183k|  }
_ZNK5Darts7Details8DawgNode5labelEv:
  973|   115k|  uchar_type label() const {
  974|   115k|    return label_;
  975|   115k|  }
_ZNK5Darts7Details8DawgNode4unitEv:
  983|  93.5k|  id_type unit() const {
  984|  93.5k|    if (label_ == '\0') {
  ------------------
  |  Branch (984:9): [True: 32.2k, False: 61.2k]
  ------------------
  985|  32.2k|      return (child_ << 1) | (has_sibling_ ? 1 : 0);
  ------------------
  |  Branch (985:31): [True: 5.50k, False: 26.7k]
  ------------------
  986|  32.2k|    }
  987|  61.2k|    return (child_ << 2) | (is_state_ ? 2 : 0) | (has_sibling_ ? 1 : 0);
  ------------------
  |  Branch (987:29): [True: 30.8k, False: 30.4k]
  |  Branch (987:51): [True: 23.2k, False: 37.9k]
  ------------------
  988|  93.5k|  }
_ZN5Darts7Details8DawgUnitC2Ej:
 1006|  47.2k|  explicit DawgUnit(id_type unit = 0) : unit_(unit) {}
_ZN5Darts7Details8DawgUnitC2ERKS1_:
 1007|  67.6k|  DawgUnit(const DawgUnit &unit) : unit_(unit.unit_) {}
_ZN5Darts7Details8DawgUnitaSEj:
 1009|  47.2k|  DawgUnit &operator=(id_type unit) {
 1010|  47.2k|    unit_ = unit;
 1011|  47.2k|    return *this;
 1012|  47.2k|  }
_ZNK5Darts7Details8DawgUnit4unitEv:
 1014|    548|  id_type unit() const {
 1015|    548|    return unit_;
 1016|    548|  }
_ZNK5Darts7Details8DawgUnit5childEv:
 1018|  95.4k|  id_type child() const {
 1019|  95.4k|    return unit_ >> 2;
 1020|  95.4k|  }
_ZNK5Darts7Details8DawgUnit11has_siblingEv:
 1021|   137k|  bool has_sibling() const {
 1022|   137k|    return (unit_ & 1) == 1;
 1023|   137k|  }
_ZNK5Darts7Details8DawgUnit5valueEv:
 1024|  16.0k|  value_type value() const {
 1025|  16.0k|    return static_cast<value_type>(unit_ >> 1);
 1026|  16.0k|  }
_ZN5Darts7Details11DawgBuilderC2Ev:
 1043|  1.62k|  DawgBuilder() : nodes_(), units_(), labels_(), is_intersections_(),
 1044|  1.62k|    table_(), node_stack_(), recycle_bin_(), num_states_(0) {}
_ZN5Darts7Details11DawgBuilderD2Ev:
 1045|  1.62k|  ~DawgBuilder() {
 1046|  1.62k|    clear();
 1047|  1.62k|  }
_ZNK5Darts7Details11DawgBuilder4rootEv:
 1049|  3.24k|  id_type root() const {
 1050|  3.24k|    return 0;
 1051|  3.24k|  }
_ZNK5Darts7Details11DawgBuilder5childEj:
 1053|  95.4k|  id_type child(id_type id) const {
 1054|  95.4k|    return units_[id].child();
 1055|  95.4k|  }
_ZNK5Darts7Details11DawgBuilder7siblingEj:
 1056|   137k|  id_type sibling(id_type id) const {
 1057|   137k|    return units_[id].has_sibling() ? (id + 1) : 0;
  ------------------
  |  Branch (1057:12): [True: 43.1k, False: 93.8k]
  ------------------
 1058|   137k|  }
_ZNK5Darts7Details11DawgBuilder5valueEj:
 1059|  16.0k|  int value(id_type id) const {
 1060|  16.0k|    return units_[id].value();
 1061|  16.0k|  }
_ZNK5Darts7Details11DawgBuilder7is_leafEj:
 1063|  45.6k|  bool is_leaf(id_type id) const {
 1064|  45.6k|    return label(id) == '\0';
 1065|  45.6k|  }
_ZNK5Darts7Details11DawgBuilder5labelEj:
 1066|   137k|  uchar_type label(id_type id) const {
 1067|   137k|    return labels_[id];
 1068|   137k|  }
_ZNK5Darts7Details11DawgBuilder15is_intersectionEj:
 1070|  62.5k|  bool is_intersection(id_type id) const {
 1071|  62.5k|    return is_intersections_[id];
 1072|  62.5k|  }
_ZNK5Darts7Details11DawgBuilder17num_intersectionsEv:
 1077|  3.24k|  std::size_t num_intersections() const {
 1078|  3.24k|    return is_intersections_.num_ones();
 1079|  3.24k|  }
_ZNK5Darts7Details11DawgBuilder4sizeEv:
 1081|  9.00k|  std::size_t size() const {
 1082|  9.00k|    return units_.size();
 1083|  9.00k|  }
_ZN5Darts7Details11DawgBuilder9free_nodeEj:
 1123|  45.6k|  void free_node(id_type id) {
 1124|  45.6k|    recycle_bin_.push(id);
 1125|  45.6k|  }
_ZN5Darts7Details11DawgBuilder4hashEj:
 1127|  45.6k|  static id_type hash(id_type key) {
 1128|  45.6k|    key = ~key + (key << 15);  // key = (key << 15) - key - 1;
 1129|  45.6k|    key = key ^ (key >> 12);
 1130|  45.6k|    key = key + (key << 2);
 1131|  45.6k|    key = key ^ (key >> 4);
 1132|  45.6k|    key = key * 2057;  // key = (key + (key << 3)) + (key << 11);
 1133|  45.6k|    key = key ^ (key >> 16);
 1134|  45.6k|    return key;
 1135|  45.6k|  }
_ZN5Darts7Details22DoubleArrayBuilderUnitC2Ev:
 1389|   524k|  DoubleArrayBuilderUnit() : unit_(0) {}
_ZN5Darts7Details22DoubleArrayBuilderUnit12set_has_leafEb:
 1391|  16.5k|  void set_has_leaf(bool has_leaf) {
 1392|  16.5k|    if (has_leaf) {
  ------------------
  |  Branch (1392:9): [True: 16.5k, False: 0]
  ------------------
 1393|  16.5k|      unit_ |= 1U << 8;
 1394|  16.5k|    } else {
 1395|      0|      unit_ &= ~(1U << 8);
 1396|      0|    }
 1397|  16.5k|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit9set_valueEi:
 1398|  16.5k|  void set_value(value_type value) {
 1399|  16.5k|    unit_ = value | (1U << 31);
 1400|  16.5k|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit9set_labelEh:
 1401|   507k|  void set_label(uchar_type label) {
 1402|   507k|    unit_ = (unit_ & ~0xFFU) | label;
 1403|   507k|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit10set_offsetEj:
 1404|  35.6k|  void set_offset(id_type offset) {
 1405|  35.6k|    if (offset >= 1U << 29) {
  ------------------
  |  Branch (1405:9): [True: 0, False: 35.6k]
  ------------------
 1406|      0|      DARTS_THROW("failed to modify unit: too large offset");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1407|      0|    }
 1408|  35.6k|    unit_ &= (1U << 31) | (1U << 8) | 0xFF;
 1409|  35.6k|    if (offset < 1U << 21) {
  ------------------
  |  Branch (1409:9): [True: 35.6k, False: 0]
  ------------------
 1410|  35.6k|      unit_ |= (offset << 10);
 1411|  35.6k|    } else {
 1412|      0|      unit_ |= (offset << 2) | (1U << 9);
 1413|      0|    }
 1414|  35.6k|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnitC2Ev:
 1428|  8.38M|  DoubleArrayBuilderExtraUnit() : prev_(0), next_(0),
 1429|  8.38M|      is_fixed_(false), is_used_(false) {}
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit8set_prevEj:
 1431|  1.05M|  void set_prev(id_type prev) {
 1432|  1.05M|    prev_ = prev;
 1433|  1.05M|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit8set_nextEj:
 1434|  1.05M|  void set_next(id_type next) {
 1435|  1.05M|    next_ = next;
 1436|  1.05M|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit12set_is_fixedEb:
 1437|   524k|  void set_is_fixed(bool is_fixed) {
 1438|   524k|    is_fixed_ = is_fixed;
 1439|   524k|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit11set_is_usedEb:
 1440|  35.6k|  void set_is_used(bool is_used) {
 1441|  35.6k|    is_used_ = is_used;
 1442|  35.6k|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit4prevEv:
 1444|  1.05M|  id_type prev() const {
 1445|  1.05M|    return prev_;
 1446|  1.05M|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit4nextEv:
 1447|  1.56M|  id_type next() const {
 1448|  1.56M|    return next_;
 1449|  1.56M|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit8is_fixedEv:
 1450|   546k|  bool is_fixed() const {
 1451|   546k|    return is_fixed_;
 1452|   546k|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit7is_usedEv:
 1453|  51.6k|  bool is_used() const {
 1454|  51.6k|    return is_used_;
 1455|  51.6k|  }
_ZN5Darts7Details18DoubleArrayBuilderC2EPFimmE:
 1473|  2.04k|      : progress_func_(progress_func), units_(), extras_(), labels_(),
 1474|  2.04k|        table_(), extras_head_(0) {}
_ZN5Darts7Details18DoubleArrayBuilderD2Ev:
 1475|  2.04k|  ~DoubleArrayBuilder() {
 1476|  2.04k|    clear();
 1477|  2.04k|  }
_ZNK5Darts7Details18DoubleArrayBuilder10num_blocksEv:
 1507|  6.14k|  std::size_t num_blocks() const {
 1508|  6.14k|    return units_.size() / BLOCK_SIZE;
 1509|  6.14k|  }
_ZNK5Darts7Details18DoubleArrayBuilder6extrasEj:
 1511|  83.1k|  const extra_type &extras(id_type id) const {
 1512|  83.1k|    return extras_[id % NUM_EXTRAS];
 1513|  83.1k|  }
_ZN5Darts7Details18DoubleArrayBuilder6extrasEj:
 1514|  5.80M|  extra_type &extras(id_type id) {
 1515|  5.80M|    return extras_[id % NUM_EXTRAS];
 1516|  5.80M|  }
_ZN5Darts7Details9BitVector5buildEv:
  864|  1.62k|inline void BitVector::build() {
  865|  1.62k|  try {
  866|  1.62k|    ranks_.reset(new id_type[units_.size()]);
  867|  1.62k|  } catch (const std::bad_alloc &) {
  868|      0|    DARTS_THROW("failed to build rank index: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  869|      0|  }
  870|       |
  871|  1.62k|  num_ones_ = 0;
  872|  4.17k|  for (std::size_t i = 0; i < units_.size(); ++i) {
  ------------------
  |  Branch (872:27): [True: 2.54k, False: 1.62k]
  ------------------
  873|  2.54k|    ranks_[i] = num_ones_;
  874|  2.54k|    num_ones_ += pop_count(units_[i]);
  875|  2.54k|  }
  876|  1.62k|}
_ZN5Darts7Details11DawgBuilder4initEv:
 1138|  1.62k|inline void DawgBuilder::init() {
 1139|  1.62k|  table_.resize(INITIAL_TABLE_SIZE, 0);
 1140|       |
 1141|  1.62k|  append_node();
 1142|  1.62k|  append_unit();
 1143|       |
 1144|  1.62k|  num_states_ = 1;
 1145|       |
 1146|  1.62k|  nodes_[0].set_label(0xFF);
 1147|  1.62k|  node_stack_.push(0);
 1148|  1.62k|}
_ZN5Darts7Details11DawgBuilder6finishEv:
 1150|  1.62k|inline void DawgBuilder::finish() {
 1151|  1.62k|  flush(0);
 1152|       |
 1153|  1.62k|  units_[0] = nodes_[0].unit();
 1154|  1.62k|  labels_[0] = nodes_[0].label();
 1155|       |
 1156|  1.62k|  nodes_.clear();
 1157|  1.62k|  table_.clear();
 1158|  1.62k|  node_stack_.clear();
 1159|  1.62k|  recycle_bin_.clear();
 1160|       |
 1161|  1.62k|  is_intersections_.build();
 1162|  1.62k|}
_ZN5Darts7Details11DawgBuilder6insertEPKcmi:
 1165|  16.0k|    value_type value) {
 1166|  16.0k|  if (value < 0) {
  ------------------
  |  Branch (1166:7): [True: 0, False: 16.0k]
  ------------------
 1167|      0|    DARTS_THROW("failed to insert key: negative value");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1168|  16.0k|  } else if (length == 0) {
  ------------------
  |  Branch (1168:14): [True: 0, False: 16.0k]
  ------------------
 1169|      0|    DARTS_THROW("failed to insert key: zero-length key");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1170|      0|  }
 1171|       |
 1172|  16.0k|  id_type id = 0;
 1173|  16.0k|  std::size_t key_pos = 0;
 1174|       |
 1175|  24.5k|  for ( ; key_pos <= length; ++key_pos) {
  ------------------
  |  Branch (1175:11): [True: 24.5k, False: 0]
  ------------------
 1176|  24.5k|    id_type child_id = nodes_[id].child();
 1177|  24.5k|    if (child_id == 0) {
  ------------------
  |  Branch (1177:9): [True: 1.62k, False: 22.8k]
  ------------------
 1178|  1.62k|      break;
 1179|  1.62k|    }
 1180|       |
 1181|  22.8k|    uchar_type key_label = static_cast<uchar_type>(key[key_pos]);
 1182|  22.8k|    if (key_pos < length && key_label == '\0') {
  ------------------
  |  Branch (1182:9): [True: 22.8k, False: 0]
  |  Branch (1182:29): [True: 0, False: 22.8k]
  ------------------
 1183|      0|      DARTS_THROW("failed to insert key: invalid null character");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1184|      0|    }
 1185|       |
 1186|  22.8k|    uchar_type unit_label = nodes_[child_id].label();
 1187|  22.8k|    if (key_label < unit_label) {
  ------------------
  |  Branch (1187:9): [True: 0, False: 22.8k]
  ------------------
 1188|      0|      DARTS_THROW("failed to insert key: wrong key order");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1189|  22.8k|    } else if (key_label > unit_label) {
  ------------------
  |  Branch (1189:16): [True: 14.3k, False: 8.49k]
  ------------------
 1190|  14.3k|      nodes_[child_id].set_has_sibling(true);
 1191|  14.3k|      flush(child_id);
 1192|  14.3k|      break;
 1193|  14.3k|    }
 1194|  8.49k|    id = child_id;
 1195|  8.49k|  }
 1196|       |
 1197|  16.0k|  if (key_pos > length) {
  ------------------
  |  Branch (1197:7): [True: 0, False: 16.0k]
  ------------------
 1198|      0|    return;
 1199|      0|  }
 1200|       |
 1201|  61.6k|  for ( ; key_pos <= length; ++key_pos) {
  ------------------
  |  Branch (1201:11): [True: 45.6k, False: 16.0k]
  ------------------
 1202|  45.6k|    uchar_type key_label = static_cast<uchar_type>(
 1203|  45.6k|        (key_pos < length) ? key[key_pos] : '\0');
  ------------------
  |  Branch (1203:9): [True: 29.6k, False: 16.0k]
  ------------------
 1204|  45.6k|    id_type child_id = append_node();
 1205|       |
 1206|  45.6k|    if (nodes_[id].child() == 0) {
  ------------------
  |  Branch (1206:9): [True: 31.2k, False: 14.3k]
  ------------------
 1207|  31.2k|      nodes_[child_id].set_is_state(true);
 1208|  31.2k|    }
 1209|  45.6k|    nodes_[child_id].set_sibling(nodes_[id].child());
 1210|  45.6k|    nodes_[child_id].set_label(key_label);
 1211|  45.6k|    nodes_[id].set_child(child_id);
 1212|  45.6k|    node_stack_.push(child_id);
 1213|       |
 1214|  45.6k|    id = child_id;
 1215|  45.6k|  }
 1216|  16.0k|  nodes_[id].set_value(value);
 1217|  16.0k|}
_ZN5Darts7Details11DawgBuilder5clearEv:
 1219|  3.24k|inline void DawgBuilder::clear() {
 1220|  3.24k|  nodes_.clear();
 1221|  3.24k|  units_.clear();
 1222|  3.24k|  labels_.clear();
 1223|  3.24k|  is_intersections_.clear();
 1224|  3.24k|  table_.clear();
 1225|  3.24k|  node_stack_.clear();
 1226|  3.24k|  recycle_bin_.clear();
 1227|  3.24k|  num_states_ = 0;
 1228|  3.24k|}
_ZN5Darts7Details11DawgBuilder5flushEj:
 1230|  16.0k|inline void DawgBuilder::flush(id_type id) {
 1231|  47.2k|  while (node_stack_.top() != id) {
  ------------------
  |  Branch (1231:10): [True: 31.2k, False: 16.0k]
  ------------------
 1232|  31.2k|    id_type node_id = node_stack_.top();
 1233|  31.2k|    node_stack_.pop();
 1234|       |
 1235|  31.2k|    if (num_states_ >= table_.size() - (table_.size() >> 2)) {
  ------------------
  |  Branch (1235:9): [True: 0, False: 31.2k]
  ------------------
 1236|      0|      expand_table();
 1237|      0|    }
 1238|       |
 1239|  31.2k|    id_type num_siblings = 0;
 1240|  76.9k|    for (id_type i = node_id; i != 0; i = nodes_[i].sibling()) {
  ------------------
  |  Branch (1240:31): [True: 45.6k, False: 31.2k]
  ------------------
 1241|  45.6k|      ++num_siblings;
 1242|  45.6k|    }
 1243|       |
 1244|  31.2k|    id_type hash_id;
 1245|  31.2k|    id_type match_id = find_node(node_id, &hash_id);
 1246|  31.2k|    if (match_id != 0) {
  ------------------
  |  Branch (1246:9): [True: 0, False: 31.2k]
  ------------------
 1247|      0|      is_intersections_.set(match_id, true);
 1248|  31.2k|    } else {
 1249|  31.2k|      id_type unit_id = 0;
 1250|  76.9k|      for (id_type i = 0; i < num_siblings; ++i) {
  ------------------
  |  Branch (1250:27): [True: 45.6k, False: 31.2k]
  ------------------
 1251|  45.6k|        unit_id = append_unit();
 1252|  45.6k|      }
 1253|  76.9k|      for (id_type i = node_id; i != 0; i = nodes_[i].sibling()) {
  ------------------
  |  Branch (1253:33): [True: 45.6k, False: 31.2k]
  ------------------
 1254|  45.6k|        units_[unit_id] = nodes_[i].unit();
 1255|  45.6k|        labels_[unit_id] = nodes_[i].label();
 1256|  45.6k|        --unit_id;
 1257|  45.6k|      }
 1258|  31.2k|      match_id = unit_id + 1;
 1259|  31.2k|      table_[hash_id] = match_id;
 1260|  31.2k|      ++num_states_;
 1261|  31.2k|    }
 1262|       |
 1263|  76.9k|    for (id_type i = node_id, next; i != 0; i = next) {
  ------------------
  |  Branch (1263:37): [True: 45.6k, False: 31.2k]
  ------------------
 1264|  45.6k|      next = nodes_[i].sibling();
 1265|  45.6k|      free_node(i);
 1266|  45.6k|    }
 1267|       |
 1268|  31.2k|    nodes_[node_stack_.top()].set_child(match_id);
 1269|  31.2k|  }
 1270|  16.0k|  node_stack_.pop();
 1271|  16.0k|}
_ZNK5Darts7Details11DawgBuilder9find_nodeEjPj:
 1302|  31.2k|    id_type *hash_id) const {
 1303|  31.2k|  *hash_id = hash_node(node_id) % table_.size();
 1304|  31.9k|  for ( ; ; *hash_id = (*hash_id + 1) % table_.size()) {
 1305|  31.9k|    id_type unit_id = table_[*hash_id];
 1306|  31.9k|    if (unit_id == 0) {
  ------------------
  |  Branch (1306:9): [True: 31.2k, False: 690]
  ------------------
 1307|  31.2k|      break;
 1308|  31.2k|    }
 1309|       |
 1310|    690|    if (are_equal(node_id, unit_id)) {
  ------------------
  |  Branch (1310:9): [True: 0, False: 690]
  ------------------
 1311|      0|      return unit_id;
 1312|      0|    }
 1313|    690|  }
 1314|  31.2k|  return 0;
 1315|  31.2k|}
_ZNK5Darts7Details11DawgBuilder9are_equalEjj:
 1317|    690|inline bool DawgBuilder::are_equal(id_type node_id, id_type unit_id) const {
 1318|    711|  for (id_type i = nodes_[node_id].sibling(); i != 0;
  ------------------
  |  Branch (1318:47): [True: 98, False: 613]
  ------------------
 1319|    690|      i = nodes_[i].sibling()) {
 1320|     98|    if (units_[unit_id].has_sibling() == false) {
  ------------------
  |  Branch (1320:9): [True: 77, False: 21]
  ------------------
 1321|     77|      return false;
 1322|     77|    }
 1323|     21|    ++unit_id;
 1324|     21|  }
 1325|    613|  if (units_[unit_id].has_sibling() == true) {
  ------------------
  |  Branch (1325:7): [True: 65, False: 548]
  ------------------
 1326|     65|    return false;
 1327|     65|  }
 1328|       |
 1329|    548|  for (id_type i = node_id; i != 0; i = nodes_[i].sibling(), --unit_id) {
  ------------------
  |  Branch (1329:29): [True: 548, False: 0]
  ------------------
 1330|    548|    if (nodes_[i].unit() != units_[unit_id].unit() ||
  ------------------
  |  Branch (1330:9): [True: 547, False: 1]
  ------------------
 1331|    548|        nodes_[i].label() != labels_[unit_id]) {
  ------------------
  |  Branch (1331:9): [True: 1, False: 0]
  ------------------
 1332|    548|      return false;
 1333|    548|    }
 1334|    548|  }
 1335|      0|  return true;
 1336|    548|}
_ZNK5Darts7Details11DawgBuilder9hash_nodeEj:
 1352|  31.2k|inline id_type DawgBuilder::hash_node(id_type id) const {
 1353|  31.2k|  id_type hash_value = 0;
 1354|  76.9k|  for ( ; id != 0; id = nodes_[id].sibling()) {
  ------------------
  |  Branch (1354:11): [True: 45.6k, False: 31.2k]
  ------------------
 1355|  45.6k|    id_type unit = nodes_[id].unit();
 1356|  45.6k|    uchar_type label = nodes_[id].label();
 1357|  45.6k|    hash_value ^= hash((label << 24) ^ unit);
 1358|  45.6k|  }
 1359|  31.2k|  return hash_value;
 1360|  31.2k|}
_ZN5Darts7Details11DawgBuilder11append_unitEv:
 1362|  47.2k|inline id_type DawgBuilder::append_unit() {
 1363|  47.2k|  is_intersections_.append();
 1364|  47.2k|  units_.append();
 1365|  47.2k|  labels_.append();
 1366|       |
 1367|  47.2k|  return static_cast<id_type>(is_intersections_.size() - 1);
 1368|  47.2k|}
_ZN5Darts7Details11DawgBuilder11append_nodeEv:
 1370|  47.2k|inline id_type DawgBuilder::append_node() {
 1371|  47.2k|  id_type id;
 1372|  47.2k|  if (recycle_bin_.empty()) {
  ------------------
  |  Branch (1372:7): [True: 21.1k, False: 26.1k]
  ------------------
 1373|  21.1k|    id = static_cast<id_type>(nodes_.size());
 1374|  21.1k|    nodes_.append();
 1375|  26.1k|  } else {
 1376|  26.1k|    id = recycle_bin_.top();
 1377|  26.1k|    nodes_[id] = DawgNode();
 1378|  26.1k|    recycle_bin_.pop();
 1379|  26.1k|  }
 1380|  47.2k|  return id;
 1381|  47.2k|}
_ZNK5Darts7Details18DoubleArrayBuilder4copyEPmPPNS0_15DoubleArrayUnitE:
 1558|  2.04k|    DoubleArrayUnit **buf_ptr) const {
 1559|  2.04k|  if (size_ptr != NULL) {
  ------------------
  |  Branch (1559:7): [True: 2.04k, False: 0]
  ------------------
 1560|  2.04k|    *size_ptr = units_.size();
 1561|  2.04k|  }
 1562|  2.04k|  if (buf_ptr != NULL) {
  ------------------
  |  Branch (1562:7): [True: 2.04k, False: 0]
  ------------------
 1563|  2.04k|    *buf_ptr = new DoubleArrayUnit[units_.size()];
 1564|  2.04k|    unit_type *units = reinterpret_cast<unit_type *>(*buf_ptr);
 1565|   526k|    for (std::size_t i = 0; i < units_.size(); ++i) {
  ------------------
  |  Branch (1565:29): [True: 524k, False: 2.04k]
  ------------------
 1566|   524k|      units[i] = units_[i];
 1567|   524k|    }
 1568|  2.04k|  }
 1569|  2.04k|}
_ZN5Darts7Details18DoubleArrayBuilder5clearEv:
 1571|  2.04k|inline void DoubleArrayBuilder::clear() {
 1572|  2.04k|  units_.clear();
 1573|  2.04k|  extras_.clear();
 1574|  2.04k|  labels_.clear();
 1575|  2.04k|  table_.clear();
 1576|  2.04k|  extras_head_ = 0;
 1577|  2.04k|}
_ZN5Darts7Details18DoubleArrayBuilder15build_from_dawgERKNS0_11DawgBuilderE:
 1592|  1.62k|inline void DoubleArrayBuilder::build_from_dawg(const DawgBuilder &dawg) {
 1593|  1.62k|  std::size_t num_units = 1;
 1594|  9.00k|  while (num_units < dawg.size()) {
  ------------------
  |  Branch (1594:10): [True: 7.37k, False: 1.62k]
  ------------------
 1595|  7.37k|    num_units <<= 1;
 1596|  7.37k|  }
 1597|  1.62k|  units_.reserve(num_units);
 1598|       |
 1599|  1.62k|  table_.reset(new id_type[dawg.num_intersections()]);
 1600|  1.62k|  for (std::size_t i = 0; i < dawg.num_intersections(); ++i) {
  ------------------
  |  Branch (1600:27): [True: 0, False: 1.62k]
  ------------------
 1601|      0|    table_[i] = 0;
 1602|      0|  }
 1603|       |
 1604|  1.62k|  extras_.reset(new extra_type[NUM_EXTRAS]);
 1605|       |
 1606|  1.62k|  reserve_id(0);
 1607|  1.62k|  extras(0).set_is_used(true);
 1608|  1.62k|  units_[0].set_offset(1);
 1609|  1.62k|  units_[0].set_label('\0');
 1610|       |
 1611|  1.62k|  if (dawg.child(dawg.root()) != 0) {
  ------------------
  |  Branch (1611:7): [True: 1.62k, False: 0]
  ------------------
 1612|  1.62k|    build_from_dawg(dawg, dawg.root(), 0);
 1613|  1.62k|  }
 1614|       |
 1615|  1.62k|  fix_all_blocks();
 1616|       |
 1617|  1.62k|  extras_.clear();
 1618|  1.62k|  labels_.clear();
 1619|  1.62k|  table_.clear();
 1620|  1.62k|}
_ZN5Darts7Details18DoubleArrayBuilder15build_from_dawgERKNS0_11DawgBuilderEjj:
 1623|  31.2k|    id_type dawg_id, id_type dic_id) {
 1624|  31.2k|  id_type dawg_child_id = dawg.child(dawg_id);
 1625|  31.2k|  if (dawg.is_intersection(dawg_child_id)) {
  ------------------
  |  Branch (1625:7): [True: 0, False: 31.2k]
  ------------------
 1626|      0|    id_type intersection_id = dawg.intersection_id(dawg_child_id);
 1627|      0|    id_type offset = table_[intersection_id];
 1628|      0|    if (offset != 0) {
  ------------------
  |  Branch (1628:9): [True: 0, False: 0]
  ------------------
 1629|      0|      offset ^= dic_id;
 1630|      0|      if (!(offset & UPPER_MASK) || !(offset & LOWER_MASK)) {
  ------------------
  |  Branch (1630:11): [True: 0, False: 0]
  |  Branch (1630:37): [True: 0, False: 0]
  ------------------
 1631|      0|        if (dawg.is_leaf(dawg_child_id)) {
  ------------------
  |  Branch (1631:13): [True: 0, False: 0]
  ------------------
 1632|      0|          units_[dic_id].set_has_leaf(true);
 1633|      0|        }
 1634|      0|        units_[dic_id].set_offset(offset);
 1635|      0|        return;
 1636|      0|      }
 1637|      0|    }
 1638|      0|  }
 1639|       |
 1640|  31.2k|  id_type offset = arrange_from_dawg(dawg, dawg_id, dic_id);
 1641|  31.2k|  if (dawg.is_intersection(dawg_child_id)) {
  ------------------
  |  Branch (1641:7): [True: 0, False: 31.2k]
  ------------------
 1642|      0|    table_[dawg.intersection_id(dawg_child_id)] = offset;
 1643|      0|  }
 1644|       |
 1645|  45.6k|  do {
 1646|  45.6k|    uchar_type child_label = dawg.label(dawg_child_id);
 1647|  45.6k|    id_type dic_child_id = offset ^ child_label;
 1648|  45.6k|    if (child_label != '\0') {
  ------------------
  |  Branch (1648:9): [True: 29.6k, False: 16.0k]
  ------------------
 1649|  29.6k|      build_from_dawg(dawg, dawg_child_id, dic_child_id);
 1650|  29.6k|    }
 1651|  45.6k|    dawg_child_id = dawg.sibling(dawg_child_id);
 1652|  45.6k|  } while (dawg_child_id != 0);
  ------------------
  |  Branch (1652:12): [True: 14.3k, False: 31.2k]
  ------------------
 1653|  31.2k|}
_ZN5Darts7Details18DoubleArrayBuilder17arrange_from_dawgERKNS0_11DawgBuilderEjj:
 1656|  31.2k|    id_type dawg_id, id_type dic_id) {
 1657|  31.2k|  labels_.resize(0);
 1658|       |
 1659|  31.2k|  id_type dawg_child_id = dawg.child(dawg_id);
 1660|  76.9k|  while (dawg_child_id != 0) {
  ------------------
  |  Branch (1660:10): [True: 45.6k, False: 31.2k]
  ------------------
 1661|  45.6k|    labels_.append(dawg.label(dawg_child_id));
 1662|  45.6k|    dawg_child_id = dawg.sibling(dawg_child_id);
 1663|  45.6k|  }
 1664|       |
 1665|  31.2k|  id_type offset = find_valid_offset(dic_id);
 1666|  31.2k|  units_[dic_id].set_offset(dic_id ^ offset);
 1667|       |
 1668|  31.2k|  dawg_child_id = dawg.child(dawg_id);
 1669|  76.9k|  for (std::size_t i = 0; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1669:27): [True: 45.6k, False: 31.2k]
  ------------------
 1670|  45.6k|    id_type dic_child_id = offset ^ labels_[i];
 1671|  45.6k|    reserve_id(dic_child_id);
 1672|       |
 1673|  45.6k|    if (dawg.is_leaf(dawg_child_id)) {
  ------------------
  |  Branch (1673:9): [True: 16.0k, False: 29.6k]
  ------------------
 1674|  16.0k|      units_[dic_id].set_has_leaf(true);
 1675|  16.0k|      units_[dic_child_id].set_value(dawg.value(dawg_child_id));
 1676|  29.6k|    } else {
 1677|  29.6k|      units_[dic_child_id].set_label(labels_[i]);
 1678|  29.6k|    }
 1679|       |
 1680|  45.6k|    dawg_child_id = dawg.sibling(dawg_child_id);
 1681|  45.6k|  }
 1682|  31.2k|  extras(offset).set_is_used(true);
 1683|       |
 1684|  31.2k|  return offset;
 1685|  31.2k|}
_ZNK5Darts7Details18DoubleArrayBuilder17find_valid_offsetEj:
 1793|  33.6k|inline id_type DoubleArrayBuilder::find_valid_offset(id_type id) const {
 1794|  33.6k|  if (extras_head_ >= units_.size()) {
  ------------------
  |  Branch (1794:7): [True: 0, False: 33.6k]
  ------------------
 1795|      0|    return units_.size() | (id & LOWER_MASK);
 1796|      0|  }
 1797|       |
 1798|  33.6k|  id_type unfixed_id = extras_head_;
 1799|  47.4k|  do {
 1800|  47.4k|    id_type offset = unfixed_id ^ labels_[0];
 1801|  47.4k|    if (is_valid_offset(id, offset)) {
  ------------------
  |  Branch (1801:9): [True: 33.6k, False: 13.8k]
  ------------------
 1802|  33.6k|      return offset;
 1803|  33.6k|    }
 1804|  13.8k|    unfixed_id = extras(unfixed_id).next();
 1805|  13.8k|  } while (unfixed_id != extras_head_);
  ------------------
  |  Branch (1805:12): [True: 13.8k, False: 2]
  ------------------
 1806|       |
 1807|      2|  return units_.size() | (id & LOWER_MASK);
 1808|  33.6k|}
_ZNK5Darts7Details18DoubleArrayBuilder15is_valid_offsetEjj:
 1811|  47.4k|    id_type offset) const {
 1812|  47.4k|  if (extras(offset).is_used()) {
  ------------------
  |  Branch (1812:7): [True: 8.23k, False: 39.2k]
  ------------------
 1813|  8.23k|    return false;
 1814|  8.23k|  }
 1815|       |
 1816|  39.2k|  id_type rel_offset = id ^ offset;
 1817|  39.2k|  if ((rel_offset & LOWER_MASK) && (rel_offset & UPPER_MASK)) {
  ------------------
  |  Branch (1817:7): [True: 39.1k, False: 96]
  |  Branch (1817:36): [True: 0, False: 39.1k]
  ------------------
 1818|      0|    return false;
 1819|      0|  }
 1820|       |
 1821|  55.3k|  for (std::size_t i = 1; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1821:27): [True: 21.7k, False: 33.6k]
  ------------------
 1822|  21.7k|    if (extras(offset ^ labels_[i]).is_fixed()) {
  ------------------
  |  Branch (1822:9): [True: 5.64k, False: 16.1k]
  ------------------
 1823|  5.64k|      return false;
 1824|  5.64k|    }
 1825|  21.7k|  }
 1826|       |
 1827|  33.6k|  return true;
 1828|  39.2k|}
_ZN5Darts7Details18DoubleArrayBuilder10reserve_idEj:
 1830|   524k|inline void DoubleArrayBuilder::reserve_id(id_type id) {
 1831|   524k|  if (id >= units_.size()) {
  ------------------
  |  Branch (1831:7): [True: 2.04k, False: 522k]
  ------------------
 1832|  2.04k|    expand_units();
 1833|  2.04k|  }
 1834|       |
 1835|   524k|  if (id == extras_head_) {
  ------------------
  |  Branch (1835:7): [True: 506k, False: 17.4k]
  ------------------
 1836|   506k|    extras_head_ = extras(id).next();
 1837|   506k|    if (extras_head_ == id) {
  ------------------
  |  Branch (1837:9): [True: 2.04k, False: 504k]
  ------------------
 1838|  2.04k|      extras_head_ = units_.size();
 1839|  2.04k|    }
 1840|   506k|  }
 1841|   524k|  extras(extras(id).prev()).set_next(extras(id).next());
 1842|   524k|  extras(extras(id).next()).set_prev(extras(id).prev());
 1843|   524k|  extras(id).set_is_fixed(true);
 1844|   524k|}
_ZN5Darts7Details18DoubleArrayBuilder12expand_unitsEv:
 1846|  2.04k|inline void DoubleArrayBuilder::expand_units() {
 1847|  2.04k|  id_type src_num_units = units_.size();
 1848|  2.04k|  id_type src_num_blocks = num_blocks();
 1849|       |
 1850|  2.04k|  id_type dest_num_units = src_num_units + BLOCK_SIZE;
 1851|  2.04k|  id_type dest_num_blocks = src_num_blocks + 1;
 1852|       |
 1853|  2.04k|  if (dest_num_blocks > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1853:7): [True: 0, False: 2.04k]
  ------------------
 1854|      0|    fix_block(src_num_blocks - NUM_EXTRA_BLOCKS);
 1855|      0|  }
 1856|       |
 1857|  2.04k|  units_.resize(dest_num_units);
 1858|       |
 1859|  2.04k|  if (dest_num_blocks > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1859:7): [True: 0, False: 2.04k]
  ------------------
 1860|      0|    for (std::size_t id = src_num_units; id < dest_num_units; ++id) {
  ------------------
  |  Branch (1860:42): [True: 0, False: 0]
  ------------------
 1861|      0|      extras(id).set_is_used(false);
 1862|      0|      extras(id).set_is_fixed(false);
 1863|      0|    }
 1864|      0|  }
 1865|       |
 1866|   524k|  for (id_type i = src_num_units + 1; i < dest_num_units; ++i) {
  ------------------
  |  Branch (1866:39): [True: 522k, False: 2.04k]
  ------------------
 1867|   522k|    extras(i - 1).set_next(i);
 1868|   522k|    extras(i).set_prev(i - 1);
 1869|   522k|  }
 1870|       |
 1871|  2.04k|  extras(src_num_units).set_prev(dest_num_units - 1);
 1872|  2.04k|  extras(dest_num_units - 1).set_next(src_num_units);
 1873|       |
 1874|  2.04k|  extras(src_num_units).set_prev(extras(extras_head_).prev());
 1875|  2.04k|  extras(dest_num_units - 1).set_next(extras_head_);
 1876|       |
 1877|  2.04k|  extras(extras(extras_head_).prev()).set_next(src_num_units);
 1878|  2.04k|  extras(extras_head_).set_prev(dest_num_units - 1);
 1879|  2.04k|}
_ZN5Darts7Details18DoubleArrayBuilder14fix_all_blocksEv:
 1881|  2.04k|inline void DoubleArrayBuilder::fix_all_blocks() {
 1882|  2.04k|  id_type begin = 0;
 1883|  2.04k|  if (num_blocks() > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1883:7): [True: 0, False: 2.04k]
  ------------------
 1884|      0|    begin = num_blocks() - NUM_EXTRA_BLOCKS;
 1885|      0|  }
 1886|  2.04k|  id_type end = num_blocks();
 1887|       |
 1888|  4.09k|  for (id_type block_id = begin; block_id != end; ++block_id) {
  ------------------
  |  Branch (1888:34): [True: 2.04k, False: 2.04k]
  ------------------
 1889|  2.04k|    fix_block(block_id);
 1890|  2.04k|  }
 1891|  2.04k|}
_ZN5Darts7Details18DoubleArrayBuilder9fix_blockEj:
 1893|  2.04k|inline void DoubleArrayBuilder::fix_block(id_type block_id) {
 1894|  2.04k|  id_type begin = block_id * BLOCK_SIZE;
 1895|  2.04k|  id_type end = begin + BLOCK_SIZE;
 1896|       |
 1897|  2.04k|  id_type unused_offset = 0;
 1898|  4.16k|  for (id_type offset = begin; offset != end; ++offset) {
  ------------------
  |  Branch (1898:32): [True: 4.16k, False: 0]
  ------------------
 1899|  4.16k|    if (!extras(offset).is_used()) {
  ------------------
  |  Branch (1899:9): [True: 2.04k, False: 2.12k]
  ------------------
 1900|  2.04k|      unused_offset = offset;
 1901|  2.04k|      break;
 1902|  2.04k|    }
 1903|  4.16k|  }
 1904|       |
 1905|   526k|  for (id_type id = begin; id != end; ++id) {
  ------------------
  |  Branch (1905:28): [True: 524k, False: 2.04k]
  ------------------
 1906|   524k|    if (!extras(id).is_fixed()) {
  ------------------
  |  Branch (1906:9): [True: 474k, False: 50.1k]
  ------------------
 1907|   474k|      reserve_id(id);
 1908|   474k|      units_[id].set_label(static_cast<uchar_type>(id ^ unused_offset));
 1909|   474k|    }
 1910|   524k|  }
 1911|  2.04k|}
_ZN5Darts7Details9AutoArrayIcE5clearEv:
  600|   177k|  void clear() {
  601|   177k|    if (array_ != NULL) {
  ------------------
  |  Branch (601:9): [True: 53.3k, False: 124k]
  ------------------
  602|  53.3k|      delete[] array_;
  603|       |      array_ = NULL;
  604|  53.3k|    }
  605|   177k|  }
_ZNK5Darts7Details8AutoPoolIjEixEm:
  633|  94.5k|  const T &operator[](std::size_t id) const {
  634|  94.5k|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|  94.5k|  }
_ZNK5Darts7Details9AutoArrayIcEixEm:
  589|  1.21M|  const T &operator[](std::size_t id) const {
  590|  1.21M|    return array_[id];
  591|  1.21M|  }
_ZN5Darts7Details8AutoPoolIjEixEm:
  636|  3.68M|  T &operator[](std::size_t id) {
  637|  3.68M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|  3.68M|  }
_ZN5Darts7Details9AutoArrayIcEixEm:
  592|  6.51M|  T &operator[](std::size_t id) {
  593|  6.51M|    return array_[id];
  594|  6.51M|  }
_ZNK5Darts7Details8AutoPoolIjE5emptyEv:
  640|  47.2k|  bool empty() const {
  641|  47.2k|    return size_ == 0;
  642|  47.2k|  }
_ZN5Darts7Details8AutoPoolIjE6appendERKj:
  666|  95.5k|  void append(const T &value) {
  667|  95.5k|    if (size_ == capacity_)
  ------------------
  |  Branch (667:9): [True: 16.4k, False: 79.0k]
  ------------------
  668|  16.4k|      resize_buf(size_ + 1);
  669|  95.5k|    new(&(*this)[size_++]) T(value);
  670|  95.5k|  }
_ZN5Darts7Details8AutoPoolIjE10resize_bufEm:
  714|  18.1k|void AutoPool<T>::resize_buf(std::size_t size) {
  715|  18.1k|  std::size_t capacity;
  716|  18.1k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 10.2k, False: 7.91k]
  ------------------
  717|  10.2k|    capacity = size;
  718|  10.2k|  } else {
  719|  7.91k|    capacity = 1;
  720|  30.4k|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 22.5k, False: 7.91k]
  ------------------
  721|  22.5k|      capacity <<= 1;
  722|  22.5k|    }
  723|  7.91k|  }
  724|       |
  725|  18.1k|  AutoArray<char> buf;
  726|  18.1k|  try {
  727|  18.1k|    buf.reset(new char[sizeof(T) * capacity]);
  728|  18.1k|  } catch (const std::bad_alloc &) {
  729|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  730|      0|  }
  731|       |
  732|  18.1k|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 11.6k, False: 6.49k]
  ------------------
  733|  11.6k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|  11.6k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|  53.6k|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 42.0k, False: 11.6k]
  ------------------
  736|  42.0k|      new(&dest[i]) T(src[i]);
  737|  42.0k|      src[i].~T();
  738|  42.0k|    }
  739|  11.6k|  }
  740|       |
  741|  18.1k|  buf_.swap(&buf);
  742|  18.1k|  capacity_ = capacity;
  743|  18.1k|}
_ZN5Darts7Details9AutoArrayIcE5resetEPc:
  611|  53.3k|  void reset(T *array = NULL) {
  612|  53.3k|    AutoArray(array).swap(this);
  613|  53.3k|  }
_ZN5Darts7Details9AutoArrayIcE4swapEPS2_:
  606|   106k|  void swap(AutoArray *array) {
  607|   106k|    T *temp = array_;
  608|   106k|    array_ = array->array_;
  609|   106k|    array->array_ = temp;
  610|   106k|  }
_ZN5Darts7Details8AutoPoolIjE5clearEv:
  647|  29.2k|  void clear() {
  648|  29.2k|    resize(0);
  649|  29.2k|    buf_.clear();
  650|  29.2k|    size_ = 0;
  651|  29.2k|    capacity_ = 0;
  652|  29.2k|  }
_ZN5Darts7Details8AutoPoolIjE6resizeEm:
  672|  29.2k|  void resize(std::size_t size) {
  673|  1.71M|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 1.68M, False: 29.2k]
  ------------------
  674|  1.68M|      (*this)[--size_].~T();
  675|  1.68M|    }
  676|  29.2k|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 29.2k]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|  29.2k|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 29.2k]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|  29.2k|  }
_ZN5Darts7Details9AutoArrayIjE5clearEv:
  600|  15.4k|  void clear() {
  601|  15.4k|    if (array_ != NULL) {
  ------------------
  |  Branch (601:9): [True: 3.24k, False: 12.2k]
  ------------------
  602|  3.24k|      delete[] array_;
  603|       |      array_ = NULL;
  604|  3.24k|    }
  605|  15.4k|  }
_ZN5Darts7Details9AutoArrayIjE5resetEPj:
  611|  3.24k|  void reset(T *array = NULL) {
  612|  3.24k|    AutoArray(array).swap(this);
  613|  3.24k|  }
_ZN5Darts7Details9AutoArrayIjE4swapEPS2_:
  606|  3.24k|  void swap(AutoArray *array) {
  607|  3.24k|    T *temp = array_;
  608|  3.24k|    array_ = array->array_;
  609|  3.24k|    array->array_ = temp;
  610|  3.24k|  }
_ZNK5Darts7Details8AutoPoolIjE4sizeEv:
  643|   236k|  std::size_t size() const {
  644|   236k|    return size_;
  645|   236k|  }
_ZN5Darts7Details9AutoArrayIjEixEm:
  592|  2.54k|  T &operator[](std::size_t id) {
  593|  2.54k|    return array_[id];
  594|  2.54k|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgUnitEEixEm:
  633|   249k|  const T &operator[](std::size_t id) const {
  634|   249k|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|   249k|  }
_ZNK5Darts7Details8AutoPoolIhEixEm:
  633|   206k|  const T &operator[](std::size_t id) const {
  634|   206k|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|   206k|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgUnitEE4sizeEv:
  643|  9.00k|  std::size_t size() const {
  644|  9.00k|    return size_;
  645|  9.00k|  }
_ZN5Darts7Details9AutoStackIjE4pushERKj:
  771|  92.9k|  void push(const T &value) {
  772|  92.9k|    pool_.push_back(value);
  773|  92.9k|  }
_ZN5Darts7Details8AutoPoolIjE9push_backERKj:
  654|  92.9k|  void push_back(const T &value) {
  655|  92.9k|    append(value);
  656|  92.9k|  }
_ZN5Darts7Details8AutoPoolIjE6resizeEmRKj:
  683|  1.62k|  void resize(std::size_t size, const T &value) {
  684|  1.62k|    while (size_ > size) {
  ------------------
  |  Branch (684:12): [True: 0, False: 1.62k]
  ------------------
  685|      0|      (*this)[--size_].~T();
  686|      0|    }
  687|  1.62k|    if (size > capacity_) {
  ------------------
  |  Branch (687:9): [True: 1.62k, False: 0]
  ------------------
  688|  1.62k|      resize_buf(size);
  689|  1.62k|    }
  690|  1.66M|    while (size_ < size) {
  ------------------
  |  Branch (690:12): [True: 1.66M, False: 1.62k]
  ------------------
  691|  1.66M|      new(&(*this)[size_++]) T(value);
  692|  1.66M|    }
  693|  1.62k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEEixEm:
  636|   670k|  T &operator[](std::size_t id) {
  637|   670k|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|   670k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEEixEm:
  636|   141k|  T &operator[](std::size_t id) {
  637|   141k|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|   141k|  }
_ZN5Darts7Details8AutoPoolIhEixEm:
  636|   320k|  T &operator[](std::size_t id) {
  637|   320k|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|   320k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE5clearEv:
  647|  6.49k|  void clear() {
  648|  6.49k|    resize(0);
  649|  6.49k|    buf_.clear();
  650|  6.49k|    size_ = 0;
  651|  6.49k|    capacity_ = 0;
  652|  6.49k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE6resizeEm:
  672|  6.49k|  void resize(std::size_t size) {
  673|  27.6k|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 21.1k, False: 6.49k]
  ------------------
  674|  21.1k|      (*this)[--size_].~T();
  675|  21.1k|    }
  676|  6.49k|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 6.49k]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|  6.49k|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 6.49k]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|  6.49k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE10resize_bufEm:
  714|  7.64k|void AutoPool<T>::resize_buf(std::size_t size) {
  715|  7.64k|  std::size_t capacity;
  716|  7.64k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 3.24k, False: 4.40k]
  ------------------
  717|  3.24k|    capacity = size;
  718|  4.40k|  } else {
  719|  4.40k|    capacity = 1;
  720|  18.0k|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 13.6k, False: 4.40k]
  ------------------
  721|  13.6k|      capacity <<= 1;
  722|  13.6k|    }
  723|  4.40k|  }
  724|       |
  725|  7.64k|  AutoArray<char> buf;
  726|  7.64k|  try {
  727|  7.64k|    buf.reset(new char[sizeof(T) * capacity]);
  728|  7.64k|  } catch (const std::bad_alloc &) {
  729|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  730|      0|  }
  731|       |
  732|  7.64k|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 6.02k, False: 1.62k]
  ------------------
  733|  6.02k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|  6.02k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|  35.4k|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 29.3k, False: 6.02k]
  ------------------
  736|  29.3k|      new(&dest[i]) T(src[i]);
  737|  29.3k|      src[i].~T();
  738|  29.3k|    }
  739|  6.02k|  }
  740|       |
  741|  7.64k|  buf_.swap(&buf);
  742|  7.64k|  capacity_ = capacity;
  743|  7.64k|}
_ZN5Darts7Details9AutoStackIjE5clearEv:
  778|  12.9k|  void clear() {
  779|  12.9k|    pool_.clear();
  780|  12.9k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE5clearEv:
  647|  4.86k|  void clear() {
  648|  4.86k|    resize(0);
  649|  4.86k|    buf_.clear();
  650|  4.86k|    size_ = 0;
  651|  4.86k|    capacity_ = 0;
  652|  4.86k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE6resizeEm:
  672|  4.86k|  void resize(std::size_t size) {
  673|  52.1k|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 47.2k, False: 4.86k]
  ------------------
  674|  47.2k|      (*this)[--size_].~T();
  675|  47.2k|    }
  676|  4.86k|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 4.86k]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|  4.86k|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 4.86k]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|  4.86k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE10resize_bufEm:
  714|  9.00k|void AutoPool<T>::resize_buf(std::size_t size) {
  715|  9.00k|  std::size_t capacity;
  716|  9.00k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 3.24k, False: 5.75k]
  ------------------
  717|  3.24k|    capacity = size;
  718|  5.75k|  } else {
  719|  5.75k|    capacity = 1;
  720|  26.5k|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 20.7k, False: 5.75k]
  ------------------
  721|  20.7k|      capacity <<= 1;
  722|  20.7k|    }
  723|  5.75k|  }
  724|       |
  725|  9.00k|  AutoArray<char> buf;
  726|  9.00k|  try {
  727|  9.00k|    buf.reset(new char[sizeof(T) * capacity]);
  728|  9.00k|  } catch (const std::bad_alloc &) {
  729|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  730|      0|  }
  731|       |
  732|  9.00k|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 7.37k, False: 1.62k]
  ------------------
  733|  7.37k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|  7.37k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|  74.9k|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 67.6k, False: 7.37k]
  ------------------
  736|  67.6k|      new(&dest[i]) T(src[i]);
  737|  67.6k|      src[i].~T();
  738|  67.6k|    }
  739|  7.37k|  }
  740|       |
  741|  9.00k|  buf_.swap(&buf);
  742|  9.00k|  capacity_ = capacity;
  743|  9.00k|}
_ZN5Darts7Details8AutoPoolIhE5clearEv:
  647|  11.0k|  void clear() {
  648|  11.0k|    resize(0);
  649|  11.0k|    buf_.clear();
  650|  11.0k|    size_ = 0;
  651|  11.0k|    capacity_ = 0;
  652|  11.0k|  }
_ZN5Darts7Details9AutoStackIjE3topEv:
  760|   135k|  T &top() {
  761|   135k|    return pool_[size() - 1];
  762|   135k|  }
_ZNK5Darts7Details9AutoStackIjE4sizeEv:
  767|   135k|  std::size_t size() const {
  768|   135k|    return pool_.size();
  769|   135k|  }
_ZN5Darts7Details9AutoStackIjE3popEv:
  774|  73.4k|  void pop() {
  775|  73.4k|    pool_.pop_back();
  776|  73.4k|  }
_ZN5Darts7Details8AutoPoolIjE8pop_backEv:
  657|  73.4k|  void pop_back() {
  658|  73.4k|    (*this)[--size_].~T();
  659|  73.4k|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgNodeEEixEm:
  633|   138k|  const T &operator[](std::size_t id) const {
  634|   138k|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|   138k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE6appendEv:
  661|  47.2k|  void append() {
  662|  47.2k|    if (size_ == capacity_)
  ------------------
  |  Branch (662:9): [True: 9.00k, False: 38.2k]
  ------------------
  663|  9.00k|      resize_buf(size_ + 1);
  664|  47.2k|    new(&(*this)[size_++]) T;
  665|  47.2k|  }
_ZN5Darts7Details8AutoPoolIhE6appendEv:
  661|  47.2k|  void append() {
  662|  47.2k|    if (size_ == capacity_)
  ------------------
  |  Branch (662:9): [True: 9.00k, False: 38.2k]
  ------------------
  663|  9.00k|      resize_buf(size_ + 1);
  664|  47.2k|    new(&(*this)[size_++]) T;
  665|  47.2k|  }
_ZN5Darts7Details8AutoPoolIhE10resize_bufEm:
  714|  14.5k|void AutoPool<T>::resize_buf(std::size_t size) {
  715|  14.5k|  std::size_t capacity;
  716|  14.5k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 6.61k, False: 7.91k]
  ------------------
  717|  6.61k|    capacity = size;
  718|  7.91k|  } else {
  719|  7.91k|    capacity = 1;
  720|  35.4k|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 27.5k, False: 7.91k]
  ------------------
  721|  27.5k|      capacity <<= 1;
  722|  27.5k|    }
  723|  7.91k|  }
  724|       |
  725|  14.5k|  AutoArray<char> buf;
  726|  14.5k|  try {
  727|  14.5k|    buf.reset(new char[sizeof(T) * capacity]);
  728|  14.5k|  } catch (const std::bad_alloc &) {
  729|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  730|      0|  }
  731|       |
  732|  14.5k|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 10.8k, False: 3.66k]
  ------------------
  733|  10.8k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|  10.8k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|  92.3k|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 81.4k, False: 10.8k]
  ------------------
  736|  81.4k|      new(&dest[i]) T(src[i]);
  737|  81.4k|      src[i].~T();
  738|  81.4k|    }
  739|  10.8k|  }
  740|       |
  741|  14.5k|  buf_.swap(&buf);
  742|  14.5k|  capacity_ = capacity;
  743|  14.5k|}
_ZNK5Darts7Details9AutoStackIjE5emptyEv:
  764|  47.2k|  bool empty() const {
  765|  47.2k|    return pool_.empty();
  766|  47.2k|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgNodeEE4sizeEv:
  643|  21.1k|  std::size_t size() const {
  644|  21.1k|    return size_;
  645|  21.1k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE6appendEv:
  661|  21.1k|  void append() {
  662|  21.1k|    if (size_ == capacity_)
  ------------------
  |  Branch (662:9): [True: 7.64k, False: 13.4k]
  ------------------
  663|  7.64k|      resize_buf(size_ + 1);
  664|  21.1k|    new(&(*this)[size_++]) T;
  665|  21.1k|  }
_ZNK5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE4sizeEv:
  643|  1.09M|  std::size_t size() const {
  644|  1.09M|    return size_;
  645|  1.09M|  }
_ZNK5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEixEm:
  589|  83.1k|  const T &operator[](std::size_t id) const {
  590|  83.1k|    return array_[id];
  591|  83.1k|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEixEm:
  592|  5.80M|  T &operator[](std::size_t id) {
  593|  5.80M|    return array_[id];
  594|  5.80M|  }
_ZNK5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEixEm:
  633|   524k|  const T &operator[](std::size_t id) const {
  634|   524k|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|   524k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE5clearEv:
  647|  4.09k|  void clear() {
  648|  4.09k|    resize(0);
  649|  4.09k|    buf_.clear();
  650|  4.09k|    size_ = 0;
  651|  4.09k|    capacity_ = 0;
  652|  4.09k|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE5clearEv:
  600|  8.18k|  void clear() {
  601|  8.18k|    if (array_ != NULL) {
  ------------------
  |  Branch (601:9): [True: 2.04k, False: 6.13k]
  ------------------
  602|  2.04k|      delete[] array_;
  603|       |      array_ = NULL;
  604|  2.04k|    }
  605|  8.18k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE7reserveEm:
  695|  2.04k|  void reserve(std::size_t size) {
  696|  2.04k|    if (size > capacity_) {
  ------------------
  |  Branch (696:9): [True: 2.04k, False: 0]
  ------------------
  697|  2.04k|      resize_buf(size);
  698|  2.04k|    }
  699|  2.04k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE10resize_bufEm:
  714|  4.09k|void AutoPool<T>::resize_buf(std::size_t size) {
  715|  4.09k|  std::size_t capacity;
  716|  4.09k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 4.09k, False: 0]
  ------------------
  717|  4.09k|    capacity = size;
  718|  4.09k|  } else {
  719|      0|    capacity = 1;
  720|      0|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 0, False: 0]
  ------------------
  721|      0|      capacity <<= 1;
  722|      0|    }
  723|      0|  }
  724|       |
  725|  4.09k|  AutoArray<char> buf;
  726|  4.09k|  try {
  727|  4.09k|    buf.reset(new char[sizeof(T) * capacity]);
  728|  4.09k|  } catch (const std::bad_alloc &) {
  729|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  730|      0|  }
  731|       |
  732|  4.09k|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 2, False: 4.08k]
  ------------------
  733|      2|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|      2|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|    514|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 512, False: 2]
  ------------------
  736|    512|      new(&dest[i]) T(src[i]);
  737|    512|      src[i].~T();
  738|    512|    }
  739|      2|  }
  740|       |
  741|  4.09k|  buf_.swap(&buf);
  742|  4.09k|  capacity_ = capacity;
  743|  4.09k|}
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE5resetEPS2_:
  611|  2.04k|  void reset(T *array = NULL) {
  612|  2.04k|    AutoArray(array).swap(this);
  613|  2.04k|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE4swapEPS3_:
  606|  2.04k|  void swap(AutoArray *array) {
  607|  2.04k|    T *temp = array_;
  608|  2.04k|    array_ = array->array_;
  609|  2.04k|    array->array_ = temp;
  610|  2.04k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEixEm:
  636|  1.62M|  T &operator[](std::size_t id) {
  637|  1.62M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|  1.62M|  }
_ZN5Darts7Details8AutoPoolIhE6resizeEm:
  672|  44.6k|  void resize(std::size_t size) {
  673|   140k|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 95.4k, False: 44.6k]
  ------------------
  674|  95.4k|      (*this)[--size_].~T();
  675|  95.4k|    }
  676|  44.6k|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 44.6k]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|  44.6k|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 44.6k]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|  44.6k|  }
_ZN5Darts7Details8AutoPoolIhE6appendERKh:
  666|  48.1k|  void append(const T &value) {
  667|  48.1k|    if (size_ == capacity_)
  ------------------
  |  Branch (667:9): [True: 5.53k, False: 42.5k]
  ------------------
  668|  5.53k|      resize_buf(size_ + 1);
  669|  48.1k|    new(&(*this)[size_++]) T(value);
  670|  48.1k|  }
_ZNK5Darts7Details8AutoPoolIhE4sizeEv:
  643|   137k|  std::size_t size() const {
  644|   137k|    return size_;
  645|   137k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE6resizeEm:
  672|  6.14k|  void resize(std::size_t size) {
  673|   530k|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 524k, False: 6.14k]
  ------------------
  674|   524k|      (*this)[--size_].~T();
  675|   524k|    }
  676|  6.14k|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 2.04k, False: 4.09k]
  ------------------
  677|  2.04k|      resize_buf(size);
  678|  2.04k|    }
  679|   530k|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 524k, False: 6.14k]
  ------------------
  680|   524k|      new(&(*this)[size_++]) T;
  681|   524k|    }
  682|  6.14k|  }
_ZN5Darts15DoubleArrayImplIvvivE5clearEv:
  185|  4.09k|  void clear() {
  186|  4.09k|    size_ = 0;
  187|  4.09k|    array_ = NULL;
  188|  4.09k|    if (buf_ != NULL) {
  ------------------
  |  Branch (188:9): [True: 2.04k, False: 2.04k]
  ------------------
  189|  2.04k|      delete[] buf_;
  190|       |      buf_ = NULL;
  191|  2.04k|    }
  192|  4.09k|  }
_ZN5Darts15DoubleArrayImplIvvivEC2Ev:
  138|  2.04k|  DoubleArrayImpl() : size_(0), array_(NULL), buf_(NULL) {}
_ZN5Darts15DoubleArrayImplIvvivED2Ev:
  141|  2.04k|  virtual ~DoubleArrayImpl() {
  142|  2.04k|    clear();
  143|  2.04k|  }
_ZNK5Darts15DoubleArrayImplIvvivE18commonPrefixSearchINS1_16result_pair_typeEEEmPKcPT_mmm:
  497|  19.4M|    std::size_t length, std::size_t node_pos) const {
  498|  19.4M|  std::size_t num_results = 0;
  499|       |
  500|  19.4M|  unit_type unit = array_[node_pos];
  501|  19.4M|  node_pos ^= unit.offset();
  502|  19.4M|  if (length != 0) {
  ------------------
  |  Branch (502:7): [True: 19.4M, False: 0]
  ------------------
  503|  24.6M|    for (std::size_t i = 0; i < length; ++i) {
  ------------------
  |  Branch (503:29): [True: 24.5M, False: 16.5k]
  ------------------
  504|  24.5M|      node_pos ^= static_cast<uchar_type>(key[i]);
  505|  24.5M|      unit = array_[node_pos];
  506|  24.5M|      if (unit.label() != static_cast<uchar_type>(key[i])) {
  ------------------
  |  Branch (506:11): [True: 19.4M, False: 5.16M]
  ------------------
  507|  19.4M|        return num_results;
  508|  19.4M|      }
  509|       |
  510|  5.16M|      node_pos ^= unit.offset();
  511|  5.16M|      if (unit.has_leaf()) {
  ------------------
  |  Branch (511:11): [True: 1.76M, False: 3.39M]
  ------------------
  512|  1.76M|        if (num_results < max_num_results) {
  ------------------
  |  Branch (512:13): [True: 1.76M, False: 0]
  ------------------
  513|  1.76M|          set_result(&results[num_results], static_cast<value_type>(
  514|  1.76M|              array_[node_pos].value()), i + 1);
  515|  1.76M|        }
  516|  1.76M|        ++num_results;
  517|  1.76M|      }
  518|  5.16M|    }
  519|  19.4M|  } else {
  520|      0|    for ( ; key[length] != '\0'; ++length) {
  ------------------
  |  Branch (520:13): [True: 0, False: 0]
  ------------------
  521|      0|      node_pos ^= static_cast<uchar_type>(key[length]);
  522|      0|      unit = array_[node_pos];
  523|      0|      if (unit.label() != static_cast<uchar_type>(key[length])) {
  ------------------
  |  Branch (523:11): [True: 0, False: 0]
  ------------------
  524|      0|        return num_results;
  525|      0|      }
  526|       |
  527|      0|      node_pos ^= unit.offset();
  528|      0|      if (unit.has_leaf()) {
  ------------------
  |  Branch (528:11): [True: 0, False: 0]
  ------------------
  529|      0|        if (num_results < max_num_results) {
  ------------------
  |  Branch (529:13): [True: 0, False: 0]
  ------------------
  530|      0|          set_result(&results[num_results], static_cast<value_type>(
  531|      0|              array_[node_pos].value()), length + 1);
  532|      0|        }
  533|      0|        ++num_results;
  534|      0|      }
  535|      0|    }
  536|      0|  }
  537|       |
  538|  16.5k|  return num_results;
  539|  19.4M|}
_ZNK5Darts15DoubleArrayImplIvvivE10set_resultEPNS1_16result_pair_typeEim:
  159|  1.76M|      value_type value, std::size_t length) const {
  160|  1.76M|    result->value = value;
  161|  1.76M|    result->length = length;
  162|  1.76M|  }
_ZN5Darts15DoubleArrayImplIvvivE5buildEmPKPKcPKmPKiPFimmE:
 1922|  2.04k|    const value_type *values, Details::progress_func_type progress_func) {
 1923|  2.04k|  Details::Keyset<value_type> keyset(num_keys, keys, lengths, values);
 1924|       |
 1925|  2.04k|  Details::DoubleArrayBuilder builder(progress_func);
 1926|  2.04k|  builder.build(keyset);
 1927|       |
 1928|  2.04k|  std::size_t size = 0;
 1929|  2.04k|  unit_type *buf = NULL;
 1930|  2.04k|  builder.copy(&size, &buf);
 1931|       |
 1932|  2.04k|  clear();
 1933|       |
 1934|  2.04k|  size_ = size;
 1935|  2.04k|  array_ = buf;
 1936|  2.04k|  buf_ = buf;
 1937|       |
 1938|  2.04k|  if (progress_func != NULL) {
  ------------------
  |  Branch (1938:7): [True: 0, False: 2.04k]
  ------------------
 1939|      0|    progress_func(num_keys + 1, num_keys + 1);
 1940|      0|  }
 1941|       |
 1942|  2.04k|  return 0;
 1943|  2.04k|}
_ZN5Darts7Details6KeysetIiEC2EmPKPKcPKmPKi:
  887|  2.04k|      num_keys_(num_keys), keys_(keys), lengths_(lengths), values_(values) {}
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEC2Ev:
  630|  2.04k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoArrayIcEC2EPc:
  584|   122k|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEC2EPS2_:
  584|  4.09k|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details8AutoPoolIhEC2Ev:
  630|  3.66k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoArrayIjEC2EPj:
  584|  6.91k|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details8AutoPoolIhED2Ev:
  631|  3.66k|  ~AutoPool() { clear(); }
_ZN5Darts7Details9AutoArrayIcED2Ev:
  585|   122k|  ~AutoArray() {
  586|   122k|    clear();
  587|   122k|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEED2Ev:
  585|  4.09k|  ~AutoArray() {
  586|  4.09k|    clear();
  587|  4.09k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEED2Ev:
  631|  2.04k|  ~AutoPool() { clear(); }
_ZN5Darts7Details18DoubleArrayBuilder5buildIiEEvRKNS0_6KeysetIT_EE:
 1546|  2.04k|void DoubleArrayBuilder::build(const Keyset<T> &keyset) {
 1547|  2.04k|  if (keyset.has_values()) {
  ------------------
  |  Branch (1547:7): [True: 1.62k, False: 423]
  ------------------
 1548|  1.62k|    Details::DawgBuilder dawg_builder;
 1549|  1.62k|    build_dawg(keyset, &dawg_builder);
 1550|  1.62k|    build_from_dawg(dawg_builder);
 1551|  1.62k|    dawg_builder.clear();
 1552|  1.62k|  } else {
 1553|    423|    build_from_keyset(keyset);
 1554|    423|  }
 1555|  2.04k|}
_ZNK5Darts7Details6KeysetIiE10has_valuesEv:
  915|  19.1k|  bool has_values() const {
  916|       |    return values_ != NULL;
  917|  19.1k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEEC2Ev:
  630|  1.62k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEEC2Ev:
  630|  1.62k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details8AutoPoolIjEC2Ev:
  630|  6.49k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoStackIjEC2Ev:
  752|  3.24k|  AutoStack() : pool_() {}
_ZN5Darts7Details9AutoStackIjED2Ev:
  753|  3.24k|  ~AutoStack() {
  754|  3.24k|    clear();
  755|  3.24k|  }
_ZN5Darts7Details8AutoPoolIjED2Ev:
  631|  6.49k|  ~AutoPool() { clear(); }
_ZN5Darts7Details9AutoArrayIjED2Ev:
  585|  6.91k|  ~AutoArray() {
  586|  6.91k|    clear();
  587|  6.91k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEED2Ev:
  631|  1.62k|  ~AutoPool() { clear(); }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEED2Ev:
  631|  1.62k|  ~AutoPool() { clear(); }
_ZN5Darts7Details18DoubleArrayBuilder10build_dawgIiEEvRKNS0_6KeysetIT_EEPNS0_11DawgBuilderE:
 1581|  1.62k|    DawgBuilder *dawg_builder) {
 1582|  1.62k|  dawg_builder->init();
 1583|  17.6k|  for (std::size_t i = 0; i < keyset.num_keys(); ++i) {
  ------------------
  |  Branch (1583:27): [True: 16.0k, False: 1.62k]
  ------------------
 1584|  16.0k|    dawg_builder->insert(keyset.keys(i), keyset.lengths(i), keyset.values(i));
 1585|  16.0k|    if (progress_func_ != NULL) {
  ------------------
  |  Branch (1585:9): [True: 0, False: 16.0k]
  ------------------
 1586|      0|      progress_func_(i + 1, keyset.num_keys() + 1);
 1587|      0|    }
 1588|  16.0k|  }
 1589|  1.62k|  dawg_builder->finish();
 1590|  1.62k|}
_ZNK5Darts7Details6KeysetIiE8num_keysEv:
  889|  18.9k|  std::size_t num_keys() const {
  890|  18.9k|    return num_keys_;
  891|  18.9k|  }
_ZNK5Darts7Details6KeysetIiE4keysEm:
  892|  16.0k|  const char_type *keys(std::size_t id) const {
  893|  16.0k|    return keys_[id];
  894|  16.0k|  }
_ZNK5Darts7Details6KeysetIiE7lengthsEm:
  904|  16.5k|  std::size_t lengths(std::size_t id) const {
  905|  16.5k|    if (has_lengths()) {
  ------------------
  |  Branch (905:9): [True: 16.5k, False: 0]
  ------------------
  906|  16.5k|      return lengths_[id];
  907|  16.5k|    }
  908|      0|    std::size_t length = 0;
  909|      0|    while (keys_[id][length] != '\0') {
  ------------------
  |  Branch (909:12): [True: 0, False: 0]
  ------------------
  910|      0|      ++length;
  911|      0|    }
  912|      0|    return length;
  913|  16.5k|  }
_ZNK5Darts7Details6KeysetIiE11has_lengthsEv:
  901|  23.9k|  bool has_lengths() const {
  902|       |    return lengths_ != NULL;
  903|  23.9k|  }
_ZNK5Darts7Details6KeysetIiE6valuesEm:
  918|  17.0k|  const value_type values(std::size_t id) const {
  919|  17.0k|    if (has_values()) {
  ------------------
  |  Branch (919:9): [True: 16.0k, False: 1.05k]
  ------------------
  920|  16.0k|      return static_cast<value_type>(values_[id]);
  921|  16.0k|    }
  922|  1.05k|    return static_cast<value_type>(id);
  923|  17.0k|  }
_ZN5Darts7Details18DoubleArrayBuilder17build_from_keysetIiEEvRKNS0_6KeysetIT_EE:
 1688|    423|void DoubleArrayBuilder::build_from_keyset(const Keyset<T> &keyset) {
 1689|    423|  std::size_t num_units = 1;
 1690|    506|  while (num_units < keyset.num_keys()) {
  ------------------
  |  Branch (1690:10): [True: 83, False: 423]
  ------------------
 1691|     83|    num_units <<= 1;
 1692|     83|  }
 1693|    423|  units_.reserve(num_units);
 1694|       |
 1695|    423|  extras_.reset(new extra_type[NUM_EXTRAS]);
 1696|       |
 1697|    423|  reserve_id(0);
 1698|    423|  extras(0).set_is_used(true);
 1699|    423|  units_[0].set_offset(1);
 1700|    423|  units_[0].set_label('\0');
 1701|       |
 1702|    423|  if (keyset.num_keys() > 0) {
  ------------------
  |  Branch (1702:7): [True: 423, False: 0]
  ------------------
 1703|    423|    build_from_keyset(keyset, 0, keyset.num_keys(), 0, 0);
 1704|    423|  }
 1705|       |
 1706|    423|  fix_all_blocks();
 1707|       |
 1708|    423|  extras_.clear();
 1709|    423|  labels_.clear();
 1710|    423|}
_ZN5Darts7Details18DoubleArrayBuilder17build_from_keysetIiEEvRKNS0_6KeysetIT_EEmmmj:
 1714|  2.33k|    std::size_t begin, std::size_t end, std::size_t depth, id_type dic_id) {
 1715|  2.33k|  id_type offset = arrange_from_keyset(keyset, begin, end, depth, dic_id);
 1716|       |
 1717|  2.86k|  while (begin < end) {
  ------------------
  |  Branch (1717:10): [True: 2.33k, False: 524]
  ------------------
 1718|  2.33k|    if (keyset.keys(begin, depth) != '\0') {
  ------------------
  |  Branch (1718:9): [True: 1.81k, False: 526]
  ------------------
 1719|  1.81k|      break;
 1720|  1.81k|    }
 1721|    526|    ++begin;
 1722|    526|  }
 1723|  2.33k|  if (begin == end) {
  ------------------
  |  Branch (1723:7): [True: 524, False: 1.81k]
  ------------------
 1724|    524|    return;
 1725|    524|  }
 1726|       |
 1727|  1.81k|  std::size_t last_begin = begin;
 1728|  1.81k|  uchar_type last_label = keyset.keys(begin, depth);
 1729|  1.95k|  while (++begin < end) {
  ------------------
  |  Branch (1729:10): [True: 137, False: 1.81k]
  ------------------
 1730|    137|    uchar_type label = keyset.keys(begin, depth);
 1731|    137|    if (label != last_label) {
  ------------------
  |  Branch (1731:9): [True: 101, False: 36]
  ------------------
 1732|    101|      build_from_keyset(keyset, last_begin, begin,
 1733|    101|          depth + 1, offset ^ last_label);
 1734|    101|      last_begin = begin;
 1735|    101|      last_label = keyset.keys(begin, depth);
 1736|    101|    }
 1737|    137|  }
 1738|  1.81k|  build_from_keyset(keyset, last_begin, end, depth + 1, offset ^ last_label);
 1739|  1.81k|}
_ZN5Darts7Details18DoubleArrayBuilder19arrange_from_keysetIiEEjRKNS0_6KeysetIT_EEmmmj:
 1743|  2.33k|    std::size_t begin, std::size_t end, std::size_t depth, id_type dic_id) {
 1744|  2.33k|  labels_.resize(0);
 1745|       |
 1746|  2.33k|  value_type value = -1;
 1747|  4.81k|  for (std::size_t i = begin; i < end; ++i) {
  ------------------
  |  Branch (1747:31): [True: 2.47k, False: 2.33k]
  ------------------
 1748|  2.47k|    uchar_type label = keyset.keys(i, depth);
 1749|  2.47k|    if (label == '\0') {
  ------------------
  |  Branch (1749:9): [True: 526, False: 1.95k]
  ------------------
 1750|    526|      if (keyset.has_lengths() && depth < keyset.lengths(i)) {
  ------------------
  |  Branch (1750:11): [True: 526, False: 0]
  |  Branch (1750:35): [True: 0, False: 526]
  ------------------
 1751|      0|        DARTS_THROW("failed to build double-array: "
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1752|      0|            "invalid null character");
 1753|    526|      } else if (keyset.values(i) < 0) {
  ------------------
  |  Branch (1753:18): [True: 0, False: 526]
  ------------------
 1754|      0|        DARTS_THROW("failed to build double-array: negative value");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1755|      0|      }
 1756|       |
 1757|    526|      if (value == -1) {
  ------------------
  |  Branch (1757:11): [True: 526, False: 0]
  ------------------
 1758|    526|        value = keyset.values(i);
 1759|    526|      }
 1760|    526|      if (progress_func_ != NULL) {
  ------------------
  |  Branch (1760:11): [True: 0, False: 526]
  ------------------
 1761|      0|        progress_func_(i + 1, keyset.num_keys() + 1);
 1762|      0|      }
 1763|    526|    }
 1764|       |
 1765|  2.47k|    if (labels_.empty()) {
  ------------------
  |  Branch (1765:9): [True: 2.33k, False: 139]
  ------------------
 1766|  2.33k|      labels_.append(label);
 1767|  2.33k|    } else if (label != labels_[labels_.size() - 1]) {
  ------------------
  |  Branch (1767:16): [True: 103, False: 36]
  ------------------
 1768|    103|      if (label < labels_[labels_.size() - 1]) {
  ------------------
  |  Branch (1768:11): [True: 0, False: 103]
  ------------------
 1769|      0|        DARTS_THROW("failed to build double-array: wrong key order");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1770|      0|      }
 1771|    103|      labels_.append(label);
 1772|    103|    }
 1773|  2.47k|  }
 1774|       |
 1775|  2.33k|  id_type offset = find_valid_offset(dic_id);
 1776|  2.33k|  units_[dic_id].set_offset(dic_id ^ offset);
 1777|       |
 1778|  4.77k|  for (std::size_t i = 0; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1778:27): [True: 2.44k, False: 2.33k]
  ------------------
 1779|  2.44k|    id_type dic_child_id = offset ^ labels_[i];
 1780|  2.44k|    reserve_id(dic_child_id);
 1781|  2.44k|    if (labels_[i] == '\0') {
  ------------------
  |  Branch (1781:9): [True: 526, False: 1.91k]
  ------------------
 1782|    526|      units_[dic_id].set_has_leaf(true);
 1783|    526|      units_[dic_child_id].set_value(value);
 1784|  1.91k|    } else {
 1785|  1.91k|      units_[dic_child_id].set_label(labels_[i]);
 1786|  1.91k|    }
 1787|  2.44k|  }
 1788|  2.33k|  extras(offset).set_is_used(true);
 1789|       |
 1790|  2.33k|  return offset;
 1791|  2.33k|}
_ZNK5Darts7Details8AutoPoolIhE5emptyEv:
  640|  2.47k|  bool empty() const {
  641|  2.47k|    return size_ == 0;
  642|  2.47k|  }
_ZNK5Darts7Details6KeysetIiE4keysEmm:
  895|  6.86k|  uchar_type keys(std::size_t key_id, std::size_t char_id) const {
  896|  6.86k|    if (has_lengths() && char_id >= lengths_[key_id])
  ------------------
  |  Branch (896:9): [True: 6.86k, False: 0]
  |  Branch (896:26): [True: 1.05k, False: 5.81k]
  ------------------
  897|  1.05k|      return '\0';
  898|  5.81k|    return keys_[key_id][char_id];
  899|  6.86k|  }
_ZNK5Darts15DoubleArrayImplIvvivE16exactMatchSearchIiEEvPKcRT_mm:
  264|  2.74M|      std::size_t length = 0, std::size_t node_pos = 0) const {
  265|  2.74M|    result = exactMatchSearch<U>(key, length, node_pos);
  266|  2.74M|  }
_ZNK5Darts15DoubleArrayImplIvvivE16exactMatchSearchIiEET_PKcmm:
  462|  2.74M|    std::size_t length, std::size_t node_pos) const {
  463|  2.74M|  U result;
  464|  2.74M|  set_result(&result, static_cast<value_type>(-1), 0);
  465|       |
  466|  2.74M|  unit_type unit = array_[node_pos];
  467|  2.74M|  if (length != 0) {
  ------------------
  |  Branch (467:7): [True: 2.74M, False: 375]
  ------------------
  468|  7.08M|    for (std::size_t i = 0; i < length; ++i) {
  ------------------
  |  Branch (468:29): [True: 4.66M, False: 2.41M]
  ------------------
  469|  4.66M|      node_pos ^= unit.offset() ^ static_cast<uchar_type>(key[i]);
  470|  4.66M|      unit = array_[node_pos];
  471|  4.66M|      if (unit.label() != static_cast<uchar_type>(key[i])) {
  ------------------
  |  Branch (471:11): [True: 327k, False: 4.33M]
  ------------------
  472|   327k|        return result;
  473|   327k|      }
  474|  4.66M|    }
  475|  2.74M|  } else {
  476|    375|    for ( ; key[length] != '\0'; ++length) {
  ------------------
  |  Branch (476:13): [True: 2, False: 373]
  ------------------
  477|      2|      node_pos ^= unit.offset() ^ static_cast<uchar_type>(key[length]);
  478|      2|      unit = array_[node_pos];
  479|      2|      if (unit.label() != static_cast<uchar_type>(key[length])) {
  ------------------
  |  Branch (479:11): [True: 2, False: 0]
  ------------------
  480|      2|        return result;
  481|      2|      }
  482|      2|    }
  483|    375|  }
  484|       |
  485|  2.41M|  if (!unit.has_leaf()) {
  ------------------
  |  Branch (485:7): [True: 871, False: 2.41M]
  ------------------
  486|    871|    return result;
  487|    871|  }
  488|  2.41M|  unit = array_[node_pos ^ unit.offset()];
  489|  2.41M|  set_result(&result, static_cast<value_type>(unit.value()), length);
  490|  2.41M|  return result;
  491|  2.41M|}
_ZNK5Darts15DoubleArrayImplIvvivE10set_resultEPiim:
  154|  5.16M|  void set_result(value_type *result, value_type value, std::size_t) const {
  155|  5.16M|    *result = value;
  156|  5.16M|  }
_ZNK5Darts15DoubleArrayImplIvvivE8traverseEPKcRmS4_m:
  544|  61.2M|    std::size_t &node_pos, std::size_t &key_pos, std::size_t length) const {
  545|  61.2M|  id_type id = static_cast<id_type>(node_pos);
  546|  61.2M|  unit_type unit = array_[id];
  547|       |
  548|  61.2M|  if (length != 0) {
  ------------------
  |  Branch (548:7): [True: 61.2M, False: 0]
  ------------------
  549|  73.1M|    for ( ; key_pos < length; ++key_pos) {
  ------------------
  |  Branch (549:13): [True: 61.2M, False: 11.9M]
  ------------------
  550|  61.2M|      id ^= unit.offset() ^ static_cast<uchar_type>(key[key_pos]);
  551|  61.2M|      unit = array_[id];
  552|  61.2M|      if (unit.label() != static_cast<uchar_type>(key[key_pos])) {
  ------------------
  |  Branch (552:11): [True: 49.3M, False: 11.9M]
  ------------------
  553|  49.3M|        return static_cast<value_type>(-2);
  554|  49.3M|      }
  555|  11.9M|      node_pos = id;
  556|  11.9M|    }
  557|  61.2M|  } else {
  558|      0|    for ( ; key[key_pos] != '\0'; ++key_pos) {
  ------------------
  |  Branch (558:13): [True: 0, False: 0]
  ------------------
  559|      0|      id ^= unit.offset() ^ static_cast<uchar_type>(key[key_pos]);
  560|      0|      unit = array_[id];
  561|      0|      if (unit.label() != static_cast<uchar_type>(key[key_pos])) {
  ------------------
  |  Branch (561:11): [True: 0, False: 0]
  ------------------
  562|      0|        return static_cast<value_type>(-2);
  563|      0|      }
  564|      0|      node_pos = id;
  565|      0|    }
  566|      0|  }
  567|       |
  568|  11.9M|  if (!unit.has_leaf()) {
  ------------------
  |  Branch (568:7): [True: 5.79M, False: 6.12M]
  ------------------
  569|  5.79M|    return static_cast<value_type>(-1);
  570|  5.79M|  }
  571|  6.12M|  unit = array_[id ^ unit.offset()];
  572|  6.12M|  return static_cast<value_type>(unit.value());
  573|  11.9M|}

_ZN6google8protobuf8internal9ArenaFreeEPvm:
   75|  20.5k|void ArenaFree(void* object, size_t size) {
   76|  20.5k|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
   77|  20.5k|  ::operator delete(object, size);
   78|       |#else
   79|       |  (void)size;
   80|       |  ::operator delete(object);
   81|       |#endif
   82|  20.5k|}
_ZN6google8protobuf8internal9ArenaImpl4InitEb:
  126|  10.2k|void ArenaImpl::Init(bool record_allocs) {
  127|  10.2k|  ThreadCache& tc = thread_cache();
  128|  10.2k|  auto id = tc.next_lifecycle_id;
  129|  10.2k|  constexpr uint64 kInc = ThreadCache::kPerThreadIds * 2;
  130|  10.2k|  if (PROTOBUF_PREDICT_FALSE((id & (kInc - 1)) == 0)) {
  ------------------
  |  |  247|  10.2k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 41, False: 10.2k]
  |  |  ------------------
  ------------------
  131|     41|    if (sizeof(lifecycle_id_generator_.id) == 4) {
  ------------------
  |  Branch (131:9): [Folded, False: 41]
  ------------------
  132|       |      // 2^32 is dangerous low to guarantee uniqueness. If we start dolling out
  133|       |      // unique id's in ranges of kInc it's unacceptably low. In this case
  134|       |      // we increment by 1. The additional range of kPerThreadIds that are used
  135|       |      // per thread effectively pushes the overflow time from weeks to years
  136|       |      // of continuous running.
  137|      0|      id = lifecycle_id_generator_.id.fetch_add(1, std::memory_order_relaxed) *
  138|      0|           kInc;
  139|     41|    } else {
  140|     41|      id =
  141|     41|          lifecycle_id_generator_.id.fetch_add(kInc, std::memory_order_relaxed);
  142|     41|    }
  143|     41|  }
  144|  10.2k|  tc.next_lifecycle_id = id + 2;
  145|       |  // We store "record_allocs" in the low bit of lifecycle_id_.
  146|  10.2k|  lifecycle_id_ = id | (record_allocs ? 1 : 0);
  ------------------
  |  Branch (146:25): [True: 0, False: 10.2k]
  ------------------
  147|  10.2k|  hint_.store(nullptr, std::memory_order_relaxed);
  148|  10.2k|  threads_.store(nullptr, std::memory_order_relaxed);
  149|  10.2k|  space_allocated_.store(0, std::memory_order_relaxed);
  150|  10.2k|}
_ZN6google8protobuf8internal9ArenaImplD2Ev:
  162|  10.2k|ArenaImpl::~ArenaImpl() {
  163|       |  // Have to do this in a first pass, because some of the destructors might
  164|       |  // refer to memory in other blocks.
  165|  10.2k|  CleanupList();
  166|       |
  167|  10.2k|  ArenaMetricsCollector* collector = nullptr;
  168|  10.2k|  auto deallocator = &ArenaFree;
  169|  10.2k|  if (options_) {
  ------------------
  |  Branch (169:7): [True: 0, False: 10.2k]
  ------------------
  170|      0|    collector = options_->metrics_collector;
  171|      0|    deallocator = options_->block_dealloc;
  172|      0|  }
  173|       |
  174|  10.2k|  PerBlock([deallocator](SerialArena::Block* b) {
  175|       |#ifdef ADDRESS_SANITIZER
  176|       |    // This memory was provided by the underlying allocator as unpoisoned, so
  177|       |    // return it in an unpoisoned state.
  178|       |    ASAN_UNPOISON_MEMORY_REGION(b->Pointer(0), b->size());
  179|       |#endif  // ADDRESS_SANITIZER
  180|  10.2k|    if (!b->user_owned()) {
  181|  10.2k|      (*deallocator)(b, b->size());
  182|  10.2k|    }
  183|  10.2k|  });
  184|       |
  185|  10.2k|  if (collector) {
  ------------------
  |  Branch (185:7): [True: 0, False: 10.2k]
  ------------------
  186|      0|    collector->OnDestroy(SpaceAllocated());
  187|      0|  }
  188|  10.2k|}
_ZN6google8protobuf8internal9ArenaImpl9NewBufferEmm:
  235|  20.5k|                                              size_t min_bytes) {
  236|  20.5k|  size_t size;
  237|  20.5k|  if (last_size != -1) {
  ------------------
  |  Branch (237:7): [True: 10.2k, False: 10.2k]
  ------------------
  238|       |    // Double the current block size, up to a limit.
  239|  10.2k|    auto max_size = options_ ? options_->max_block_size : kDefaultMaxBlockSize;
  ------------------
  |  Branch (239:21): [True: 0, False: 10.2k]
  ------------------
  240|  10.2k|    size = std::min(2 * last_size, max_size);
  241|  10.2k|  } else {
  242|  10.2k|    size = options_ ? options_->start_block_size : kDefaultStartBlockSize;
  ------------------
  |  Branch (242:12): [True: 0, False: 10.2k]
  ------------------
  243|  10.2k|  }
  244|       |  // Verify that min_bytes + kBlockHeaderSize won't overflow.
  245|  20.5k|  GOOGLE_CHECK_LE(min_bytes, std::numeric_limits<size_t>::max() - kBlockHeaderSize);
  ------------------
  |  |  159|  20.5k|#define GOOGLE_CHECK_LE(A, B) GOOGLE_CHECK((A) <= (B))
  |  |  ------------------
  |  |  |  |  154|  20.5k|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|  20.5k|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 20.5k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  246|  20.5k|  size = std::max(size, kBlockHeaderSize + min_bytes);
  247|       |
  248|  20.5k|  void* mem = options_ ? (*options_->block_alloc)(size) : ::operator new(size);
  ------------------
  |  Branch (248:15): [True: 0, False: 20.5k]
  ------------------
  249|  20.5k|  space_allocated_.fetch_add(size, std::memory_order_relaxed);
  250|  20.5k|  return {mem, size};
  251|  20.5k|}
_ZN6google8protobuf8internal11SerialArena8NewBlockEPNS2_5BlockEmPNS1_9ArenaImplE:
  254|  20.5k|                                          size_t min_bytes, ArenaImpl* arena) {
  255|  20.5k|  void* mem;
  256|  20.5k|  size_t size;
  257|  20.5k|  std::tie(mem, size) =
  258|  20.5k|      arena->NewBuffer(last_block ? last_block->size() : -1, min_bytes);
  ------------------
  |  Branch (258:24): [True: 10.2k, False: 10.2k]
  ------------------
  259|  20.5k|  Block* b = new (mem) Block(size, last_block, false, false);
  260|  20.5k|  return b;
  261|  20.5k|}
_ZN6google8protobuf8internal11SerialArena18AddCleanupFallbackEPvPFvS3_E:
  264|  10.2k|void SerialArena::AddCleanupFallback(void* elem, void (*cleanup)(void*)) {
  265|  10.2k|  size_t size = cleanup_ ? cleanup_->size * 2 : kMinCleanupListElements;
  ------------------
  |  Branch (265:17): [True: 0, False: 10.2k]
  ------------------
  266|  10.2k|  size = std::min(size, kMaxCleanupListElements);
  267|  10.2k|  size_t bytes = internal::AlignUpTo8(CleanupChunk::SizeOf(size));
  268|  10.2k|  CleanupChunk* list = reinterpret_cast<CleanupChunk*>(AllocateAligned(bytes));
  269|  10.2k|  list->next = cleanup_;
  270|  10.2k|  list->size = size;
  271|       |
  272|  10.2k|  cleanup_ = list;
  273|  10.2k|  cleanup_ptr_ = &list->nodes[0];
  274|  10.2k|  cleanup_limit_ = &list->nodes[size];
  275|       |
  276|  10.2k|  AddCleanup(elem, cleanup);
  277|  10.2k|}
_ZN6google8protobuf8internal9ArenaImpl28AllocateAlignedAndAddCleanupEmPFvPvE:
  280|  10.2k|                                              void (*cleanup)(void*)) {
  281|  10.2k|  SerialArena* arena;
  282|  10.2k|  if (PROTOBUF_PREDICT_TRUE(GetSerialArenaFast(&arena))) {
  ------------------
  |  |  236|  10.2k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 10.2k]
  |  |  ------------------
  ------------------
  283|      0|    return arena->AllocateAlignedAndAddCleanup(n, cleanup);
  284|  10.2k|  } else {
  285|  10.2k|    return AllocateAlignedAndAddCleanupFallback(n, cleanup);
  286|  10.2k|  }
  287|  10.2k|}
_ZN6google8protobuf8internal9ArenaImpl36AllocateAlignedAndAddCleanupFallbackEmPFvPvE:
  305|  10.2k|                                                      void (*cleanup)(void*)) {
  306|  10.2k|  return GetSerialArenaFallback(
  307|  10.2k|      &thread_cache())->AllocateAlignedAndAddCleanup(n, cleanup);
  308|  10.2k|}
_ZN6google8protobuf8internal11SerialArena23AllocateAlignedFallbackEm:
  316|  10.2k|void* SerialArena::AllocateAlignedFallback(size_t n) {
  317|       |  // Sync back to current's pos.
  318|  10.2k|  head_->set_pos(head_->size() - (limit_ - ptr_));
  319|       |
  320|  10.2k|  head_ = NewBlock(head_, n, arena_);
  321|  10.2k|  ptr_ = head_->Pointer(head_->pos());
  322|  10.2k|  limit_ = head_->Pointer(head_->size());
  323|       |
  324|       |#ifdef ADDRESS_SANITIZER
  325|       |  ASAN_POISON_MEMORY_REGION(ptr_, limit_ - ptr_);
  326|       |#endif  // ADDRESS_SANITIZER
  327|       |
  328|  10.2k|  return AllocateAligned(n);
  329|  10.2k|}
_ZN6google8protobuf8internal9ArenaImpl11CleanupListEv:
  360|  10.2k|void ArenaImpl::CleanupList() {
  361|       |  // By omitting an Acquire barrier we ensure that any user code that doesn't
  362|       |  // properly synchronize Reset() or the destructor will throw a TSAN warning.
  363|  10.2k|  SerialArena* serial = threads_.load(std::memory_order_relaxed);
  364|       |
  365|  20.5k|  for (; serial; serial = serial->next()) {
  ------------------
  |  Branch (365:10): [True: 10.2k, False: 10.2k]
  ------------------
  366|  10.2k|    serial->CleanupList();
  367|  10.2k|  }
  368|  10.2k|}
_ZN6google8protobuf8internal11SerialArena11CleanupListEv:
  370|  10.2k|void SerialArena::CleanupList() {
  371|  10.2k|  if (cleanup_ != NULL) {
  ------------------
  |  Branch (371:7): [True: 10.2k, False: 0]
  ------------------
  372|  10.2k|    CleanupListFallback();
  373|  10.2k|  }
  374|  10.2k|}
_ZN6google8protobuf8internal11SerialArena19CleanupListFallbackEv:
  376|  10.2k|void SerialArena::CleanupListFallback() {
  377|       |  // The first chunk might be only partially full, so calculate its size
  378|       |  // from cleanup_ptr_. Subsequent chunks are always full, so use list->size.
  379|  10.2k|  size_t n = cleanup_ptr_ - &cleanup_->nodes[0];
  380|  10.2k|  CleanupChunk* list = cleanup_;
  381|  10.2k|  while (true) {
  ------------------
  |  Branch (381:10): [True: 10.2k, Folded]
  ------------------
  382|  10.2k|    CleanupNode* node = &list->nodes[0];
  383|       |    // Cleanup newest elements first (allocated last).
  384|  20.5k|    for (size_t i = n; i > 0; i--) {
  ------------------
  |  Branch (384:24): [True: 10.2k, False: 10.2k]
  ------------------
  385|  10.2k|      node[i - 1].cleanup(node[i - 1].elem);
  386|  10.2k|    }
  387|  10.2k|    list = list->next;
  388|  10.2k|    if (list == nullptr) {
  ------------------
  |  Branch (388:9): [True: 10.2k, False: 0]
  ------------------
  389|  10.2k|      break;
  390|  10.2k|    }
  391|       |    // All but the first chunk are always full.
  392|      0|    n = list->size;
  393|      0|  }
  394|  10.2k|}
_ZN6google8protobuf8internal11SerialArena3NewEPNS2_5BlockEPvPNS1_9ArenaImplE:
  396|  10.2k|SerialArena* SerialArena::New(Block* b, void* owner, ArenaImpl* arena) {
  397|  10.2k|  auto pos = b->pos();
  398|  10.2k|  GOOGLE_DCHECK_LE(pos + ArenaImpl::kSerialArenaSize, b->size());
  ------------------
  |  |  186|  10.2k|#define GOOGLE_DCHECK_LE(A, B) GOOGLE_DCHECK((A) <= (B))
  |  |  ------------------
  |  |  |  |  181|  10.2k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 10.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  399|  10.2k|  SerialArena* serial = reinterpret_cast<SerialArena*>(b->Pointer(pos));
  400|  10.2k|  b->set_pos(pos + ArenaImpl::kSerialArenaSize);
  401|  10.2k|  serial->arena_ = arena;
  402|  10.2k|  serial->owner_ = owner;
  403|  10.2k|  serial->head_ = b;
  404|  10.2k|  serial->ptr_ = b->Pointer(b->pos());
  405|  10.2k|  serial->limit_ = b->Pointer(b->size());
  406|  10.2k|  serial->cleanup_ = NULL;
  407|  10.2k|  serial->cleanup_ptr_ = NULL;
  408|       |  serial->cleanup_limit_ = NULL;
  409|  10.2k|  return serial;
  410|  10.2k|}
_ZN6google8protobuf8internal9ArenaImpl22GetSerialArenaFallbackEPv:
  413|  10.2k|SerialArena* ArenaImpl::GetSerialArenaFallback(void* me) {
  414|       |  // Look for this SerialArena in our linked list.
  415|  10.2k|  SerialArena* serial = threads_.load(std::memory_order_acquire);
  416|  10.2k|  for (; serial; serial = serial->next()) {
  ------------------
  |  Branch (416:10): [True: 0, False: 10.2k]
  ------------------
  417|      0|    if (serial->owner() == me) {
  ------------------
  |  Branch (417:9): [True: 0, False: 0]
  ------------------
  418|      0|      break;
  419|      0|    }
  420|      0|  }
  421|       |
  422|  10.2k|  if (!serial) {
  ------------------
  |  Branch (422:7): [True: 10.2k, False: 0]
  ------------------
  423|       |    // This thread doesn't have any SerialArena, which also means it doesn't
  424|       |    // have any blocks yet.  So we'll allocate its first block now.
  425|  10.2k|    SerialArena::Block* b = SerialArena::NewBlock(NULL, kSerialArenaSize, this);
  426|  10.2k|    serial = SerialArena::New(b, me, this);
  427|       |
  428|  10.2k|    SerialArena* head = threads_.load(std::memory_order_relaxed);
  429|  10.2k|    do {
  430|  10.2k|      serial->set_next(head);
  431|  10.2k|    } while (!threads_.compare_exchange_weak(
  ------------------
  |  Branch (431:14): [True: 0, False: 10.2k]
  ------------------
  432|  10.2k|        head, serial, std::memory_order_release, std::memory_order_relaxed));
  433|  10.2k|  }
  434|       |
  435|  10.2k|  CacheSerialArena(serial);
  436|  10.2k|  return serial;
  437|  10.2k|}
arena.cc:_ZZN6google8protobuf8internal9ArenaImplD1EvENK3$_0clEPNS1_11SerialArena5BlockE:
  174|  20.5k|  PerBlock([deallocator](SerialArena::Block* b) {
  175|       |#ifdef ADDRESS_SANITIZER
  176|       |    // This memory was provided by the underlying allocator as unpoisoned, so
  177|       |    // return it in an unpoisoned state.
  178|       |    ASAN_UNPOISON_MEMORY_REGION(b->Pointer(0), b->size());
  179|       |#endif  // ADDRESS_SANITIZER
  180|  20.5k|    if (!b->user_owned()) {
  ------------------
  |  Branch (180:9): [True: 20.5k, False: 0]
  ------------------
  181|  20.5k|      (*deallocator)(b, b->size());
  182|  20.5k|    }
  183|  20.5k|  });

_ZNK6google8protobuf8internal10LazyString4InitEv:
   50|      5|const std::string& LazyString::Init() const {
   51|      5|  static WrappedMutex mu{GOOGLE_PROTOBUF_LINKER_INITIALIZED};
   52|      5|  mu.Lock();
   53|      5|  const std::string* res = inited_.load(std::memory_order_acquire);
   54|      5|  if (res == nullptr) {
  ------------------
  |  Branch (54:7): [True: 5, False: 0]
  ------------------
   55|      5|    auto init_value = init_value_;
   56|      5|    res = ::new (static_cast<void*>(string_buf_))
   57|      5|        std::string(init_value.ptr, init_value.size);
   58|      5|    inited_.store(res, std::memory_order_release);
   59|      5|  }
   60|      5|  mu.Unlock();
   61|      5|  return *res;
   62|      5|}
_ZN6google8protobuf8internal14ArenaStringPtr3SetEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEOS9_PNS0_5ArenaE:
   75|  19.9M|                         ::google::protobuf::Arena* arena) {
   76|  19.9M|  if (IsDefault(default_value)) {
  ------------------
  |  Branch (76:7): [True: 19.9M, False: 0]
  ------------------
   77|  19.9M|    if (arena == nullptr) {
  ------------------
  |  Branch (77:9): [True: 19.9M, False: 0]
  ------------------
   78|  19.9M|      tagged_ptr_.Set(new std::string(std::move(value)));
   79|  19.9M|    } else {
   80|      0|      tagged_ptr_.Set(Arena::Create<std::string>(arena, std::move(value)));
   81|      0|    }
   82|  19.9M|  } else if (IsDonatedString()) {
  ------------------
  |  Branch (82:14): [True: 0, False: 0]
  ------------------
   83|      0|    std::string* current = tagged_ptr_.Get();
   84|      0|    auto* s = new (current) std::string(std::move(value));
   85|      0|    arena->OwnDestructor(s);
   86|      0|    tagged_ptr_.Set(s);
   87|      0|  } else /* !IsDonatedString() */ {
   88|      0|    *UnsafeMutablePointer() = std::move(value);
   89|      0|  }
   90|  19.9M|}
_ZN6google8protobuf8internal14ArenaStringPtr3SetENS2_12EmptyDefaultEONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaE:
   98|  19.9M|                         ::google::protobuf::Arena* arena) {
   99|  19.9M|  Set(&GetEmptyStringAlreadyInited(), std::move(value), arena);
  100|  19.9M|}
_ZN6google8protobuf8internal14ArenaStringPtr7MutableENS2_12EmptyDefaultEPNS0_5ArenaE:
  112|  92.7M|std::string* ArenaStringPtr::Mutable(EmptyDefault, ::google::protobuf::Arena* arena) {
  113|  92.7M|  if (!IsDonatedString() && !IsDefault(&GetEmptyStringAlreadyInited())) {
  ------------------
  |  Branch (113:7): [True: 92.7M, False: 0]
  |  Branch (113:29): [True: 89.5M, False: 3.19M]
  ------------------
  114|  89.5M|    return UnsafeMutablePointer();
  115|  89.5M|  } else {
  116|  3.19M|    return MutableSlow(arena);
  117|  3.19M|  }
  118|  92.7M|}
_ZN6google8protobuf8internal14ArenaStringPtr7MutableERKNS1_10LazyStringEPNS0_5ArenaE:
  121|    167|                                     ::google::protobuf::Arena* arena) {
  122|    167|  if (!IsDonatedString() && !IsDefault(nullptr)) {
  ------------------
  |  Branch (122:7): [True: 167, False: 0]
  |  Branch (122:29): [True: 54, False: 113]
  ------------------
  123|     54|    return UnsafeMutablePointer();
  124|    113|  } else {
  125|    113|    return MutableSlow(arena, default_value);
  126|    113|  }
  127|    167|}
_ZN6google8protobuf8internal14ArenaStringPtr11MutableSlowIJEEEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaEDpRKT_:
  144|  3.19M|                                         const Lazy&... lazy_default) {
  145|  3.19M|  const std::string* const default_value =
  146|  3.19M|      sizeof...(Lazy) == 0 ? &GetEmptyStringAlreadyInited() : nullptr;
  ------------------
  |  Branch (146:7): [True: 3.19M, Folded]
  ------------------
  147|  3.19M|  GOOGLE_DCHECK(IsDefault(default_value));
  ------------------
  |  |  181|  3.19M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 3.19M]
  |  |  ------------------
  ------------------
  148|  3.19M|  std::string* new_string =
  149|  3.19M|      Arena::Create<std::string>(arena, lazy_default.get()...);
  150|  3.19M|  tagged_ptr_.Set(new_string);
  151|  3.19M|  return new_string;
  152|  3.19M|}
_ZN6google8protobuf8internal14ArenaStringPtr11MutableSlowIJNS1_10LazyStringEEEEPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPNS0_5ArenaEDpRKT_:
  144|    113|                                         const Lazy&... lazy_default) {
  145|    113|  const std::string* const default_value =
  146|    113|      sizeof...(Lazy) == 0 ? &GetEmptyStringAlreadyInited() : nullptr;
  ------------------
  |  Branch (146:7): [Folded, False: 113]
  ------------------
  147|    113|  GOOGLE_DCHECK(IsDefault(default_value));
  ------------------
  |  |  181|    113|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 113]
  |  |  ------------------
  ------------------
  148|    113|  std::string* new_string =
  149|    113|      Arena::Create<std::string>(arena, lazy_default.get()...);
  150|    113|  tagged_ptr_.Set(new_string);
  151|    113|  return new_string;
  152|    113|}

_ZN6google8protobuf2io19EpsCopyOutputStream30WriteStringMaybeAliasedOutlineEjRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPh:
  914|  25.9k|                                                           uint8* ptr) {
  915|  25.9k|  ptr = EnsureSpace(ptr);
  916|  25.9k|  uint32 size = s.size();
  917|  25.9k|  ptr = WriteLengthDelim(num, size, ptr);
  918|  25.9k|  return WriteRawMaybeAliased(s.data(), size, ptr);
  919|  25.9k|}

_ZN6google8protobuf8internal13VerifyVersionEiiPKc:
   73|      9|                   const char* filename) {
   74|      9|  if (GOOGLE_PROTOBUF_VERSION < minLibraryVersion) {
  ------------------
  |  |   85|      9|#define GOOGLE_PROTOBUF_VERSION 3014000
  ------------------
  |  Branch (74:7): [True: 0, False: 9]
  ------------------
   75|       |    // Library is too old for headers.
   76|      0|    GOOGLE_LOG(FATAL)
  ------------------
  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  ------------------
   77|      0|      << "This program requires version " << VersionString(minLibraryVersion)
   78|      0|      << " of the Protocol Buffer runtime library, but the installed version "
   79|      0|         "is " << VersionString(GOOGLE_PROTOBUF_VERSION) << ".  Please update "
  ------------------
  |  |   85|      0|#define GOOGLE_PROTOBUF_VERSION 3014000
  ------------------
   80|      0|         "your library.  If you compiled the program yourself, make sure that "
   81|      0|         "your headers are from the same version of Protocol Buffers as your "
   82|      0|         "link-time library.  (Version verification failed in \""
   83|      0|      << filename << "\".)";
   84|      0|  }
   85|      9|  if (headerVersion < kMinHeaderVersionForLibrary) {
  ------------------
  |  Branch (85:7): [True: 0, False: 9]
  ------------------
   86|       |    // Headers are too old for library.
   87|      0|    GOOGLE_LOG(FATAL)
  ------------------
  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  ------------------
   88|      0|      << "This program was compiled against version "
   89|      0|      << VersionString(headerVersion) << " of the Protocol Buffer runtime "
   90|      0|         "library, which is not compatible with the installed version ("
   91|      0|      << VersionString(GOOGLE_PROTOBUF_VERSION) <<  ").  Contact the program "
  ------------------
  |  |   85|      0|#define GOOGLE_PROTOBUF_VERSION 3014000
  ------------------
   92|      0|         "author for an update.  If you compiled the program yourself, make "
   93|      0|         "sure that your headers are from the same version of Protocol Buffers "
   94|      0|         "as your link-time library.  (Version verification failed in \""
   95|      0|      << filename << "\".)";
   96|      0|  }
   97|      9|}

_ZN6google8protobuf8internal15ExtensionFinderD2Ev:
  124|  9.39k|ExtensionFinder::~ExtensionFinder() {}
_ZN6google8protobuf8internal24GeneratedExtensionFinder4FindEiPNS1_13ExtensionInfoE:
  126|  9.39k|bool GeneratedExtensionFinder::Find(int number, ExtensionInfo* output) {
  127|  9.39k|  const ExtensionInfo* extension =
  128|  9.39k|      FindRegisteredExtension(containing_type_, number);
  129|  9.39k|  if (extension == NULL) {
  ------------------
  |  Branch (129:7): [True: 9.39k, False: 0]
  ------------------
  130|  9.39k|    return false;
  131|  9.39k|  } else {
  132|      0|    *output = *extension;
  133|      0|    return true;
  134|      0|  }
  135|  9.39k|}
_ZN6google8protobuf8internal12ExtensionSetC2EPNS0_5ArenaE:
  188|  13.0M|    : arena_(arena),
  189|  13.0M|      flat_capacity_(0),
  190|  13.0M|      flat_size_(0),
  191|  13.0M|      map_{flat_capacity_ == 0
  ------------------
  |  Branch (191:12): [True: 13.0M, False: 0]
  ------------------
  192|  13.0M|               ? NULL
  193|  13.0M|               : Arena::CreateArray<KeyValue>(arena_, flat_capacity_)} {}
_ZN6google8protobuf8internal12ExtensionSetD2Ev:
  195|  13.0M|ExtensionSet::~ExtensionSet() {
  196|       |  // Deletes all allocated extensions.
  197|  13.0M|  if (arena_ == NULL) {
  ------------------
  |  Branch (197:7): [True: 13.0M, False: 0]
  ------------------
  198|  13.0M|    ForEach([](int /* number */, Extension& ext) { ext.Free(); });
  199|  13.0M|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  13.0M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 13.0M]
  |  |  ------------------
  ------------------
  200|      0|      delete map_.large;
  201|  13.0M|    } else {
  202|  13.0M|      DeleteFlatMap(map_.flat, flat_capacity_);
  203|  13.0M|    }
  204|  13.0M|  }
  205|  13.0M|}
_ZN6google8protobuf8internal12ExtensionSet13DeleteFlatMapEPKNS2_8KeyValueEt:
  208|  13.0M|                                 uint16 flat_capacity) {
  209|  13.0M|#ifdef __cpp_sized_deallocation
  210|       |  // Arena::CreateArray already requires a trivially destructible type, but
  211|       |  // ensure this constraint is not violated in the future.
  212|  13.0M|  static_assert(std::is_trivially_destructible<KeyValue>::value,
  213|  13.0M|                "CreateArray requires a trivially destructible type");
  214|       |  // A const-cast is needed, but this is safe as we are about to deallocate the
  215|       |  // array.
  216|  13.0M|  ::operator delete[](const_cast<ExtensionSet::KeyValue*>(flat),
  217|  13.0M|                      sizeof(*flat) * flat_capacity);
  218|       |#else   // !__cpp_sized_deallocation
  219|       |  delete[] flat;
  220|       |#endif  // !__cpp_sized_deallocation
  221|  13.0M|}
_ZN6google8protobuf8internal12ExtensionSet5ClearEv:
  877|  20.0k|void ExtensionSet::Clear() {
  878|  20.0k|  ForEach([](int /* number */, Extension& ext) { ext.Clear(); });
  879|  20.0k|}
_ZNK6google8protobuf8internal12ExtensionSet13IsInitializedEv:
 1127|  1.31M|bool ExtensionSet::IsInitialized() const {
 1128|       |  // Extensions are never required.  However, we need to check that all
 1129|       |  // embedded messages are initialized.
 1130|  1.31M|  if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  1.31M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 1.31M]
  |  |  ------------------
  ------------------
 1131|      0|    for (const auto& kv : *map_.large) {
  ------------------
  |  Branch (1131:25): [True: 0, False: 0]
  ------------------
 1132|      0|      if (!kv.second.IsInitialized()) return false;
  ------------------
  |  Branch (1132:11): [True: 0, False: 0]
  ------------------
 1133|      0|    }
 1134|      0|    return true;
 1135|      0|  }
 1136|  1.31M|  for (const KeyValue* it = flat_begin(); it != flat_end(); ++it) {
  ------------------
  |  Branch (1136:43): [True: 0, False: 1.31M]
  ------------------
 1137|      0|    if (!it->second.IsInitialized()) return false;
  ------------------
  |  Branch (1137:9): [True: 0, False: 0]
  ------------------
 1138|      0|  }
 1139|  1.31M|  return true;
 1140|  1.31M|}
_ZN6google8protobuf8internal12ExtensionSet32FindExtensionInfoFromFieldNumberEiiPNS1_15ExtensionFinderEPNS1_13ExtensionInfoEPb:
 1156|  9.39k|    ExtensionInfo* extension, bool* was_packed_on_wire) {
 1157|  9.39k|  if (!extension_finder->Find(field_number, extension)) {
  ------------------
  |  Branch (1157:7): [True: 9.39k, False: 0]
  ------------------
 1158|  9.39k|    return false;
 1159|  9.39k|  }
 1160|       |
 1161|      0|  WireFormatLite::WireType expected_wire_type =
 1162|      0|      WireFormatLite::WireTypeForFieldType(real_type(extension->type));
 1163|       |
 1164|       |  // Check if this is a packed field.
 1165|      0|  *was_packed_on_wire = false;
 1166|      0|  if (extension->is_repeated &&
  ------------------
  |  Branch (1166:7): [True: 0, False: 0]
  ------------------
 1167|      0|      wire_type == WireFormatLite::WIRETYPE_LENGTH_DELIMITED &&
  ------------------
  |  Branch (1167:7): [True: 0, False: 0]
  ------------------
 1168|      0|      is_packable(expected_wire_type)) {
  ------------------
  |  Branch (1168:7): [True: 0, False: 0]
  ------------------
 1169|      0|    *was_packed_on_wire = true;
 1170|      0|    return true;
 1171|      0|  }
 1172|       |  // Otherwise the wire type must match.
 1173|      0|  return expected_wire_type == wire_type;
 1174|      0|}
_ZN6google8protobuf8internal12ExtensionSet10ParseFieldEmPKcPKNS0_11MessageLiteEPNS1_16InternalMetadataEPNS1_12ParseContextE:
 1194|  9.39k|                                     internal::ParseContext* ctx) {
 1195|  9.39k|  GeneratedExtensionFinder finder(containing_type);
 1196|  9.39k|  int number = tag >> 3;
 1197|  9.39k|  bool was_packed_on_wire;
 1198|  9.39k|  ExtensionInfo extension;
 1199|  9.39k|  if (!FindExtensionInfoFromFieldNumber(tag & 7, number, &finder, &extension,
  ------------------
  |  Branch (1199:7): [True: 9.39k, False: 0]
  ------------------
 1200|  9.39k|                                        &was_packed_on_wire)) {
 1201|  9.39k|    return UnknownFieldParse(
 1202|  9.39k|        tag, metadata->mutable_unknown_fields<std::string>(), ptr, ctx);
 1203|  9.39k|  }
 1204|      0|  return ParseFieldWithExtensionInfo<std::string>(
 1205|      0|      number, was_packed_on_wire, extension, metadata, ptr, ctx);
 1206|  9.39k|}
_ZNK6google8protobuf8internal12ExtensionSet18_InternalSerializeEiiPhPNS0_2io19EpsCopyOutputStreamE:
 1460|  3.13M|                                        io::EpsCopyOutputStream* stream) const {
 1461|  3.13M|  if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  3.13M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 3.13M]
  |  |  ------------------
  ------------------
 1462|      0|    const auto& end = map_.large->end();
 1463|      0|    for (auto it = map_.large->lower_bound(start_field_number);
 1464|      0|         it != end && it->first < end_field_number; ++it) {
  ------------------
  |  Branch (1464:10): [True: 0, False: 0]
  |  Branch (1464:23): [True: 0, False: 0]
  ------------------
 1465|      0|      target = it->second.InternalSerializeFieldWithCachedSizesToArray(
 1466|      0|          it->first, target, stream);
 1467|      0|    }
 1468|      0|    return target;
 1469|      0|  }
 1470|  3.13M|  const KeyValue* end = flat_end();
 1471|  3.13M|  for (const KeyValue* it = std::lower_bound(
 1472|  3.13M|           flat_begin(), end, start_field_number, KeyValue::FirstComparator());
 1473|  3.13M|       it != end && it->first < end_field_number; ++it) {
  ------------------
  |  Branch (1473:8): [True: 0, False: 3.13M]
  |  Branch (1473:21): [True: 0, False: 0]
  ------------------
 1474|      0|    target = it->second.InternalSerializeFieldWithCachedSizesToArray(
 1475|      0|        it->first, target, stream);
 1476|      0|  }
 1477|  3.13M|  return target;
 1478|  3.13M|}
_ZNK6google8protobuf8internal12ExtensionSet8ByteSizeEv:
 1489|  3.13M|size_t ExtensionSet::ByteSize() const {
 1490|  3.13M|  size_t total_size = 0;
 1491|  3.13M|  ForEach([&total_size](int number, const Extension& ext) {
 1492|  3.13M|    total_size += ext.ByteSize(number);
 1493|  3.13M|  });
 1494|  3.13M|  return total_size;
 1495|  3.13M|}
extension_set.cc:_ZN6google8protobuf8internal12_GLOBAL__N_123FindRegisteredExtensionEPKNS0_11MessageLiteEi:
  115|  9.39k|                                             int number) {
  116|  9.39k|  return global_registry == nullptr
  ------------------
  |  Branch (116:10): [True: 9.39k, False: 0]
  ------------------
  117|  9.39k|             ? nullptr
  118|  9.39k|             : FindOrNull(*global_registry,
  119|      0|                               std::make_pair(containing_type, number));
  120|  9.39k|}

_ZN6google8protobuf8internal24InitProtobufDefaultsSlowEv:
   89|      1|void InitProtobufDefaultsSlow() {
   90|      1|  static bool is_inited = InitProtobufDefaultsImpl();
   91|      1|  (void)is_inited;
   92|      1|}
_ZN6google8protobuf8internal11InitSCCImplEPNS1_11SCCInfoBaseE:
  764|     12|void InitSCCImpl(SCCInfoBase* scc) {
  765|     12|  static WrappedMutex mu{GOOGLE_PROTOBUF_LINKER_INITIALIZED};
  766|       |  // Either the default in case no initialization is running or the id of the
  767|       |  // thread that is currently initializing.
  768|     12|#ifndef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
  769|     12|  static std::atomic<std::thread::id> runner;
  770|     12|  auto me = std::this_thread::get_id();
  771|       |#else
  772|       |  // This is a lightweight replacement for std::thread::id. std::thread does not
  773|       |  // work on Windows XP SP2 with the latest VC++ libraries, because it utilizes
  774|       |  // the Concurrency Runtime that is only supported on Windows XP SP3 and above.
  775|       |  static std::atomic_llong runner(-1);
  776|       |  auto me = ::GetCurrentThreadId();
  777|       |#endif  // #ifndef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
  778|       |
  779|       |  // This will only happen because the constructor will call InitSCC while
  780|       |  // constructing the default instance.
  781|     12|  if (runner.load(std::memory_order_relaxed) == me) {
  ------------------
  |  Branch (781:7): [True: 9, False: 3]
  ------------------
  782|       |    // Because we're in the process of constructing the default instance.
  783|       |    // We can be assured that we're already exploring this SCC.
  784|      9|    GOOGLE_CHECK_EQ(scc->visit_status.load(std::memory_order_relaxed),
  ------------------
  |  |  156|      9|#define GOOGLE_CHECK_EQ(A, B) GOOGLE_CHECK((A) == (B))
  |  |  ------------------
  |  |  |  |  154|      9|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      9|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 9, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  785|      9|             SCCInfoBase::kRunning);
  786|      9|    return;
  787|      9|  }
  788|      3|  InitProtobufDefaults();
  789|      3|  mu.Lock();
  790|      3|  runner.store(me, std::memory_order_relaxed);
  791|      3|  InitSCC_DFS(scc);
  792|       |
  793|      3|#ifndef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
  794|      3|  runner.store(std::thread::id{}, std::memory_order_relaxed);
  795|       |#else
  796|       |  runner.store(-1, std::memory_order_relaxed);
  797|       |#endif  // #ifndef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
  798|       |
  799|      3|  mu.Unlock();
  800|      3|}
generated_message_util.cc:_ZN6google8protobuf8internalL24InitProtobufDefaultsImplEv:
   76|      1|static bool InitProtobufDefaultsImpl() {
   77|      1|  ::new (static_cast<void*>(&fixed_address_empty_string.value)) std::string();
   78|      1|  OnShutdownDestroyString(&fixed_address_empty_string.value);
   79|       |
   80|       |  // Verify that we can indeed get the address during constant evaluation.
   81|      1|  PROTOBUF_CONSTINIT static const std::string& fixed_address_empty_string_test =
  ------------------
  |  |  589|      1|#define PROTOBUF_CONSTINIT [[clang::require_constant_initialization]]
  ------------------
   82|      1|      GetEmptyStringAlreadyInited();
   83|      1|  (void)fixed_address_empty_string_test;
   84|       |
   85|      1|  init_protobuf_defaults_state.store(true, std::memory_order_release);
   86|      1|  return true;
   87|      1|}
generated_message_util.cc:_ZN6google8protobuf8internal12_GLOBAL__N_111InitSCC_DFSEPNS1_11SCCInfoBaseE:
  736|     10|void InitSCC_DFS(SCCInfoBase* scc) {
  737|     10|  if (scc->visit_status.load(std::memory_order_relaxed) !=
  ------------------
  |  Branch (737:7): [True: 1, False: 9]
  ------------------
  738|     10|      SCCInfoBase::kUninitialized)
  739|      1|    return;
  740|      9|  scc->visit_status.store(SCCInfoBase::kRunning, std::memory_order_relaxed);
  741|       |  // Each base is followed by an array of void*, containing first pointers to
  742|       |  // SCCInfoBase and then pointers-to-pointers to SCCInfoBase.
  743|      9|  auto deps = reinterpret_cast<void**>(scc + 1);
  744|      9|  auto strong_deps = reinterpret_cast<SCCInfoBase* const*>(deps);
  745|     16|  for (int i = 0; i < scc->num_deps; ++i) {
  ------------------
  |  Branch (745:19): [True: 7, False: 9]
  ------------------
  746|      7|    if (strong_deps[i]) InitSCC_DFS(strong_deps[i]);
  ------------------
  |  Branch (746:9): [True: 7, False: 0]
  ------------------
  747|      7|  }
  748|      9|  auto implicit_weak_deps =
  749|      9|      reinterpret_cast<SCCInfoBase** const*>(deps + scc->num_deps);
  750|      9|  for (int i = 0; i < scc->num_implicit_weak_deps; ++i) {
  ------------------
  |  Branch (750:19): [True: 0, False: 9]
  ------------------
  751|      0|    if (*implicit_weak_deps[i]) {
  ------------------
  |  Branch (751:9): [True: 0, False: 0]
  ------------------
  752|      0|      InitSCC_DFS(*implicit_weak_deps[i]);
  753|      0|    }
  754|      0|  }
  755|      9|  scc->init_func();
  756|       |  // Mark done (note we use memory order release here), other threads could
  757|       |  // now see this as initialized and thus the initialization must have happened
  758|       |  // before.
  759|      9|  scc->visit_status.store(SCCInfoBase::kInitialized, std::memory_order_release);
  760|      9|}

_ZN6google8protobuf5ArenaC2Ev:
  228|  10.2k|  inline Arena() : impl_() {}
_ZN6google8protobuf5ArenaD2Ev:
  250|  10.2k|  inline ~Arena() {}
_ZN6google8protobuf5Arena6CreateIN13sentencepiece17SentencePieceTextEJEEEPT_PS1_DpOT0_:
  292|  8.25k|  PROTOBUF_ALWAYS_INLINE static T* Create(Arena* arena, Args&&... args) {
  293|  8.25k|    return CreateNoMessage<T>(arena, is_arena_constructable<T>(),
  294|  8.25k|                              std::forward<Args>(args)...);
  295|  8.25k|  }
_ZN6google8protobuf5Arena15CreateNoMessageIN13sentencepiece17SentencePieceTextEJEEEPT_PS1_NSt3__117integral_constantIbLb1EEEDpOT0_:
  537|  8.25k|                                                   Args&&... args) {
  538|       |    // User is constructing with Create() despite the fact that T supports arena
  539|       |    // construction.  In this case we have to delegate to CreateInternal(), and
  540|       |    // we can't use any CreateMaybeMessage() specialization that may be defined.
  541|  8.25k|    return CreateInternal<T>(arena, std::forward<Args>(args)...);
  542|  8.25k|  }
_ZN6google8protobuf5Arena14CreateInternalIN13sentencepiece17SentencePieceTextEJEEEPT_PS1_DpOT0_:
  472|  8.25k|                                                  Args&&... args) {
  473|  8.25k|    if (arena == NULL) {
  ------------------
  |  Branch (473:9): [True: 0, False: 8.25k]
  ------------------
  474|      0|      return new T(std::forward<Args>(args)...);
  475|  8.25k|    } else {
  476|  8.25k|      return arena->DoCreate<T>(std::is_trivially_destructible<T>::value,
  477|  8.25k|                                std::forward<Args>(args)...);
  478|  8.25k|    }
  479|  8.25k|  }
_ZN6google8protobuf5Arena8DoCreateIN13sentencepiece17SentencePieceTextEJEEEPT_bDpOT0_:
  570|  8.25k|                                     Args&&... args) {
  571|  8.25k|    return new (AllocateInternal<T>(skip_explicit_ownership))
  572|  8.25k|        T(std::forward<Args>(args)...);
  573|  8.25k|  }
_ZN6google8protobuf5Arena16AllocateInternalIN13sentencepiece17SentencePieceTextEEEPvb:
  488|  8.25k|  PROTOBUF_ALWAYS_INLINE void* AllocateInternal(bool skip_explicit_ownership) {
  489|  8.25k|    const size_t n = internal::AlignUpTo8(sizeof(T));
  490|       |    // Monitor allocation if needed.
  491|  8.25k|    impl_.RecordAlloc(RTTI_TYPE_ID(T), n);
  ------------------
  |  |  174|  8.25k|#define RTTI_TYPE_ID(type) (&typeid(type))
  ------------------
  492|  8.25k|    if (skip_explicit_ownership) {
  ------------------
  |  Branch (492:9): [True: 0, False: 8.25k]
  ------------------
  493|      0|      return AllocateAlignedTo<alignof(T)>(sizeof(T));
  494|  8.25k|    } else {
  495|  8.25k|      if (alignof(T) <= 8) {
  ------------------
  |  Branch (495:11): [True: 8.25k, Folded]
  ------------------
  496|  8.25k|        return impl_.AllocateAlignedAndAddCleanup(
  497|  8.25k|            n, &internal::arena_destruct_object<T>);
  498|  8.25k|      } else {
  499|      0|        auto ptr =
  500|      0|            reinterpret_cast<uintptr_t>(impl_.AllocateAlignedAndAddCleanup(
  501|      0|                sizeof(T) + alignof(T) - 8,
  502|      0|                &internal::arena_destruct_object<T>));
  503|      0|        return reinterpret_cast<void*>((ptr + alignof(T) - 8) &
  504|      0|                                       (~alignof(T) + 1));
  505|      0|      }
  506|  8.25k|    }
  507|  8.25k|  }
_ZN6google8protobuf8internal21arena_destruct_objectIN13sentencepiece17SentencePieceTextEEEvPv:
   98|  8.25k|void arena_destruct_object(void* object) {
   99|  8.25k|  reinterpret_cast<T*>(object)->~T();
  100|  8.25k|}
_ZN6google8protobuf5Arena6CreateIN13sentencepiece22NBestSentencePieceTextEJEEEPT_PS1_DpOT0_:
  292|  2.03k|  PROTOBUF_ALWAYS_INLINE static T* Create(Arena* arena, Args&&... args) {
  293|  2.03k|    return CreateNoMessage<T>(arena, is_arena_constructable<T>(),
  294|  2.03k|                              std::forward<Args>(args)...);
  295|  2.03k|  }
_ZN6google8protobuf5Arena15CreateNoMessageIN13sentencepiece22NBestSentencePieceTextEJEEEPT_PS1_NSt3__117integral_constantIbLb1EEEDpOT0_:
  537|  2.03k|                                                   Args&&... args) {
  538|       |    // User is constructing with Create() despite the fact that T supports arena
  539|       |    // construction.  In this case we have to delegate to CreateInternal(), and
  540|       |    // we can't use any CreateMaybeMessage() specialization that may be defined.
  541|  2.03k|    return CreateInternal<T>(arena, std::forward<Args>(args)...);
  542|  2.03k|  }
_ZN6google8protobuf5Arena14CreateInternalIN13sentencepiece22NBestSentencePieceTextEJEEEPT_PS1_DpOT0_:
  472|  2.03k|                                                  Args&&... args) {
  473|  2.03k|    if (arena == NULL) {
  ------------------
  |  Branch (473:9): [True: 0, False: 2.03k]
  ------------------
  474|      0|      return new T(std::forward<Args>(args)...);
  475|  2.03k|    } else {
  476|  2.03k|      return arena->DoCreate<T>(std::is_trivially_destructible<T>::value,
  477|  2.03k|                                std::forward<Args>(args)...);
  478|  2.03k|    }
  479|  2.03k|  }
_ZN6google8protobuf5Arena8DoCreateIN13sentencepiece22NBestSentencePieceTextEJEEEPT_bDpOT0_:
  570|  2.03k|                                     Args&&... args) {
  571|  2.03k|    return new (AllocateInternal<T>(skip_explicit_ownership))
  572|  2.03k|        T(std::forward<Args>(args)...);
  573|  2.03k|  }
_ZN6google8protobuf5Arena16AllocateInternalIN13sentencepiece22NBestSentencePieceTextEEEPvb:
  488|  2.03k|  PROTOBUF_ALWAYS_INLINE void* AllocateInternal(bool skip_explicit_ownership) {
  489|  2.03k|    const size_t n = internal::AlignUpTo8(sizeof(T));
  490|       |    // Monitor allocation if needed.
  491|  2.03k|    impl_.RecordAlloc(RTTI_TYPE_ID(T), n);
  ------------------
  |  |  174|  2.03k|#define RTTI_TYPE_ID(type) (&typeid(type))
  ------------------
  492|  2.03k|    if (skip_explicit_ownership) {
  ------------------
  |  Branch (492:9): [True: 0, False: 2.03k]
  ------------------
  493|      0|      return AllocateAlignedTo<alignof(T)>(sizeof(T));
  494|  2.03k|    } else {
  495|  2.03k|      if (alignof(T) <= 8) {
  ------------------
  |  Branch (495:11): [True: 2.03k, Folded]
  ------------------
  496|  2.03k|        return impl_.AllocateAlignedAndAddCleanup(
  497|  2.03k|            n, &internal::arena_destruct_object<T>);
  498|  2.03k|      } else {
  499|      0|        auto ptr =
  500|      0|            reinterpret_cast<uintptr_t>(impl_.AllocateAlignedAndAddCleanup(
  501|      0|                sizeof(T) + alignof(T) - 8,
  502|      0|                &internal::arena_destruct_object<T>));
  503|      0|        return reinterpret_cast<void*>((ptr + alignof(T) - 8) &
  504|      0|                                       (~alignof(T) + 1));
  505|      0|      }
  506|  2.03k|    }
  507|  2.03k|  }
_ZN6google8protobuf8internal21arena_destruct_objectIN13sentencepiece22NBestSentencePieceTextEEEvPv:
   98|  2.03k|void arena_destruct_object(void* object) {
   99|  2.03k|  reinterpret_cast<T*>(object)->~T();
  100|  2.03k|}
_ZN6google8protobuf5Arena6CreateINS0_8internal16InternalMetadata9ContainerINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEEEPT_PS1_DpOT0_:
  292|  9.10k|  PROTOBUF_ALWAYS_INLINE static T* Create(Arena* arena, Args&&... args) {
  293|  9.10k|    return CreateNoMessage<T>(arena, is_arena_constructable<T>(),
  294|  9.10k|                              std::forward<Args>(args)...);
  295|  9.10k|  }
_ZN6google8protobuf5Arena15CreateNoMessageINS0_8internal16InternalMetadata9ContainerINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEEEPT_PS1_NS6_17integral_constantIbLb0EEEDpOT0_:
  547|  9.10k|                                                   Args&&... args) {
  548|       |    // User is constructing with Create() and the type does not support arena
  549|       |    // construction.  In this case we can delegate to CreateMaybeMessage() and
  550|       |    // use any specialization that may be available for that.
  551|  9.10k|    return CreateMaybeMessage<T>(arena, std::forward<Args>(args)...);
  552|  9.10k|  }
_ZN6google8protobuf5Arena18CreateMaybeMessageINS0_8internal16InternalMetadata9ContainerINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEEEPT_PS1_DpOT0_:
  530|  9.10k|                                                      Args&&... args) {
  531|  9.10k|    return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(),
  532|  9.10k|                                   std::forward<Args>(args)...);
  533|  9.10k|  }
_ZN6google8protobuf5Arena20DoCreateMaybeMessageINS0_8internal16InternalMetadata9ContainerINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEEEPT_PS1_NS6_17integral_constantIbLb0EEEDpOT0_:
  524|  9.10k|                                                        Args&&... args) {
  525|  9.10k|    return CreateInternal<T>(arena, std::forward<Args>(args)...);
  526|  9.10k|  }
_ZN6google8protobuf5Arena14CreateInternalINS0_8internal16InternalMetadata9ContainerINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEEEPT_PS1_DpOT0_:
  472|  9.10k|                                                  Args&&... args) {
  473|  9.10k|    if (arena == NULL) {
  ------------------
  |  Branch (473:9): [True: 9.10k, False: 0]
  ------------------
  474|  9.10k|      return new T(std::forward<Args>(args)...);
  475|  9.10k|    } else {
  476|      0|      return arena->DoCreate<T>(std::is_trivially_destructible<T>::value,
  477|      0|                                std::forward<Args>(args)...);
  478|      0|    }
  479|  9.10k|  }
_ZN6google8protobuf5Arena6CreateINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_:
  292|  3.21M|  PROTOBUF_ALWAYS_INLINE static T* Create(Arena* arena, Args&&... args) {
  293|  3.21M|    return CreateNoMessage<T>(arena, is_arena_constructable<T>(),
  294|  3.21M|                              std::forward<Args>(args)...);
  295|  3.21M|  }
_ZN6google8protobuf5Arena15CreateNoMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  547|  3.21M|                                                   Args&&... args) {
  548|       |    // User is constructing with Create() and the type does not support arena
  549|       |    // construction.  In this case we can delegate to CreateMaybeMessage() and
  550|       |    // use any specialization that may be available for that.
  551|  3.21M|    return CreateMaybeMessage<T>(arena, std::forward<Args>(args)...);
  552|  3.21M|  }
_ZN6google8protobuf5Arena18CreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_:
  530|  3.21M|                                                      Args&&... args) {
  531|  3.21M|    return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(),
  532|  3.21M|                                   std::forward<Args>(args)...);
  533|  3.21M|  }
_ZN6google8protobuf5Arena20DoCreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  524|  3.21M|                                                        Args&&... args) {
  525|  3.21M|    return CreateInternal<T>(arena, std::forward<Args>(args)...);
  526|  3.21M|  }
_ZN6google8protobuf5Arena14CreateInternalINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_:
  472|  3.21M|                                                  Args&&... args) {
  473|  3.21M|    if (arena == NULL) {
  ------------------
  |  Branch (473:9): [True: 3.21M, False: 0]
  ------------------
  474|  3.21M|      return new T(std::forward<Args>(args)...);
  475|  3.21M|    } else {
  476|      0|      return arena->DoCreate<T>(std::is_trivially_destructible<T>::value,
  477|      0|                                std::forward<Args>(args)...);
  478|      0|    }
  479|  3.21M|  }
_ZN6google8protobuf5Arena6CreateINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_DpOT0_:
  292|    113|  PROTOBUF_ALWAYS_INLINE static T* Create(Arena* arena, Args&&... args) {
  293|    113|    return CreateNoMessage<T>(arena, is_arena_constructable<T>(),
  294|    113|                              std::forward<Args>(args)...);
  295|    113|  }
_ZN6google8protobuf5Arena15CreateNoMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  547|    113|                                                   Args&&... args) {
  548|       |    // User is constructing with Create() and the type does not support arena
  549|       |    // construction.  In this case we can delegate to CreateMaybeMessage() and
  550|       |    // use any specialization that may be available for that.
  551|    113|    return CreateMaybeMessage<T>(arena, std::forward<Args>(args)...);
  552|    113|  }
_ZN6google8protobuf5Arena18CreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_DpOT0_:
  530|    113|                                                      Args&&... args) {
  531|    113|    return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(),
  532|    113|                                   std::forward<Args>(args)...);
  533|    113|  }
_ZN6google8protobuf5Arena20DoCreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  524|    113|                                                        Args&&... args) {
  525|    113|    return CreateInternal<T>(arena, std::forward<Args>(args)...);
  526|    113|  }
_ZN6google8protobuf5Arena14CreateInternalINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_DpOT0_:
  472|    113|                                                  Args&&... args) {
  473|    113|    if (arena == NULL) {
  ------------------
  |  Branch (473:9): [True: 113, False: 0]
  ------------------
  474|    113|      return new T(std::forward<Args>(args)...);
  475|    113|    } else {
  476|      0|      return arena->DoCreate<T>(std::is_trivially_destructible<T>::value,
  477|      0|                                std::forward<Args>(args)...);
  478|      0|    }
  479|    113|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece31SentencePieceText_SentencePieceEEEPT_PS1_:
  459|  11.5M|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  11.5M|    static_assert(
  461|  11.5M|        InternalHelper<T>::is_arena_constructable::value,
  462|  11.5M|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  11.5M|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 11.5M, False: 0]
  ------------------
  464|  11.5M|      return new T();
  465|  11.5M|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  11.5M|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece17SentencePieceTextEEEPT_PS1_:
  459|  2.14k|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  2.14k|    static_assert(
  461|  2.14k|        InternalHelper<T>::is_arena_constructable::value,
  462|  2.14k|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  2.14k|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 2.14k, False: 0]
  ------------------
  464|  2.14k|      return new T();
  465|  2.14k|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  2.14k|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece11TrainerSpecEEEPT_PS1_:
  459|  2.89k|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  2.89k|    static_assert(
  461|  2.89k|        InternalHelper<T>::is_arena_constructable::value,
  462|  2.89k|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  2.89k|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 2.89k, False: 0]
  ------------------
  464|  2.89k|      return new T();
  465|  2.89k|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  2.89k|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece14NormalizerSpecEEEPT_PS1_:
  459|  1.27k|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  1.27k|    static_assert(
  461|  1.27k|        InternalHelper<T>::is_arena_constructable::value,
  462|  1.27k|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  1.27k|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 1.27k, False: 0]
  ------------------
  464|  1.27k|      return new T();
  465|  1.27k|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  1.27k|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece19SelfTestData_SampleEEEPT_PS1_:
  459|  1.58k|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  1.58k|    static_assert(
  461|  1.58k|        InternalHelper<T>::is_arena_constructable::value,
  462|  1.58k|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  1.58k|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 1.58k, False: 0]
  ------------------
  464|  1.58k|      return new T();
  465|  1.58k|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  1.58k|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece12SelfTestDataEEEPT_PS1_:
  459|    625|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|    625|    static_assert(
  461|    625|        InternalHelper<T>::is_arena_constructable::value,
  462|    625|        "CreateMessage can only construct types that are ArenaConstructable");
  463|    625|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 625, False: 0]
  ------------------
  464|    625|      return new T();
  465|    625|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|    625|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece24ModelProto_SentencePieceEEEPT_PS1_:
  459|  1.48M|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  1.48M|    static_assert(
  461|  1.48M|        InternalHelper<T>::is_arena_constructable::value,
  462|  1.48M|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  1.48M|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 1.48M, False: 0]
  ------------------
  464|  1.48M|      return new T();
  465|  1.48M|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  1.48M|  }

_ZN6google8protobuf8internal9ArenaImplC2Ev:
  262|  10.2k|  ArenaImpl() { Init(false); }
_ZN6google8protobuf8internal10AlignUpTo8Em:
   56|  20.5k|inline size_t AlignUpTo8(size_t n) {
   57|       |  // Align n to next multiple of 8 (from Hacker's Delight, Chapter 3.)
   58|  20.5k|  return (n + 7) & static_cast<size_t>(-8);
   59|  20.5k|}
_ZNK6google8protobuf8internal9ArenaImpl11RecordAllocEPKSt9type_infom:
  315|  10.2k|                          size_t n) const {
  316|  10.2k|    if (PROTOBUF_PREDICT_FALSE(record_allocs())) {
  ------------------
  |  |  247|  10.2k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 10.2k]
  |  |  ------------------
  ------------------
  317|      0|      options_->metrics_collector->OnAlloc(allocated_type, n);
  318|      0|    }
  319|  10.2k|  }
_ZNK6google8protobuf8internal9ArenaImpl13record_allocsEv:
  352|  10.2k|  inline bool record_allocs() const { return lifecycle_id_ & 1; }
_ZN6google8protobuf8internal11SerialArena5BlockC2EmPS3_bb:
  103|  20.5k|        : next_and_bits_(reinterpret_cast<uintptr_t>(next) | (special ? 1 : 0) |
  ------------------
  |  Branch (103:63): [True: 0, False: 20.5k]
  ------------------
  104|  20.5k|                         (user_owned ? 2 : 0)),
  ------------------
  |  Branch (104:27): [True: 0, False: 20.5k]
  ------------------
  105|  20.5k|          pos_(kBlockHeaderSize),
  106|  20.5k|          size_(size) {
  107|  20.5k|      GOOGLE_DCHECK_EQ(reinterpret_cast<uintptr_t>(next) & 3, 0u);
  ------------------
  |  |  183|  20.5k|#define GOOGLE_DCHECK_EQ(A, B) GOOGLE_DCHECK((A) == (B))
  |  |  ------------------
  |  |  |  |  181|  20.5k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 20.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  108|  20.5k|    }
_ZN6google8protobuf8internal11SerialArena5Block7PointerEm:
  110|  51.4k|    char* Pointer(size_t n) {
  111|  51.4k|      GOOGLE_DCHECK(n <= size_);
  ------------------
  |  |  181|  51.4k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 51.4k]
  |  |  ------------------
  ------------------
  112|  51.4k|      return reinterpret_cast<char*>(this) + n;
  113|  51.4k|    }
_ZNK6google8protobuf8internal11SerialArena5Block10user_ownedEv:
  122|  20.5k|    bool user_owned() const { return (next_and_bits_ & 2) != 0; }
_ZNK6google8protobuf8internal11SerialArena5Block4nextEv:
  124|  20.5k|    Block* next() const {
  125|  20.5k|      const uintptr_t bottom_bits = 3;
  126|  20.5k|      return reinterpret_cast<Block*>(next_and_bits_ & ~bottom_bits);
  127|  20.5k|    }
_ZNK6google8protobuf8internal11SerialArena5Block3posEv:
  133|  30.8k|    size_t pos() const { return pos_; }
_ZNK6google8protobuf8internal11SerialArena5Block4sizeEv:
  134|  61.6k|    size_t size() const { return size_; }
_ZN6google8protobuf8internal11SerialArena5Block7set_posEm:
  135|  20.5k|    void set_pos(size_t pos) { pos_ = pos; }
_ZN6google8protobuf8internal11SerialArena8HasSpaceEm:
  156|  30.8k|  bool HasSpace(size_t n) { return n <= static_cast<size_t>(limit_ - ptr_); }
_ZN6google8protobuf8internal11SerialArena15AllocateAlignedEm:
  158|  30.8k|  void* AllocateAligned(size_t n) {
  159|  30.8k|    GOOGLE_DCHECK_EQ(internal::AlignUpTo8(n), n);  // Must be already aligned.
  ------------------
  |  |  183|  30.8k|#define GOOGLE_DCHECK_EQ(A, B) GOOGLE_DCHECK((A) == (B))
  |  |  ------------------
  |  |  |  |  181|  30.8k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 30.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  160|  30.8k|    GOOGLE_DCHECK_GE(limit_, ptr_);
  ------------------
  |  |  188|  30.8k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|  30.8k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 30.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  161|  30.8k|    if (PROTOBUF_PREDICT_FALSE(!HasSpace(n))) {
  ------------------
  |  |  247|  30.8k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 10.2k, False: 20.5k]
  |  |  ------------------
  ------------------
  162|  10.2k|      return AllocateAlignedFallback(n);
  163|  10.2k|    }
  164|  20.5k|    void* ret = ptr_;
  165|  20.5k|    ptr_ += n;
  166|       |#ifdef ADDRESS_SANITIZER
  167|       |    ASAN_UNPOISON_MEMORY_REGION(ret, n);
  168|       |#endif  // ADDRESS_SANITIZER
  169|  20.5k|    return ret;
  170|  30.8k|  }
_ZN6google8protobuf8internal11SerialArena10AddCleanupEPvPFvS3_E:
  186|  20.5k|  void AddCleanup(void* elem, void (*cleanup)(void*)) {
  187|  20.5k|    if (PROTOBUF_PREDICT_FALSE(cleanup_ptr_ == cleanup_limit_)) {
  ------------------
  |  |  247|  20.5k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 10.2k, False: 10.2k]
  |  |  ------------------
  ------------------
  188|  10.2k|      AddCleanupFallback(elem, cleanup);
  189|  10.2k|      return;
  190|  10.2k|    }
  191|  10.2k|    cleanup_ptr_->elem = elem;
  192|  10.2k|    cleanup_ptr_->cleanup = cleanup;
  193|  10.2k|    cleanup_ptr_++;
  194|  10.2k|  }
_ZN6google8protobuf8internal11SerialArena28AllocateAlignedAndAddCleanupEmPFvPvE:
  196|  10.2k|  void* AllocateAlignedAndAddCleanup(size_t n, void (*cleanup)(void*)) {
  197|  10.2k|    void* ret = AllocateAligned(n);
  198|  10.2k|    AddCleanup(ret, cleanup);
  199|  10.2k|    return ret;
  200|  10.2k|  }
_ZNK6google8protobuf8internal11SerialArena4headEv:
  202|  10.2k|  Block* head() const { return head_; }
_ZNK6google8protobuf8internal11SerialArena4nextEv:
  204|  20.5k|  SerialArena* next() const { return next_; }
_ZN6google8protobuf8internal11SerialArena8set_nextEPS2_:
  205|  10.2k|  void set_next(SerialArena* next) { next_ = next; }
_ZN6google8protobuf8internal11SerialArena12CleanupChunk6SizeOfEm:
  218|  10.2k|    static size_t SizeOf(size_t i) {
  219|  10.2k|      return sizeof(CleanupChunk) + (sizeof(CleanupNode) * (i - 1));
  220|  10.2k|    }
_ZN6google8protobuf8internal9ArenaImpl16CacheSerialArenaEPNS1_11SerialArenaE:
  375|  10.2k|  inline void CacheSerialArena(SerialArena* serial) {
  376|  10.2k|    thread_cache().last_serial_arena = serial;
  377|  10.2k|    thread_cache().last_lifecycle_id_seen = lifecycle_id_;
  378|       |    // TODO(haberman): evaluate whether we would gain efficiency by getting rid
  379|       |    // of hint_.  It's the only write we do to ArenaImpl in the allocation path,
  380|       |    // which will dirty the cache line.
  381|       |
  382|  10.2k|    hint_.store(serial, std::memory_order_release);
  383|  10.2k|  }
_ZN6google8protobuf8internal9ArenaImpl18GetSerialArenaFastEPPNS1_11SerialArenaE:
  385|  10.2k|  PROTOBUF_ALWAYS_INLINE bool GetSerialArenaFast(SerialArena** arena) {
  386|  10.2k|    if (GetSerialArenaFromThreadCache(arena)) return true;
  ------------------
  |  Branch (386:9): [True: 0, False: 10.2k]
  ------------------
  387|       |
  388|       |    // Check whether we own the last accessed SerialArena on this arena.  This
  389|       |    // fast path optimizes the case where a single thread uses multiple arenas.
  390|  10.2k|    ThreadCache* tc = &thread_cache();
  391|  10.2k|    SerialArena* serial = hint_.load(std::memory_order_acquire);
  392|  10.2k|    if (PROTOBUF_PREDICT_TRUE(serial != NULL && serial->owner() == tc)) {
  ------------------
  |  |  236|  10.2k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 10.2k]
  |  |  |  Branch (236:55): [True: 0, False: 10.2k]
  |  |  |  Branch (236:55): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  393|      0|      *arena = serial;
  394|      0|      return true;
  395|      0|    }
  396|  10.2k|    return false;
  397|  10.2k|  }
_ZN6google8protobuf8internal9ArenaImpl29GetSerialArenaFromThreadCacheEPPNS1_11SerialArenaE:
  400|  10.2k|      SerialArena** arena) {
  401|       |    // If this thread already owns a block in this arena then try to use that.
  402|       |    // This fast path optimizes the case where multiple threads allocate from
  403|       |    // the same arena.
  404|  10.2k|    ThreadCache* tc = &thread_cache();
  405|  10.2k|    if (PROTOBUF_PREDICT_TRUE(tc->last_lifecycle_id_seen == lifecycle_id_)) {
  ------------------
  |  |  236|  10.2k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 10.2k]
  |  |  ------------------
  ------------------
  406|      0|      *arena = tc->last_serial_arena;
  407|      0|      return true;
  408|      0|    }
  409|  10.2k|    return false;
  410|  10.2k|  }
_ZN6google8protobuf8internal9ArenaImpl12thread_cacheEv:
  462|  61.6k|  static ThreadCache& thread_cache() { return thread_cache_; }
arena.cc:_ZN6google8protobuf8internal9ArenaImpl8PerBlockIZNS2_D1EvE3$_0EEvT_:
  356|  10.2k|  void PerBlock(Functor fn) {
  357|       |    // By omitting an Acquire barrier we ensure that any user code that doesn't
  358|       |    // properly synchronize Reset() or the destructor will throw a TSAN warning.
  359|  10.2k|    SerialArena* serial = threads_.load(std::memory_order_relaxed);
  360|  20.5k|    while (serial) {
  ------------------
  |  Branch (360:12): [True: 10.2k, False: 10.2k]
  ------------------
  361|       |      // fn() may delete blocks and arenas, so fetch next pointers before fn();
  362|  10.2k|      SerialArena* cur = serial;
  363|  10.2k|      serial = serial->next();
  364|  30.8k|      for (auto* block = cur->head(); block != nullptr;) {
  ------------------
  |  Branch (364:39): [True: 20.5k, False: 10.2k]
  ------------------
  365|  20.5k|        auto* b = block;
  366|  20.5k|        block = b->next();
  367|  20.5k|        fn(b);
  368|  20.5k|      }
  369|  10.2k|    }
  370|  10.2k|  }

_ZNK6google8protobuf8internal14ArenaStringPtr3GetEv:
  194|  23.2M|  const std::string& Get() const PROTOBUF_ALWAYS_INLINE {
  195|       |    // Unconditionally mask away the tag.
  196|  23.2M|    return *tagged_ptr_.Get();
  197|  23.2M|  }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEv:
   99|  23.2M|  T* Get() const { return reinterpret_cast<T*>(as_int() & -2); }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE6as_intEv:
  109|  23.2M|  uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
_ZNK6google8protobuf8internal14ArenaStringPtr9IsDefaultEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  279|   137M|  inline bool IsDefault(const std::string* default_value) const {
  280|       |    // Relies on the fact that kPtrTagString == 0, so if IsString(), ptr_ is the
  281|       |    // actual std::string pointer (and if !IsString(), ptr_ will never be equal
  282|       |    // to any aligned |default_value| pointer). The key is that we want to avoid
  283|       |    // masking in the fastpath const-pointer Get() case for non-arena code.
  284|   137M|    return tagged_ptr_.UnsafeGet() == default_value;
  285|   137M|  }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE9UnsafeGetEv:
  104|   249M|  T* UnsafeGet() const { return static_cast<T*>(ptr_); }
_ZNK6google8protobuf8internal10LazyString3getEv:
   74|  16.3k|  const std::string& get() const {
   75|       |    // This check generates less code than a call-once invocation.
   76|  16.3k|    auto* res = inited_.load(std::memory_order_acquire);
   77|  16.3k|    if (PROTOBUF_PREDICT_FALSE(res == nullptr)) return Init();
  ------------------
  |  |  247|  16.3k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 5, False: 16.3k]
  |  |  ------------------
  ------------------
   78|  16.3k|    return *res;
   79|  16.3k|  }
_ZNK6google8protobuf8internal14ArenaStringPtr15IsDonatedStringEv:
  290|  92.7M|  bool IsDonatedString() const { return false; }
_ZN6google8protobuf8internal14ArenaStringPtr16UnsafeSetDefaultEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  301|  24.5M|inline void ArenaStringPtr::UnsafeSetDefault(const std::string* value) {
  302|  24.5M|  tagged_ptr_.Set(const_cast<std::string*>(value));
  303|  24.5M|}
_ZN6google8protobuf8internal14ArenaStringPtr14DestroyNoArenaEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  356|  24.5M|inline void ArenaStringPtr::DestroyNoArena(const std::string* default_value) {
  357|  24.5M|  if (!IsDefault(default_value)) {
  ------------------
  |  Branch (357:7): [True: 23.1M, False: 1.47M]
  ------------------
  358|  23.1M|    delete UnsafeMutablePointer();
  359|  23.1M|  }
  360|  24.5M|}
_ZN6google8protobuf8internal14ArenaStringPtr20UnsafeMutablePointerEv:
  362|   112M|inline std::string* ArenaStringPtr::UnsafeMutablePointer() {
  363|   112M|  GOOGLE_DCHECK(!tagged_ptr_.IsTagged());
  ------------------
  |  |  181|   112M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 112M]
  |  |  ------------------
  ------------------
  364|   112M|  GOOGLE_DCHECK(tagged_ptr_.UnsafeGet() != nullptr);
  ------------------
  |  |  181|   112M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 112M]
  |  |  ------------------
  ------------------
  365|   112M|  return tagged_ptr_.UnsafeGet();
  366|   112M|}
_ZN6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3SetEPS9_:
   98|  47.6M|  void Set(T* p) { ptr_ = p; }

_ZN6google8protobuf8internal13ExtensionInfoC2Ev:
  101|  9.39k|  inline ExtensionInfo() {}
_ZN6google8protobuf8internal24GeneratedExtensionFinderC2EPKNS0_11MessageLiteE:
  147|  9.39k|      : containing_type_(containing_type) {}
_ZNK6google8protobuf8internal12ExtensionSet8is_largeEv:
  667|  33.6M|  bool is_large() const { return flat_capacity_ > kMaximumFlatCapacity; }
_ZN6google8protobuf8internal12ExtensionSet10flat_beginEv:
  816|  13.0M|  KeyValue* flat_begin() {
  817|       |    assert(!is_large());
  818|  13.0M|    return map_.flat;
  819|  13.0M|  }
_ZNK6google8protobuf8internal12ExtensionSet10flat_beginEv:
  820|  7.59M|  const KeyValue* flat_begin() const {
  821|       |    assert(!is_large());
  822|  7.59M|    return map_.flat;
  823|  7.59M|  }
_ZN6google8protobuf8internal12ExtensionSet8flat_endEv:
  824|  13.0M|  KeyValue* flat_end() {
  825|       |    assert(!is_large());
  826|  13.0M|    return map_.flat + flat_size_;
  827|  13.0M|  }
_ZNK6google8protobuf8internal12ExtensionSet8flat_endEv:
  828|  7.59M|  const KeyValue* flat_end() const {
  829|       |    assert(!is_large());
  830|  7.59M|    return map_.flat + flat_size_;
  831|  7.59M|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIZNS2_D1EvE3$_0EET_S5_:
  688|  13.0M|  KeyValueFunctor ForEach(KeyValueFunctor func) {
  689|  13.0M|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  13.0M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 13.0M]
  |  |  ------------------
  ------------------
  690|      0|      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
  691|      0|    }
  692|  13.0M|    return ForEach(flat_begin(), flat_end(), std::move(func));
  693|  13.0M|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIPNS2_8KeyValueEZNS2_D1EvE3$_0EET0_T_S8_S7_:
  681|  13.0M|                                 KeyValueFunctor func) {
  682|  13.0M|    for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
  ------------------
  |  Branch (682:31): [True: 0, False: 13.0M]
  ------------------
  683|  13.0M|    return std::move(func);
  684|  13.0M|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIZNS2_5ClearEvE3$_0EET_S5_:
  688|  20.0k|  KeyValueFunctor ForEach(KeyValueFunctor func) {
  689|  20.0k|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  20.0k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 20.0k]
  |  |  ------------------
  ------------------
  690|      0|      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
  691|      0|    }
  692|  20.0k|    return ForEach(flat_begin(), flat_end(), std::move(func));
  693|  20.0k|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIPNS2_8KeyValueEZNS2_5ClearEvE3$_0EET0_T_S8_S7_:
  681|  20.0k|                                 KeyValueFunctor func) {
  682|  20.0k|    for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
  ------------------
  |  Branch (682:31): [True: 0, False: 20.0k]
  ------------------
  683|  20.0k|    return std::move(func);
  684|  20.0k|  }
extension_set.cc:_ZNK6google8protobuf8internal12ExtensionSet7ForEachIZNKS2_8ByteSizeEvE3$_0EET_S5_:
  697|  3.13M|  KeyValueFunctor ForEach(KeyValueFunctor func) const {
  698|  3.13M|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  3.13M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 3.13M]
  |  |  ------------------
  ------------------
  699|      0|      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
  700|      0|    }
  701|  3.13M|    return ForEach(flat_begin(), flat_end(), std::move(func));
  702|  3.13M|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIPKNS2_8KeyValueEZNKS2_8ByteSizeEvE3$_0EET0_T_S9_S8_:
  681|  3.13M|                                 KeyValueFunctor func) {
  682|  3.13M|    for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
  ------------------
  |  Branch (682:31): [True: 0, False: 3.13M]
  ------------------
  683|  3.13M|    return std::move(func);
  684|  3.13M|  }

_ZNK6google8protobuf8internal10CachedSize3GetEv:
  188|  3.13M|  int Get() const { return size_.load(std::memory_order_relaxed); }
_ZN6google8protobuf8internal10CachedSize3SetEi:
  189|  3.13M|  void Set(int size) { size_.store(size, std::memory_order_relaxed); }
_ZN6google8protobuf8internal20InitProtobufDefaultsEv:
   93|      3|PROTOBUF_EXPORT inline void InitProtobufDefaults() {
   94|      3|  if (PROTOBUF_PREDICT_FALSE(
  ------------------
  |  |  247|      3|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 1, False: 2]
  |  |  ------------------
  ------------------
   95|      3|          !init_protobuf_defaults_state.load(std::memory_order_acquire))) {
   96|      1|    InitProtobufDefaultsSlow();
   97|      1|  }
   98|      3|}
_ZN6google8protobuf8internal7InitSCCEPNS1_11SCCInfoBaseE:
  247|  13.0M|inline void InitSCC(SCCInfoBase* scc) {
  248|  13.0M|  auto status = scc->visit_status.load(std::memory_order_acquire);
  249|  13.0M|  if (PROTOBUF_PREDICT_FALSE(status != SCCInfoBase::kInitialized))
  ------------------
  |  |  247|  13.0M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 12, False: 13.0M]
  |  |  ------------------
  ------------------
  250|     12|    InitSCCImpl(scc);
  251|  13.0M|}
_ZN6google8protobuf8internal24OnShutdownDestroyMessageEPKv:
  256|      9|inline void OnShutdownDestroyMessage(const void* ptr) {
  257|      9|  OnShutdownRun(DestroyMessage, ptr);
  258|      9|}
_ZN6google8protobuf8internal23OnShutdownDestroyStringEPKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  260|      1|inline void OnShutdownDestroyString(const std::string* ptr) {
  261|      1|  OnShutdownRun(DestroyString, ptr);
  262|      1|}
_ZN6google8protobuf8internal17AllAreInitializedIN13sentencepiece24ModelProto_SentencePieceEEEbRKNS0_16RepeatedPtrFieldIT_EE:
  113|  3.17k|bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
  114|  1.31M|  for (int i = t.size(); --i >= 0;) {
  ------------------
  |  Branch (114:26): [True: 1.31M, False: 3.17k]
  ------------------
  115|  1.31M|    if (!t.Get(i).IsInitialized()) return false;
  ------------------
  |  Branch (115:9): [True: 0, False: 1.31M]
  ------------------
  116|  1.31M|  }
  117|  3.17k|  return true;
  118|  3.17k|}

_ZNK6google8protobuf8internal7HasBitsILm1EEixEi:
   60|  7.78M|  const uint32& operator[](int index) const PROTOBUF_ALWAYS_INLINE {
   61|  7.78M|    return has_bits_[index];
   62|  7.78M|  }
_ZN6google8protobuf8internal7HasBitsILm1EEixEi:
   56|   192M|  uint32& operator[](int index) PROTOBUF_ALWAYS_INLINE {
   57|   192M|    return has_bits_[index];
   58|   192M|  }
_ZNK6google8protobuf8internal7HasBitsILm2EEixEi:
   60|  8.88k|  const uint32& operator[](int index) const PROTOBUF_ALWAYS_INLINE {
   61|  8.88k|    return has_bits_[index];
   62|  8.88k|  }
_ZN6google8protobuf8internal7HasBitsILm2EEixEi:
   56|  23.7k|  uint32& operator[](int index) PROTOBUF_ALWAYS_INLINE {
   57|  23.7k|    return has_bits_[index];
   58|  23.7k|  }
_ZN6google8protobuf8internal7HasBitsILm1EEC2Ev:
   50|  14.5M|  constexpr HasBits() PROTOBUF_ALWAYS_INLINE : has_bits_{} {}
_ZN6google8protobuf8internal7HasBitsILm1EE5ClearEv:
   52|  20.0k|  void Clear() PROTOBUF_ALWAYS_INLINE {
   53|  20.0k|    memset(has_bits_, 0, sizeof(has_bits_));
   54|  20.0k|  }
_ZN6google8protobuf8internal7HasBitsILm1EE2OrERKS3_:
   72|  1.50M|  void Or(const HasBits<doublewords>& rhs) {
   73|  3.00M|    for (size_t i = 0; i < doublewords; i++) has_bits_[i] |= rhs[i];
  ------------------
  |  Branch (73:24): [True: 1.50M, False: 1.50M]
  ------------------
   74|  1.50M|  }
_ZN6google8protobuf8internal7HasBitsILm2EEC2Ev:
   50|  2.90k|  constexpr HasBits() PROTOBUF_ALWAYS_INLINE : has_bits_{} {}

_ZN6google8protobuf2io16CodedInputStream24GetDefaultRecursionLimitEv:
  415|  7.70k|  static int GetDefaultRecursionLimit() { return default_recursion_limit_; }
_ZN6google8protobuf2io19EpsCopyOutputStreamC2EPvib:
  669|  6.09k|      : end_(static_cast<uint8*>(data) + size),
  670|  6.09k|        buffer_end_(nullptr),
  671|  6.09k|        stream_(nullptr),
  672|  6.09k|        is_serialization_deterministic_(deterministic) {}
_ZN6google8protobuf2io19EpsCopyOutputStream11EnsureSpaceEPh:
  688|  12.5M|  PROTOBUF_MUST_USE_RESULT uint8* EnsureSpace(uint8* ptr) {
  689|  12.5M|    if (PROTOBUF_PREDICT_FALSE(ptr >= end_)) {
  ------------------
  |  |  247|  12.5M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 12.5M]
  |  |  ------------------
  ------------------
  690|      0|      return EnsureSpaceFallback(ptr);
  691|      0|    }
  692|  12.5M|    return ptr;
  693|  12.5M|  }
_ZN6google8protobuf2io19EpsCopyOutputStream8WriteRawEPKviPh:
  695|  27.9k|  uint8* WriteRaw(const void* data, int size, uint8* ptr) {
  696|  27.9k|    if (PROTOBUF_PREDICT_FALSE(end_ - ptr < size)) {
  ------------------
  |  |  247|  27.9k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 27.9k]
  |  |  ------------------
  ------------------
  697|      0|      return WriteRawFallback(data, size, ptr);
  698|      0|    }
  699|  27.9k|    std::memcpy(ptr, data, size);
  700|  27.9k|    return ptr + size;
  701|  27.9k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream20WriteRawMaybeAliasedEPKviPh:
  706|  25.9k|  uint8* WriteRawMaybeAliased(const void* data, int size, uint8* ptr) {
  707|  25.9k|    if (aliasing_enabled_) {
  ------------------
  |  Branch (707:9): [True: 0, False: 25.9k]
  ------------------
  708|      0|      return WriteAliasedRaw(data, size, ptr);
  709|  25.9k|    } else {
  710|  25.9k|      return WriteRaw(data, size, ptr);
  711|  25.9k|    }
  712|  25.9k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream23WriteStringMaybeAliasedEjRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPh:
  715|  6.23M|  uint8* WriteStringMaybeAliased(uint32 num, const std::string& s, uint8* ptr) {
  716|  6.23M|    std::ptrdiff_t size = s.size();
  717|  6.23M|    if (PROTOBUF_PREDICT_FALSE(
  ------------------
  |  |  247|  12.4M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 25.9k, False: 6.20M]
  |  |  |  Branch (247:53): [True: 25.9k, False: 6.20M]
  |  |  |  Branch (247:53): [True: 0, False: 6.20M]
  |  |  ------------------
  ------------------
  718|  6.23M|            size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
  719|  25.9k|      return WriteStringMaybeAliasedOutline(num, s, ptr);
  720|  25.9k|    }
  721|  6.20M|    ptr = UnsafeVarint((num << 3) | 2, ptr);
  722|  6.20M|    *ptr++ = static_cast<uint8>(size);
  723|  6.20M|    std::memcpy(ptr, s.data(), size);
  724|  6.20M|    return ptr + size;
  725|  6.23M|  }
_ZN6google8protobuf2io19EpsCopyOutputStream22WriteBytesMaybeAliasedEjRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPh:
  726|      9|  uint8* WriteBytesMaybeAliased(uint32 num, const std::string& s, uint8* ptr) {
  727|      9|    return WriteStringMaybeAliased(num, s, ptr);
  728|      9|  }
_ZN6google8protobuf2io19EpsCopyOutputStream7TagSizeEj:
  849|  6.21M|  static constexpr int TagSize(uint32 tag) {
  850|  6.21M|    return (tag < (1 << 7))
  ------------------
  |  Branch (850:12): [True: 6.21M, False: 50]
  ------------------
  851|  6.21M|               ? 1
  852|  6.21M|               : (tag < (1 << 14))
  ------------------
  |  Branch (852:18): [True: 50, False: 0]
  ------------------
  853|     50|                     ? 2
  854|     50|                     : (tag < (1 << 21)) ? 3 : (tag < (1 << 28)) ? 4 : 5;
  ------------------
  |  Branch (854:24): [True: 0, False: 0]
  |  Branch (854:48): [True: 0, False: 0]
  ------------------
  855|  6.21M|  }
_ZN6google8protobuf2io19EpsCopyOutputStream8WriteTagEjjPh:
  857|  25.9k|  PROTOBUF_ALWAYS_INLINE uint8* WriteTag(uint32 num, uint32 wt, uint8* ptr) {
  858|  25.9k|    GOOGLE_DCHECK(ptr < end_);  // NOLINT
  ------------------
  |  |  181|  25.9k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 25.9k]
  |  |  ------------------
  ------------------
  859|  25.9k|    return UnsafeVarint((num << 3) | wt, ptr);
  860|  25.9k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream16WriteLengthDelimEijPh:
  863|  25.9k|                                                 uint8* ptr) {
  864|  25.9k|    ptr = WriteTag(num, 2, ptr);
  865|  25.9k|    return UnsafeWriteSize(size, ptr);
  866|  25.9k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream15UnsafeWriteSizeEjPh:
  924|  25.9k|                                                       uint8* ptr) {
  925|  52.3k|    while (PROTOBUF_PREDICT_FALSE(value >= 0x80)) {
  ------------------
  |  |  247|  52.3k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 26.4k, False: 25.9k]
  |  |  ------------------
  ------------------
  926|  26.4k|      *ptr = static_cast<uint8>(value | 0x80);
  927|  26.4k|      value >>= 7;
  928|  26.4k|      ++ptr;
  929|  26.4k|    }
  930|  25.9k|    *ptr++ = static_cast<uint8>(value);
  931|  25.9k|    return ptr;
  932|  25.9k|  }
_ZN6google8protobuf2io17CodedOutputStream35IsDefaultSerializationDeterministicEv:
 1234|  6.09k|  static bool IsDefaultSerializationDeterministic() {
 1235|  6.09k|    return default_serialization_deterministic_.load(
 1236|  6.09k|               std::memory_order_relaxed) != 0;
 1237|  6.09k|  }
_ZN6google8protobuf2io17CodedOutputStream20WriteVarint32ToArrayEjPh:
 1589|  24.9M|                                                      uint8* target) {
 1590|  24.9M|  return EpsCopyOutputStream::UnsafeVarint(value, target);
 1591|  24.9M|}
_ZN6google8protobuf2io17CodedOutputStream20WriteVarint64ToArrayEmPh:
 1594|  12.1k|                                                      uint8* target) {
 1595|  12.1k|  return EpsCopyOutputStream::UnsafeVarint(value, target);
 1596|  12.1k|}
_ZN6google8protobuf2io17CodedOutputStream32WriteVarint32SignExtendedToArrayEiPh:
 1603|  12.1k|    int32 value, uint8* target) {
 1604|  12.1k|  return WriteVarint64ToArray(static_cast<uint64>(value), target);
 1605|  12.1k|}
_ZN6google8protobuf2io17CodedOutputStream26WriteLittleEndian32ToArrayEjPh:
 1608|  39.6k|                                                            uint8* target) {
 1609|  39.6k|#if defined(PROTOBUF_LITTLE_ENDIAN)
 1610|  39.6k|  memcpy(target, &value, sizeof(value));
 1611|       |#else
 1612|       |  target[0] = static_cast<uint8>(value);
 1613|       |  target[1] = static_cast<uint8>(value >> 8);
 1614|       |  target[2] = static_cast<uint8>(value >> 16);
 1615|       |  target[3] = static_cast<uint8>(value >> 24);
 1616|       |#endif
 1617|  39.6k|  return target + sizeof(value);
 1618|  39.6k|}
_ZN6google8protobuf2io17CodedOutputStream26WriteLittleEndian64ToArrayEmPh:
 1621|  10.2k|                                                            uint8* target) {
 1622|  10.2k|#if defined(PROTOBUF_LITTLE_ENDIAN)
 1623|  10.2k|  memcpy(target, &value, sizeof(value));
 1624|       |#else
 1625|       |  uint32 part0 = static_cast<uint32>(value);
 1626|       |  uint32 part1 = static_cast<uint32>(value >> 32);
 1627|       |
 1628|       |  target[0] = static_cast<uint8>(part0);
 1629|       |  target[1] = static_cast<uint8>(part0 >> 8);
 1630|       |  target[2] = static_cast<uint8>(part0 >> 16);
 1631|       |  target[3] = static_cast<uint8>(part0 >> 24);
 1632|       |  target[4] = static_cast<uint8>(part1);
 1633|       |  target[5] = static_cast<uint8>(part1 >> 8);
 1634|       |  target[6] = static_cast<uint8>(part1 >> 16);
 1635|       |  target[7] = static_cast<uint8>(part1 >> 24);
 1636|       |#endif
 1637|  10.2k|  return target + sizeof(value);
 1638|  10.2k|}
_ZN6google8protobuf2io17CodedOutputStream15WriteTagToArrayEjPh:
 1652|  12.4M|inline uint8* CodedOutputStream::WriteTagToArray(uint32 value, uint8* target) {
 1653|  12.4M|  return WriteVarint32ToArray(value, target);
 1654|  12.4M|}
_ZN6google8protobuf2io17CodedOutputStream12VarintSize32Ej:
 1656|  18.6M|inline size_t CodedOutputStream::VarintSize32(uint32 value) {
 1657|       |  // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
 1658|       |  // Use an explicit multiplication to implement the divide of
 1659|       |  // a number in the 1..31 range.
 1660|       |  // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
 1661|       |  // undefined.
 1662|  18.6M|  uint32 log2value = Bits::Log2FloorNonZero(value | 0x1);
 1663|  18.6M|  return static_cast<size_t>((log2value * 9 + 73) / 64);
 1664|  18.6M|}
_ZN6google8protobuf2io17CodedOutputStream12VarintSize64Em:
 1666|      2|inline size_t CodedOutputStream::VarintSize64(uint64 value) {
 1667|       |  // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
 1668|       |  // Use an explicit multiplication to implement the divide of
 1669|       |  // a number in the 1..63 range.
 1670|       |  // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
 1671|       |  // undefined.
 1672|      2|  uint32 log2value = Bits::Log2FloorNonZero64(value | 0x1);
 1673|      2|  return static_cast<size_t>((log2value * 9 + 73) / 64);
 1674|      2|}
_ZN6google8protobuf2io17CodedOutputStream24VarintSize32SignExtendedEi:
 1676|  12.1k|inline size_t CodedOutputStream::VarintSize32SignExtended(int32 value) {
 1677|  12.1k|  if (value < 0) {
  ------------------
  |  Branch (1677:7): [True: 10, False: 12.1k]
  ------------------
 1678|     10|    return 10;  // TODO(kenton):  Make this a symbolic constant.
 1679|  12.1k|  } else {
 1680|  12.1k|    return VarintSize32(static_cast<uint32>(value));
 1681|  12.1k|  }
 1682|  12.1k|}
_ZN6google8protobuf2io19EpsCopyOutputStream12UnsafeVarintIjEEPhT_S4_:
  900|  31.1M|  PROTOBUF_ALWAYS_INLINE static uint8* UnsafeVarint(T value, uint8* ptr) {
  901|  31.1M|    static_assert(std::is_unsigned<T>::value,
  902|  31.1M|                  "Varint serialization must be unsigned");
  903|  31.1M|    if (value < 0x80) {
  ------------------
  |  Branch (903:9): [True: 24.9M, False: 6.16M]
  ------------------
  904|  24.9M|      ptr[0] = static_cast<uint8>(value);
  905|  24.9M|      return ptr + 1;
  906|  24.9M|    }
  907|  6.16M|    ptr[0] = static_cast<uint8>(value | 0x80);
  908|  6.16M|    value >>= 7;
  909|  6.16M|    if (value < 0x80) {
  ------------------
  |  Branch (909:9): [True: 2.32M, False: 3.83M]
  ------------------
  910|  2.32M|      ptr[1] = static_cast<uint8>(value);
  911|  2.32M|      return ptr + 2;
  912|  2.32M|    }
  913|  3.83M|    ptr++;
  914|  3.83M|    do {
  915|  3.83M|      *ptr = static_cast<uint8>(value | 0x80);
  916|  3.83M|      value >>= 7;
  917|  3.83M|      ++ptr;
  918|  3.83M|    } while (PROTOBUF_PREDICT_FALSE(value >= 0x80));
  ------------------
  |  |  247|  3.83M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 2, False: 3.83M]
  |  |  ------------------
  ------------------
  919|  3.83M|    *ptr++ = static_cast<uint8>(value);
  920|  3.83M|    return ptr;
  921|  6.16M|  }
_ZN6google8protobuf2io19EpsCopyOutputStream12UnsafeVarintImEEPhT_S4_:
  900|  12.1k|  PROTOBUF_ALWAYS_INLINE static uint8* UnsafeVarint(T value, uint8* ptr) {
  901|  12.1k|    static_assert(std::is_unsigned<T>::value,
  902|  12.1k|                  "Varint serialization must be unsigned");
  903|  12.1k|    if (value < 0x80) {
  ------------------
  |  Branch (903:9): [True: 12.1k, False: 67]
  ------------------
  904|  12.1k|      ptr[0] = static_cast<uint8>(value);
  905|  12.1k|      return ptr + 1;
  906|  12.1k|    }
  907|     67|    ptr[0] = static_cast<uint8>(value | 0x80);
  908|     67|    value >>= 7;
  909|     67|    if (value < 0x80) {
  ------------------
  |  Branch (909:9): [True: 10, False: 57]
  ------------------
  910|     10|      ptr[1] = static_cast<uint8>(value);
  911|     10|      return ptr + 2;
  912|     10|    }
  913|     57|    ptr++;
  914|    154|    do {
  915|    154|      *ptr = static_cast<uint8>(value | 0x80);
  916|    154|      value >>= 7;
  917|    154|      ++ptr;
  918|    154|    } while (PROTOBUF_PREDICT_FALSE(value >= 0x80));
  ------------------
  |  |  247|    154|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 97, False: 57]
  |  |  ------------------
  ------------------
  919|     57|    *ptr++ = static_cast<uint8>(value);
  920|     57|    return ptr;
  921|     67|  }
_ZN6google8protobuf2io19EpsCopyOutputStream11WriteStringINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEPhjRKT_SB_:
  732|    655|                                            uint8* ptr) {
  733|    655|    std::ptrdiff_t size = s.size();
  734|    655|    if (PROTOBUF_PREDICT_FALSE(
  ------------------
  |  |  247|  1.31k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 655]
  |  |  |  Branch (247:53): [True: 0, False: 655]
  |  |  |  Branch (247:53): [True: 0, False: 655]
  |  |  ------------------
  ------------------
  735|    655|            size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
  736|      0|      return WriteStringOutline(num, s, ptr);
  737|      0|    }
  738|    655|    ptr = UnsafeVarint((num << 3) | 2, ptr);
  739|    655|    *ptr++ = static_cast<uint8>(size);
  740|    655|    std::memcpy(ptr, s.data(), size);
  741|    655|    return ptr + size;
  742|    655|  }

_ZN6google8protobuf2io19mutable_string_dataEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  387|  6.09k|inline char* mutable_string_data(std::string* s) {
  388|       |  // This should be simpler & faster than string_as_array() because the latter
  389|       |  // is guaranteed to return NULL when *s is empty, so it has to check for that.
  390|  6.09k|  return &(*s)[0];
  391|  6.09k|}

_ZNK6google8protobuf11MessageLite8GetArenaEv:
  230|   112M|  Arena* GetArena() const { return _internal_metadata_.arena(); }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN13sentencepiece14NormalizerSpecEEEPT_PNS0_5ArenaE:
  479|  1.27k|  static T* CreateMaybeMessage(Arena* arena) {
  480|  1.27k|    return Arena::CreateMaybeMessage<T>(arena);
  481|  1.27k|  }
_ZN6google8protobuf11MessageLiteC2EPNS0_5ArenaE:
  483|  13.0M|  inline explicit MessageLite(Arena* arena) : _internal_metadata_(arena) {}
_ZNK6google8protobuf11MessageLite23IsInitializedWithErrorsEv:
  508|  3.17k|  bool IsInitializedWithErrors() const {
  509|  3.17k|    if (IsInitialized()) return true;
  ------------------
  |  Branch (509:9): [True: 3.17k, False: 0]
  ------------------
  510|      0|    LogInitializationErrorMessage();
  511|      0|    return false;
  512|  3.17k|  }
_ZN6google8protobuf8internal12ToCachedSizeEm:
   97|  3.13M|inline int ToCachedSize(size_t size) { return static_cast<int>(size); }
_ZN6google8protobuf8internal11FromIntSizeEi:
  104|  2.22k|inline size_t FromIntSize(int size) {
  105|       |  // Convert to unsigned before widening so sign extension is not necessary.
  106|  2.22k|  return static_cast<unsigned int>(size);
  107|  2.22k|}
_ZN6google8protobuf8internal27GetEmptyStringAlreadyInitedEv:
  173|   165M|PROTOBUF_EXPORT constexpr const std::string& GetEmptyStringAlreadyInited() {
  174|   165M|  return fixed_address_empty_string.value;
  175|   165M|}
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN13sentencepiece11TrainerSpecEEEPT_PNS0_5ArenaE:
  479|  2.89k|  static T* CreateMaybeMessage(Arena* arena) {
  480|  2.89k|    return Arena::CreateMaybeMessage<T>(arena);
  481|  2.89k|  }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN13sentencepiece12SelfTestDataEEEPT_PNS0_5ArenaE:
  479|    625|  static T* CreateMaybeMessage(Arena* arena) {
  480|    625|    return Arena::CreateMaybeMessage<T>(arena);
  481|    625|  }
_ZN6google8protobuf11MessageLiteD2Ev:
  210|  13.0M|  virtual ~MessageLite() = default;
_ZN6google8protobuf11MessageLite9ParseFromILNS1_10ParseFlagsE1ENS0_11StringPieceEEEbRKT0_:
  576|  7.70k|bool MessageLite::ParseFrom(const T& input) {
  577|  7.70k|  if (flags & kParse) Clear();
  ------------------
  |  Branch (577:7): [True: 7.70k, Folded]
  ------------------
  578|  7.70k|  constexpr bool alias = (flags & kMergeWithAliasing) != 0;
  579|  7.70k|  return internal::MergeFromImpl<alias>(input, this, flags);
  580|  7.70k|}

_ZNK6google8protobuf8internal16InternalMetadata5arenaEv:
   72|   112M|  PROTOBUF_ALWAYS_INLINE Arena* arena() const {
   73|   112M|    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
  ------------------
  |  |  247|   112M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 42.5k, False: 112M]
  |  |  ------------------
  ------------------
   74|  42.5k|      return PtrValue<ContainerBase>()->arena;
   75|   112M|    } else {
   76|   112M|      return PtrValue<Arena>();
   77|   112M|    }
   78|   112M|  }
_ZNK6google8protobuf8internal16InternalMetadata19have_unknown_fieldsEv:
   80|   132M|  PROTOBUF_ALWAYS_INLINE bool have_unknown_fields() const {
   81|   132M|    return PtrTag() == kTagContainer;
   82|   132M|  }
_ZNK6google8protobuf8internal16InternalMetadata6PtrTagEv:
  146|   132M|  PROTOBUF_ALWAYS_INLINE int PtrTag() const {
  147|   132M|    return reinterpret_cast<intptr_t>(ptr_) & kPtrTagMask;
  148|   132M|  }
_ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS2_13ContainerBaseEEEPT_v:
  151|  42.5k|  U* PtrValue() const {
  152|  42.5k|    return reinterpret_cast<U*>(reinterpret_cast<intptr_t>(ptr_) &
  153|  42.5k|                                kPtrValueMask);
  154|  42.5k|  }
_ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS0_5ArenaEEEPT_v:
  151|   112M|  U* PtrValue() const {
  152|   112M|    return reinterpret_cast<U*>(reinterpret_cast<intptr_t>(ptr_) &
  153|   112M|                                kPtrValueMask);
  154|   112M|  }
_ZN6google8protobuf8internal16InternalMetadataC2EPNS0_5ArenaE:
   62|  13.0M|  explicit InternalMetadata(Arena* arena) : ptr_(arena) {}
_ZN6google8protobuf8internal16InternalMetadata22mutable_unknown_fieldsINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEPT_v:
   97|   176k|  PROTOBUF_ALWAYS_INLINE T* mutable_unknown_fields() {
   98|   176k|    if (PROTOBUF_PREDICT_TRUE(have_unknown_fields())) {
  ------------------
  |  |  236|   176k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 167k, False: 9.10k]
  |  |  ------------------
  ------------------
   99|   167k|      return &PtrValue<Container<T>>()->unknown_fields;
  100|   167k|    } else {
  101|  9.10k|      return mutable_unknown_fields_slow<T>();
  102|  9.10k|    }
  103|   176k|  }
_ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS2_9ContainerINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEEEPT_v:
  151|   182k|  U* PtrValue() const {
  152|   182k|    return reinterpret_cast<U*>(reinterpret_cast<intptr_t>(ptr_) &
  153|   182k|                                kPtrValueMask);
  154|   182k|  }
_ZN6google8protobuf8internal16InternalMetadata27mutable_unknown_fields_slowINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEPT_v:
  167|  9.10k|  PROTOBUF_NOINLINE T* mutable_unknown_fields_slow() {
  168|  9.10k|    Arena* my_arena = arena();
  169|  9.10k|    Container<T>* container = Arena::Create<Container<T>>(my_arena);
  170|       |    // Two-step assignment works around a bug in clang's static analyzer:
  171|       |    // https://bugs.llvm.org/show_bug.cgi?id=34198.
  172|  9.10k|    ptr_ = container;
  173|  9.10k|    ptr_ = reinterpret_cast<void*>(reinterpret_cast<intptr_t>(ptr_) |
  174|  9.10k|                                   kTagContainer);
  175|  9.10k|    container->arena = my_arena;
  176|  9.10k|    return &(container->unknown_fields);
  177|  9.10k|  }
_ZNK6google8protobuf8internal16InternalMetadata14unknown_fieldsINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEERKT_PFSD_vE:
   88|  6.11k|      const T& (*default_instance)()) const {
   89|  6.11k|    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
  ------------------
  |  |  247|  6.11k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 6.11k, False: 0]
  |  |  ------------------
  ------------------
   90|  6.11k|      return PtrValue<Container<T>>()->unknown_fields;
   91|  6.11k|    } else {
   92|      0|      return default_instance();
   93|      0|    }
   94|  6.11k|  }
_ZN6google8protobuf8internal16InternalMetadata6DeleteINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvv:
   65|  13.0M|  void Delete() {
   66|       |    // Note that Delete<> should be called not more than once.
   67|  13.0M|    if (have_unknown_fields() && arena() == NULL) {
  ------------------
  |  Branch (67:9): [True: 9.10k, False: 13.0M]
  |  Branch (67:34): [True: 9.10k, False: 0]
  ------------------
   68|  9.10k|      delete PtrValue<Container<T>>();
   69|  9.10k|    }
   70|  13.0M|  }
_ZN6google8protobuf8internal16InternalMetadata5ClearINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvv:
  126|  22.0k|  PROTOBUF_ALWAYS_INLINE void Clear() {
  127|  22.0k|    if (have_unknown_fields()) {
  ------------------
  |  Branch (127:9): [True: 0, False: 22.0k]
  ------------------
  128|      0|      DoClear<T>();
  129|      0|    }
  130|  22.0k|  }

_ZN6google8protobuf8internal18EpsCopyInputStreamC2Eb:
  113|  7.70k|      : aliasing_(enable_aliasing ? kOnPatch : kNoAliasing) {}
  ------------------
  |  Branch (113:19): [True: 0, False: 7.70k]
  ------------------
_ZN6google8protobuf8internal18EpsCopyInputStream9PushLimitEPKci:
  127|  1.49M|  PROTOBUF_MUST_USE_RESULT int PushLimit(const char* ptr, int limit) {
  128|  1.49M|    GOOGLE_DCHECK(limit >= 0 && limit <= INT_MAX - kSlopBytes);
  ------------------
  |  |  181|  1.49M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1.49M]
  |  |  ------------------
  ------------------
  129|       |    // This add is safe due to the invariant above, because
  130|       |    // ptr - buffer_end_ <= kSlopBytes.
  131|  1.49M|    limit += static_cast<int>(ptr - buffer_end_);
  132|  1.49M|    limit_end_ = buffer_end_ + (std::min)(0, limit);
  133|  1.49M|    auto old_limit = limit_;
  134|  1.49M|    limit_ = limit;
  135|  1.49M|    return old_limit - limit;
  136|  1.49M|  }
_ZN6google8protobuf8internal18EpsCopyInputStream8PopLimitEi:
  138|  1.49M|  PROTOBUF_MUST_USE_RESULT bool PopLimit(int delta) {
  139|  1.49M|    if (PROTOBUF_PREDICT_FALSE(!EndedAtLimit())) return false;
  ------------------
  |  |  247|  1.49M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 915, False: 1.49M]
  |  |  ------------------
  ------------------
  140|  1.49M|    limit_ = limit_ + delta;
  141|       |    // TODO(gerbens) We could remove this line and hoist the code to
  142|       |    // DoneFallback. Study the perf/bin-size effects.
  143|  1.49M|    limit_end_ = buffer_end_ + (std::min)(0, limit_);
  144|  1.49M|    return true;
  145|  1.49M|  }
_ZN6google8protobuf8internal18EpsCopyInputStream10ReadStringEPKciPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  154|   111k|                                                  std::string* s) {
  155|   111k|    if (size <= buffer_end_ + kSlopBytes - ptr) {
  ------------------
  |  Branch (155:9): [True: 111k, False: 336]
  ------------------
  156|   111k|      s->assign(ptr, size);
  157|   111k|      return ptr + size;
  158|   111k|    }
  159|    336|    return ReadStringFallback(ptr, size, s);
  160|   111k|  }
_ZN6google8protobuf8internal18EpsCopyInputStream12AppendStringEPKciPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  162|  3.69k|                                                    std::string* s) {
  163|  3.69k|    if (size <= buffer_end_ + kSlopBytes - ptr) {
  ------------------
  |  Branch (163:9): [True: 3.38k, False: 307]
  ------------------
  164|  3.38k|      s->append(ptr, size);
  165|  3.38k|      return ptr + size;
  166|  3.38k|    }
  167|    307|    return AppendStringFallback(ptr, size, s);
  168|  3.69k|  }
_ZN6google8protobuf8internal18EpsCopyInputStream15ConsumeEndGroupEj:
  184|  3.51k|  bool ConsumeEndGroup(uint32 start_tag) {
  185|  3.51k|    bool res = last_tag_minus_1_ == start_tag;
  186|  3.51k|    last_tag_minus_1_ = 0;
  187|  3.51k|    return res;
  188|  3.51k|  }
_ZNK6google8protobuf8internal18EpsCopyInputStream12EndedAtLimitEv:
  189|  1.49M|  bool EndedAtLimit() const { return last_tag_minus_1_ == 0; }
_ZN6google8protobuf8internal18EpsCopyInputStream10SetLastTagEj:
  191|  1.11k|  void SetLastTag(uint32 tag) { last_tag_minus_1_ = tag - 1; }
_ZN6google8protobuf8internal18EpsCopyInputStream14SetEndOfStreamEv:
  192|    367|  void SetEndOfStream() { last_tag_minus_1_ = 1; }
_ZN6google8protobuf8internal18EpsCopyInputStream13DataAvailableEPKc:
  202|  1.50M|  bool DataAvailable(const char* ptr) { return ptr < limit_end_; }
_ZN6google8protobuf8internal18EpsCopyInputStream13DoneWithCheckEPPKci:
  208|  1.95M|  bool DoneWithCheck(const char** ptr, int d) {
  209|  1.95M|    GOOGLE_DCHECK(*ptr);
  ------------------
  |  |  181|  1.95M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1.95M]
  |  |  ------------------
  ------------------
  210|  1.95M|    if (PROTOBUF_PREDICT_TRUE(*ptr < limit_end_)) return false;
  ------------------
  |  |  236|  1.95M|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 450k, False: 1.50M]
  |  |  ------------------
  ------------------
  211|  1.50M|    int overrun = *ptr - buffer_end_;
  212|  1.50M|    GOOGLE_DCHECK_LE(overrun, kSlopBytes);  // Guaranteed by parse loop.
  ------------------
  |  |  186|  1.50M|#define GOOGLE_DCHECK_LE(A, B) GOOGLE_DCHECK((A) <= (B))
  |  |  ------------------
  |  |  |  |  181|  1.50M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 1.50M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  213|  1.50M|    if (overrun ==
  ------------------
  |  Branch (213:9): [True: 1.49M, False: 6.43k]
  ------------------
  214|  1.50M|        limit_) {  //  No need to flip buffers if we ended on a limit.
  215|       |      // If we actually overrun the buffer and next_chunk_ is null. It means
  216|       |      // the stream ended and we passed the stream end.
  217|  1.49M|      if (overrun > 0 && next_chunk_ == nullptr) *ptr = nullptr;
  ------------------
  |  Branch (217:11): [True: 332, False: 1.49M]
  |  Branch (217:26): [True: 38, False: 294]
  ------------------
  218|  1.49M|      return true;
  219|  1.49M|    }
  220|  6.43k|    auto res = DoneFallback(overrun, d);
  221|  6.43k|    *ptr = res.first;
  222|  6.43k|    return res.second;
  223|  1.50M|  }
_ZN6google8protobuf8internal18EpsCopyInputStream8InitFromENS0_11StringPieceE:
  225|  7.70k|  const char* InitFrom(StringPiece flat) {
  226|  7.70k|    overall_limit_ = 0;
  227|  7.70k|    if (flat.size() > kSlopBytes) {
  ------------------
  |  Branch (227:9): [True: 5.35k, False: 2.34k]
  ------------------
  228|  5.35k|      limit_ = kSlopBytes;
  229|  5.35k|      limit_end_ = buffer_end_ = flat.data() + flat.size() - kSlopBytes;
  230|  5.35k|      next_chunk_ = buffer_;
  231|  5.35k|      if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
  ------------------
  |  Branch (231:11): [True: 0, False: 5.35k]
  ------------------
  232|  5.35k|      return flat.data();
  233|  5.35k|    } else {
  234|  2.34k|      std::memcpy(buffer_, flat.data(), flat.size());
  235|  2.34k|      limit_ = 0;
  236|  2.34k|      limit_end_ = buffer_end_ = buffer_ + flat.size();
  237|  2.34k|      next_chunk_ = nullptr;
  238|  2.34k|      if (aliasing_ == kOnPatch) {
  ------------------
  |  Branch (238:11): [True: 0, False: 2.34k]
  ------------------
  239|      0|        aliasing_ = reinterpret_cast<std::uintptr_t>(flat.data()) -
  240|      0|                    reinterpret_cast<std::uintptr_t>(buffer_);
  241|      0|      }
  242|  2.34k|      return buffer_;
  243|  2.34k|    }
  244|  7.70k|  }
_ZN6google8protobuf8internal12ParseContext4DoneEPPKc:
  390|  1.95M|  bool Done(const char** ptr) { return DoneWithCheck(ptr, group_depth_); }
_ZN6google8protobuf8internal12EndianHelperILi4EE4LoadEPKv:
  461|  67.9k|  static uint32 Load(const void* p) {
  462|  67.9k|    uint32 tmp;
  463|  67.9k|    std::memcpy(&tmp, p, 4);
  464|       |#ifndef PROTOBUF_LITTLE_ENDIAN
  465|       |    tmp = bswap_32(tmp);
  466|       |#endif
  467|  67.9k|    return tmp;
  468|  67.9k|  }
_ZN6google8protobuf8internal12EndianHelperILi8EE4LoadEPKv:
  473|  10.2k|  static uint64 Load(const void* p) {
  474|  10.2k|    uint64 tmp;
  475|  10.2k|    std::memcpy(&tmp, p, 8);
  476|       |#ifndef PROTOBUF_LITTLE_ENDIAN
  477|       |    tmp = bswap_64(tmp);
  478|       |#endif
  479|  10.2k|    return tmp;
  480|  10.2k|  }
_ZN6google8protobuf8internal15VarintParseSlowEPKcjPm:
  502|  12.0k|inline const char* VarintParseSlow(const char* p, uint32 res, uint64* out) {
  503|  12.0k|  auto tmp = VarintParseSlow64(p, res);
  504|  12.0k|  *out = tmp.second;
  505|  12.0k|  return tmp.first;
  506|  12.0k|}
_ZN6google8protobuf8internal7ReadTagEPKcPjj:
  532|   455k|inline const char* ReadTag(const char* p, uint32* out, uint32 /*max_tag*/ = 0) {
  533|   455k|  uint32 res = static_cast<uint8>(p[0]);
  534|   455k|  if (res < 128) {
  ------------------
  |  Branch (534:7): [True: 433k, False: 22.1k]
  ------------------
  535|   433k|    *out = res;
  536|   433k|    return p + 1;
  537|   433k|  }
  538|  22.1k|  uint32 second = static_cast<uint8>(p[1]);
  539|  22.1k|  res += (second - 1) << 7;
  540|  22.1k|  if (second < 128) {
  ------------------
  |  Branch (540:7): [True: 14.6k, False: 7.47k]
  ------------------
  541|  14.6k|    *out = res;
  542|  14.6k|    return p + 2;
  543|  14.6k|  }
  544|  7.47k|  auto tmp = ReadTagFallback(p, res);
  545|  7.47k|  *out = tmp.second;
  546|  7.47k|  return tmp.first;
  547|  22.1k|}
_ZN6google8protobuf8internal8ReadSizeEPPKc:
  599|  1.61M|inline uint32 ReadSize(const char** pp) {
  600|  1.61M|  auto p = *pp;
  601|  1.61M|  uint32 res = static_cast<uint8>(p[0]);
  602|  1.61M|  if (res < 128) {
  ------------------
  |  Branch (602:7): [True: 1.60M, False: 2.50k]
  ------------------
  603|  1.60M|    *pp = p + 1;
  604|  1.60M|    return res;
  605|  1.60M|  }
  606|  2.50k|  auto x = ReadSizeFallback(p, res);
  607|  2.50k|  *pp = x.first;
  608|  2.50k|  return x.second;
  609|  1.61M|}
_ZN6google8protobuf8internal12ReadVarint64EPPKc:
  616|  80.7k|inline uint64 ReadVarint64(const char** p) {
  617|  80.7k|  uint64 tmp;
  618|  80.7k|  *p = VarintParse(*p, &tmp);
  619|  80.7k|  return tmp;
  620|  80.7k|}
_ZN6google8protobuf8internal11VarintParseImEEPKcS4_PT_:
  509|   246k|PROTOBUF_MUST_USE_RESULT const char* VarintParse(const char* p, T* out) {
  510|   246k|  auto ptr = reinterpret_cast<const uint8*>(p);
  511|   246k|  uint32 res = ptr[0];
  512|   246k|  if (!(res & 0x80)) {
  ------------------
  |  Branch (512:7): [True: 229k, False: 17.6k]
  ------------------
  513|   229k|    *out = res;
  514|   229k|    return p + 1;
  515|   229k|  }
  516|  17.6k|  uint32 byte = ptr[1];
  517|  17.6k|  res += (byte - 1) << 7;
  518|  17.6k|  if (!(byte & 0x80)) {
  ------------------
  |  Branch (518:7): [True: 5.67k, False: 12.0k]
  ------------------
  519|  5.67k|    *out = res;
  520|  5.67k|    return p + 2;
  521|  5.67k|  }
  522|  12.0k|  return VarintParseSlow(p, res, out);
  523|  17.6k|}
_ZN6google8protobuf8internal13UnalignedLoadIfEET_PKc:
  484|  55.4k|T UnalignedLoad(const char* p) {
  485|  55.4k|  auto tmp = EndianHelper<sizeof(T)>::Load(p);
  486|  55.4k|  T res;
  487|  55.4k|  memcpy(&res, &tmp, sizeof(T));
  488|  55.4k|  return res;
  489|  55.4k|}
_ZN6google8protobuf8internal13UnalignedLoadImEET_PKc:
  484|  10.2k|T UnalignedLoad(const char* p) {
  485|  10.2k|  auto tmp = EndianHelper<sizeof(T)>::Load(p);
  486|  10.2k|  T res;
  487|  10.2k|  memcpy(&res, &tmp, sizeof(T));
  488|  10.2k|  return res;
  489|  10.2k|}
_ZN6google8protobuf8internal13UnalignedLoadIjEET_PKc:
  484|  12.5k|T UnalignedLoad(const char* p) {
  485|  12.5k|  auto tmp = EndianHelper<sizeof(T)>::Load(p);
  486|  12.5k|  T res;
  487|  12.5k|  memcpy(&res, &tmp, sizeof(T));
  488|  12.5k|  return res;
  489|  12.5k|}
_ZN6google8protobuf8internal12ParseContextC2IJRNS0_11StringPieceEEEEibPPKcDpOT_:
  384|  7.70k|      : EpsCopyInputStream(aliasing), depth_(depth) {
  385|  7.70k|    *start = InitFrom(std::forward<T>(args)...);
  386|  7.70k|  }
parse_context.cc:_ZN6google8protobuf8internal18EpsCopyInputStream10AppendSizeIZNS2_18ReadStringFallbackEPKciPNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE3$_0EES5_S5_iRKT_:
  320|    336|  const char* AppendSize(const char* ptr, int size, const A& append) {
  321|    336|    int chunk_size = buffer_end_ + kSlopBytes - ptr;
  322|    378|    do {
  323|    378|      GOOGLE_DCHECK(size > chunk_size);
  ------------------
  |  |  181|    378|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 378]
  |  |  ------------------
  ------------------
  324|    378|      if (next_chunk_ == nullptr) return nullptr;
  ------------------
  |  Branch (324:11): [True: 270, False: 108]
  ------------------
  325|    108|      append(ptr, chunk_size);
  326|    108|      ptr += chunk_size;
  327|    108|      size -= chunk_size;
  328|       |      // TODO(gerbens) Next calls NextBuffer which generates buffers with
  329|       |      // overlap and thus incurs cost of copying the slop regions. This is not
  330|       |      // necessary for reading strings. We should just call Next buffers.
  331|    108|      if (limit_ <= kSlopBytes) return nullptr;
  ------------------
  |  Branch (331:11): [True: 54, False: 54]
  ------------------
  332|     54|      ptr = Next();
  333|     54|      if (ptr == nullptr) return nullptr;  // passed the limit
  ------------------
  |  Branch (333:11): [True: 0, False: 54]
  ------------------
  334|     54|      ptr += kSlopBytes;
  335|     54|      chunk_size = buffer_end_ + kSlopBytes - ptr;
  336|     54|    } while (size > chunk_size);
  ------------------
  |  Branch (336:14): [True: 42, False: 12]
  ------------------
  337|     12|    append(ptr, size);
  338|     12|    return ptr + size;
  339|    336|  }
parse_context.cc:_ZN6google8protobuf8internal18EpsCopyInputStream10AppendSizeIZNS2_20AppendStringFallbackEPKciPNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEE3$_0EES5_S5_iRKT_:
  320|    307|  const char* AppendSize(const char* ptr, int size, const A& append) {
  321|    307|    int chunk_size = buffer_end_ + kSlopBytes - ptr;
  322|    345|    do {
  323|    345|      GOOGLE_DCHECK(size > chunk_size);
  ------------------
  |  |  181|    345|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 345]
  |  |  ------------------
  ------------------
  324|    345|      if (next_chunk_ == nullptr) return nullptr;
  ------------------
  |  Branch (324:11): [True: 263, False: 82]
  ------------------
  325|     82|      append(ptr, chunk_size);
  326|     82|      ptr += chunk_size;
  327|     82|      size -= chunk_size;
  328|       |      // TODO(gerbens) Next calls NextBuffer which generates buffers with
  329|       |      // overlap and thus incurs cost of copying the slop regions. This is not
  330|       |      // necessary for reading strings. We should just call Next buffers.
  331|     82|      if (limit_ <= kSlopBytes) return nullptr;
  ------------------
  |  Branch (331:11): [True: 31, False: 51]
  ------------------
  332|     51|      ptr = Next();
  333|     51|      if (ptr == nullptr) return nullptr;  // passed the limit
  ------------------
  |  Branch (333:11): [True: 0, False: 51]
  ------------------
  334|     51|      ptr += kSlopBytes;
  335|     51|      chunk_size = buffer_end_ + kSlopBytes - ptr;
  336|     51|    } while (size > chunk_size);
  ------------------
  |  Branch (336:14): [True: 38, False: 13]
  ------------------
  337|     13|    append(ptr, size);
  338|     13|    return ptr + size;
  339|    307|  }
_ZN6google8protobuf8internal16WireFormatParserINS1_28UnknownFieldLiteParserHelperEEEPKcRT_S5_PNS1_12ParseContextE:
  776|  3.51k|                                                      ParseContext* ctx) {
  777|  26.6k|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (777:10): [True: 26.4k, False: 269]
  ------------------
  778|  26.4k|    uint32 tag;
  779|  26.4k|    ptr = ReadTag(ptr, &tag);
  780|  26.4k|    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
  ------------------
  |  |  724|  26.4k|  GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
  |  |  ------------------
  |  |  |  |  717|  26.4k|  if (!(predicate)) {                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (717:7): [True: 14, False: 26.4k]
  |  |  |  |  ------------------
  |  |  |  |  718|     14|    /*  ::raise(SIGINT);  */                           \
  |  |  |  |  719|     14|    /*  GOOGLE_LOG(ERROR) << "Parse failure";  */             \
  |  |  |  |  720|     14|    return ret;                                        \
  |  |  |  |  721|     14|  }
  |  |  ------------------
  ------------------
  781|  26.4k|    if (tag == 0 || (tag & 7) == 4) {
  ------------------
  |  Branch (781:9): [True: 37, False: 26.3k]
  |  Branch (781:21): [True: 385, False: 25.9k]
  ------------------
  782|    422|      ctx->SetLastTag(tag);
  783|    422|      return ptr;
  784|    422|    }
  785|  25.9k|    ptr = FieldParser(tag, field_parser, ptr, ctx);
  786|  25.9k|    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr != nullptr);
  ------------------
  |  |  724|  25.9k|  GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
  |  |  ------------------
  |  |  |  |  717|  25.9k|  if (!(predicate)) {                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (717:7): [True: 2.80k, False: 23.1k]
  |  |  |  |  ------------------
  |  |  |  |  718|  2.80k|    /*  ::raise(SIGINT);  */                           \
  |  |  |  |  719|  2.80k|    /*  GOOGLE_LOG(ERROR) << "Parse failure";  */             \
  |  |  |  |  720|  2.80k|    return ret;                                        \
  |  |  |  |  721|  2.80k|  }
  |  |  ------------------
  ------------------
  787|  23.1k|  }
  788|    269|  return ptr;
  789|  3.51k|}
_ZN6google8protobuf8internal11FieldParserINS1_28UnknownFieldLiteParserHelperEEEPKcmRT_S5_PNS1_12ParseContextE:
  729|   196k|                                                 ParseContext* ctx) {
  730|   196k|  uint32 number = tag >> 3;
  731|   196k|  GOOGLE_PROTOBUF_PARSER_ASSERT(number != 0);
  ------------------
  |  |  724|   196k|  GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
  |  |  ------------------
  |  |  |  |  717|   196k|  if (!(predicate)) {                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (717:7): [True: 138, False: 196k]
  |  |  |  |  ------------------
  |  |  |  |  718|    138|    /*  ::raise(SIGINT);  */                           \
  |  |  |  |  719|    138|    /*  GOOGLE_LOG(ERROR) << "Parse failure";  */             \
  |  |  |  |  720|    138|    return ret;                                        \
  |  |  |  |  721|    138|  }
  |  |  ------------------
  ------------------
  732|   196k|  using WireType = internal::WireFormatLite::WireType;
  733|   196k|  switch (tag & 7) {
  734|   166k|    case WireType::WIRETYPE_VARINT: {
  ------------------
  |  Branch (734:5): [True: 166k, False: 30.7k]
  ------------------
  735|   166k|      uint64 value;
  736|   166k|      ptr = VarintParse(ptr, &value);
  737|   166k|      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
  ------------------
  |  |  724|   166k|  GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
  |  |  ------------------
  |  |  |  |  717|   166k|  if (!(predicate)) {                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (717:7): [True: 7, False: 166k]
  |  |  |  |  ------------------
  |  |  |  |  718|      7|    /*  ::raise(SIGINT);  */                           \
  |  |  |  |  719|      7|    /*  GOOGLE_LOG(ERROR) << "Parse failure";  */             \
  |  |  |  |  720|      7|    return ret;                                        \
  |  |  |  |  721|      7|  }
  |  |  ------------------
  ------------------
  738|   166k|      field_parser.AddVarint(number, value);
  739|   166k|      break;
  740|   166k|    }
  741|  10.2k|    case WireType::WIRETYPE_FIXED64: {
  ------------------
  |  Branch (741:5): [True: 10.2k, False: 186k]
  ------------------
  742|  10.2k|      uint64 value = UnalignedLoad<uint64>(ptr);
  743|  10.2k|      ptr += 8;
  744|  10.2k|      field_parser.AddFixed64(number, value);
  745|  10.2k|      break;
  746|   166k|    }
  747|  3.70k|    case WireType::WIRETYPE_LENGTH_DELIMITED: {
  ------------------
  |  Branch (747:5): [True: 3.70k, False: 193k]
  ------------------
  748|  3.70k|      ptr = field_parser.ParseLengthDelimited(number, ptr, ctx);
  749|  3.70k|      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
  ------------------
  |  |  724|  3.70k|  GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
  |  |  ------------------
  |  |  |  |  717|  3.70k|  if (!(predicate)) {                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (717:7): [True: 307, False: 3.40k]
  |  |  |  |  ------------------
  |  |  |  |  718|    307|    /*  ::raise(SIGINT);  */                           \
  |  |  |  |  719|    307|    /*  GOOGLE_LOG(ERROR) << "Parse failure";  */             \
  |  |  |  |  720|    307|    return ret;                                        \
  |  |  |  |  721|    307|  }
  |  |  ------------------
  ------------------
  750|  3.40k|      break;
  751|  3.70k|    }
  752|  3.51k|    case WireType::WIRETYPE_START_GROUP: {
  ------------------
  |  Branch (752:5): [True: 3.51k, False: 193k]
  ------------------
  753|  3.51k|      ptr = field_parser.ParseGroup(number, ptr, ctx);
  754|  3.51k|      GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
  ------------------
  |  |  724|  3.51k|  GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
  |  |  ------------------
  |  |  |  |  717|  3.51k|  if (!(predicate)) {                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (717:7): [True: 3.17k, False: 338]
  |  |  |  |  ------------------
  |  |  |  |  718|  3.17k|    /*  ::raise(SIGINT);  */                           \
  |  |  |  |  719|  3.17k|    /*  GOOGLE_LOG(ERROR) << "Parse failure";  */             \
  |  |  |  |  720|  3.17k|    return ret;                                        \
  |  |  |  |  721|  3.17k|  }
  |  |  ------------------
  ------------------
  755|    338|      break;
  756|  3.51k|    }
  757|      0|    case WireType::WIRETYPE_END_GROUP: {
  ------------------
  |  Branch (757:5): [True: 0, False: 196k]
  ------------------
  758|      0|      GOOGLE_LOG(FATAL) << "Can't happen";
  ------------------
  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  ------------------
  759|      0|      break;
  760|  3.51k|    }
  761|  12.5k|    case WireType::WIRETYPE_FIXED32: {
  ------------------
  |  Branch (761:5): [True: 12.5k, False: 184k]
  ------------------
  762|  12.5k|      uint32 value = UnalignedLoad<uint32>(ptr);
  763|  12.5k|      ptr += 4;
  764|  12.5k|      field_parser.AddFixed32(number, value);
  765|  12.5k|      break;
  766|  3.51k|    }
  767|    709|    default:
  ------------------
  |  Branch (767:5): [True: 709, False: 196k]
  ------------------
  768|    709|      return nullptr;
  769|   196k|  }
  770|   192k|  return ptr;
  771|   196k|}
_ZN6google8protobuf8internal12ParseContext10ParseGroupINS1_28UnknownFieldLiteParserHelperEEEPKcPT_S6_j:
  405|  3.51k|      T* msg, const char* ptr, uint32 tag) {
  406|  3.51k|    if (--depth_ < 0) return nullptr;
  ------------------
  |  Branch (406:9): [True: 4, False: 3.51k]
  ------------------
  407|  3.51k|    group_depth_++;
  408|  3.51k|    ptr = msg->_InternalParse(ptr, this);
  409|  3.51k|    group_depth_--;
  410|  3.51k|    depth_++;
  411|  3.51k|    if (PROTOBUF_PREDICT_FALSE(!ConsumeEndGroup(tag))) return nullptr;
  ------------------
  |  |  247|  3.51k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 3.17k, False: 338]
  |  |  ------------------
  ------------------
  412|    338|    return ptr;
  413|  3.51k|  }
_ZN6google8protobuf8internal9ExpectTagILj10EEEbPKc:
  429|  1.50M|bool ExpectTag(const char* ptr) {
  430|  1.50M|  if (tag < 128) {
  ------------------
  |  Branch (430:7): [True: 1.50M, Folded]
  ------------------
  431|  1.50M|    return *ptr == tag;
  432|  1.50M|  } else {
  433|      0|    static_assert(tag < 128 * 128, "We only expect tags for 1 or 2 bytes");
  434|      0|    char buf[2] = {static_cast<char>(tag | 0x80), static_cast<char>(tag >> 7)};
  435|      0|    return std::memcmp(ptr, buf, 2) == 0;
  436|      0|  }
  437|  1.50M|}
_ZN6google8protobuf8internal9ExpectTagILj42EEEbPKc:
  429|    838|bool ExpectTag(const char* ptr) {
  430|    838|  if (tag < 128) {
  ------------------
  |  Branch (430:7): [True: 838, Folded]
  ------------------
  431|    838|    return *ptr == tag;
  432|    838|  } else {
  433|      0|    static_assert(tag < 128 * 128, "We only expect tags for 1 or 2 bytes");
  434|      0|    char buf[2] = {static_cast<char>(tag | 0x80), static_cast<char>(tag >> 7)};
  435|      0|    return std::memcmp(ptr, buf, 2) == 0;
  436|      0|  }
  437|    838|}
_ZN6google8protobuf8internal9ExpectTagILj242EEEbPKc:
  429|     91|bool ExpectTag(const char* ptr) {
  430|     91|  if (tag < 128) {
  ------------------
  |  Branch (430:7): [Folded, False: 91]
  ------------------
  431|      0|    return *ptr == tag;
  432|     91|  } else {
  433|     91|    static_assert(tag < 128 * 128, "We only expect tags for 1 or 2 bytes");
  434|     91|    char buf[2] = {static_cast<char>(tag | 0x80), static_cast<char>(tag >> 7)};
  435|     91|    return std::memcmp(ptr, buf, 2) == 0;
  436|     91|  }
  437|     91|}
_ZN6google8protobuf8internal9ExpectTagILj250EEEbPKc:
  429|     40|bool ExpectTag(const char* ptr) {
  430|     40|  if (tag < 128) {
  ------------------
  |  Branch (430:7): [Folded, False: 40]
  ------------------
  431|      0|    return *ptr == tag;
  432|     40|  } else {
  433|     40|    static_assert(tag < 128 * 128, "We only expect tags for 1 or 2 bytes");
  434|     40|    char buf[2] = {static_cast<char>(tag | 0x80), static_cast<char>(tag >> 7)};
  435|     40|    return std::memcmp(ptr, buf, 2) == 0;
  436|     40|  }
  437|     40|}
_ZN6google8protobuf8internal12ParseContext12ParseMessageIN13sentencepiece19SelfTestData_SampleEEEPKcPT_S7_:
  642|  1.58k|    T* msg, const char* ptr) {
  643|  1.58k|  int size = ReadSize(&ptr);
  644|  1.58k|  if (!ptr) return nullptr;
  ------------------
  |  Branch (644:7): [True: 3, False: 1.58k]
  ------------------
  645|  1.58k|  auto old = PushLimit(ptr, size);
  646|  1.58k|  if (--depth_ < 0) return nullptr;
  ------------------
  |  Branch (646:7): [True: 0, False: 1.58k]
  ------------------
  647|  1.58k|  ptr = msg->_InternalParse(ptr, this);
  648|  1.58k|  if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) return nullptr;
  ------------------
  |  |  247|  1.58k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 160, False: 1.42k]
  |  |  ------------------
  ------------------
  649|  1.42k|  depth_++;
  650|  1.42k|  if (!PopLimit(old)) return nullptr;
  ------------------
  |  Branch (650:7): [True: 51, False: 1.37k]
  ------------------
  651|  1.37k|  return ptr;
  652|  1.42k|}
_ZN6google8protobuf8internal12ParseContext12ParseMessageIN13sentencepiece24ModelProto_SentencePieceEEEPKcPT_S7_:
  642|  1.48M|    T* msg, const char* ptr) {
  643|  1.48M|  int size = ReadSize(&ptr);
  644|  1.48M|  if (!ptr) return nullptr;
  ------------------
  |  Branch (644:7): [True: 1, False: 1.48M]
  ------------------
  645|  1.48M|  auto old = PushLimit(ptr, size);
  646|  1.48M|  if (--depth_ < 0) return nullptr;
  ------------------
  |  Branch (646:7): [True: 0, False: 1.48M]
  ------------------
  647|  1.48M|  ptr = msg->_InternalParse(ptr, this);
  648|  1.48M|  if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) return nullptr;
  ------------------
  |  |  247|  1.48M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 396, False: 1.48M]
  |  |  ------------------
  ------------------
  649|  1.48M|  depth_++;
  650|  1.48M|  if (!PopLimit(old)) return nullptr;
  ------------------
  |  Branch (650:7): [True: 117, False: 1.48M]
  ------------------
  651|  1.48M|  return ptr;
  652|  1.48M|}
_ZN6google8protobuf8internal12ParseContext12ParseMessageIN13sentencepiece11TrainerSpecEEEPKcPT_S7_:
  642|  3.16k|    T* msg, const char* ptr) {
  643|  3.16k|  int size = ReadSize(&ptr);
  644|  3.16k|  if (!ptr) return nullptr;
  ------------------
  |  Branch (644:7): [True: 1, False: 3.16k]
  ------------------
  645|  3.16k|  auto old = PushLimit(ptr, size);
  646|  3.16k|  if (--depth_ < 0) return nullptr;
  ------------------
  |  Branch (646:7): [True: 0, False: 3.16k]
  ------------------
  647|  3.16k|  ptr = msg->_InternalParse(ptr, this);
  648|  3.16k|  if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) return nullptr;
  ------------------
  |  |  247|  3.16k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 1.51k, False: 1.65k]
  |  |  ------------------
  ------------------
  649|  1.65k|  depth_++;
  650|  1.65k|  if (!PopLimit(old)) return nullptr;
  ------------------
  |  Branch (650:7): [True: 444, False: 1.21k]
  ------------------
  651|  1.21k|  return ptr;
  652|  1.65k|}
_ZN6google8protobuf8internal12ParseContext12ParseMessageIN13sentencepiece14NormalizerSpecEEEPKcPT_S7_:
  642|  1.96k|    T* msg, const char* ptr) {
  643|  1.96k|  int size = ReadSize(&ptr);
  644|  1.96k|  if (!ptr) return nullptr;
  ------------------
  |  Branch (644:7): [True: 3, False: 1.95k]
  ------------------
  645|  1.95k|  auto old = PushLimit(ptr, size);
  646|  1.95k|  if (--depth_ < 0) return nullptr;
  ------------------
  |  Branch (646:7): [True: 0, False: 1.95k]
  ------------------
  647|  1.95k|  ptr = msg->_InternalParse(ptr, this);
  648|  1.95k|  if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) return nullptr;
  ------------------
  |  |  247|  1.95k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 579, False: 1.37k]
  |  |  ------------------
  ------------------
  649|  1.37k|  depth_++;
  650|  1.37k|  if (!PopLimit(old)) return nullptr;
  ------------------
  |  Branch (650:7): [True: 213, False: 1.16k]
  ------------------
  651|  1.16k|  return ptr;
  652|  1.37k|}
_ZN6google8protobuf8internal12ParseContext12ParseMessageIN13sentencepiece12SelfTestDataEEEPKcPT_S7_:
  642|    744|    T* msg, const char* ptr) {
  643|    744|  int size = ReadSize(&ptr);
  644|    744|  if (!ptr) return nullptr;
  ------------------
  |  Branch (644:7): [True: 2, False: 742]
  ------------------
  645|    742|  auto old = PushLimit(ptr, size);
  646|    742|  if (--depth_ < 0) return nullptr;
  ------------------
  |  Branch (646:7): [True: 0, False: 742]
  ------------------
  647|    742|  ptr = msg->_InternalParse(ptr, this);
  648|    742|  if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) return nullptr;
  ------------------
  |  |  247|    742|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 413, False: 329]
  |  |  ------------------
  ------------------
  649|    329|  depth_++;
  650|    329|  if (!PopLimit(old)) return nullptr;
  ------------------
  |  Branch (650:7): [True: 90, False: 239]
  ------------------
  651|    239|  return ptr;
  652|    329|}

_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE3GetEi:
 2172|  6.23M|inline const Element& RepeatedPtrField<Element>::Get(int index) const {
 2173|  6.23M|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 2174|  6.23M|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE11TypeHandlerEEERKNT_4TypeEi:
 1704|  6.23M|    int index) const {
 1705|  6.23M|  GOOGLE_DCHECK_GE(index, 0);
  ------------------
  |  |  188|  6.23M|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|  6.23M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 6.23M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1706|  6.23M|  GOOGLE_DCHECK_LT(index, current_size_);
  ------------------
  |  |  185|  6.23M|#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
  |  |  ------------------
  |  |  |  |  181|  6.23M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 6.23M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1707|  6.23M|  return *cast<TypeHandler>(rep_->elements[index]);
 1708|  6.23M|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE11TypeHandlerEEEPNT_4TypeEPv:
  748|  65.6M|  static inline typename TypeHandler::Type* cast(void* element) {
  749|  65.6M|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  750|  65.6M|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldIN13sentencepiece17SentencePieceTextEE11TypeHandlerEEEPNT_4TypeEPv:
  748|  2.14k|  static inline typename TypeHandler::Type* cast(void* element) {
  749|  2.14k|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  750|  2.14k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE4sizeEv:
 2167|  2.22k|inline int RepeatedPtrField<Element>::size() const {
 2168|  2.22k|  return RepeatedPtrFieldBase::size();
 2169|  2.22k|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv:
 1700|  55.4M|inline int RepeatedPtrFieldBase::size() const { return current_size_; }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE4sizeEv:
 2167|  7.50M|inline int RepeatedPtrField<Element>::size() const {
 2168|  7.50M|  return RepeatedPtrFieldBase::size();
 2169|  7.50M|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEPNT_4TypeEPv:
  748|   165M|  static inline typename TypeHandler::Type* cast(void* element) {
  749|   165M|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  750|   165M|  }
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece17SentencePieceTextEE3AddEv:
 2193|  2.14k|inline Element* RepeatedPtrField<Element>::Add() {
 2194|  2.14k|  return RepeatedPtrFieldBase::Add<TypeHandler>();
 2195|  2.14k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldIN13sentencepiece17SentencePieceTextEE11TypeHandlerEEEPNT_4TypeESB_:
 1741|  2.14k|    typename TypeHandler::Type* prototype) {
 1742|  2.14k|  if (rep_ != NULL && current_size_ < rep_->allocated_size) {
  ------------------
  |  Branch (1742:7): [True: 563, False: 1.58k]
  |  Branch (1742:23): [True: 0, False: 563]
  ------------------
 1743|      0|    return cast<TypeHandler>(rep_->elements[current_size_++]);
 1744|      0|  }
 1745|  2.14k|  if (!rep_ || rep_->allocated_size == total_size_) {
  ------------------
  |  Branch (1745:7): [True: 1.58k, False: 563]
  |  Branch (1745:16): [True: 0, False: 563]
  ------------------
 1746|  1.58k|    Reserve(total_size_ + 1);
 1747|  1.58k|  }
 1748|  2.14k|  ++rep_->allocated_size;
 1749|  2.14k|  typename TypeHandler::Type* result =
 1750|  2.14k|      TypeHandler::NewFromPrototype(prototype, arena_);
 1751|  2.14k|  rep_->elements[current_size_++] = result;
 1752|  2.14k|  return result;
 1753|  2.14k|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece17SentencePieceTextEE16NewFromPrototypeEPKS4_PNS0_5ArenaE:
  836|  2.14k|    const GenericType* /* prototype */, Arena* arena) {
  837|  2.14k|  return New(arena);
  838|  2.14k|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece17SentencePieceTextEE3NewEPNS0_5ArenaE:
  806|  2.14k|  static inline GenericType* New(Arena* arena) {
  807|  2.14k|    return Arena::CreateMaybeMessage<Type>(arena);
  808|  2.14k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE4sizeEv:
 2167|  47.9M|inline int RepeatedPtrField<Element>::size() const {
 2168|  47.9M|  return RepeatedPtrFieldBase::size();
 2169|  47.9M|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE7MutableEi:
 2188|  47.8M|inline Element* RepeatedPtrField<Element>::Mutable(int index) {
 2189|  47.8M|  return RepeatedPtrFieldBase::Mutable<TypeHandler>(index);
 2190|  47.8M|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7MutableINS0_16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE11TypeHandlerEEEPNT_4TypeEi:
 1726|  47.8M|inline typename TypeHandler::Type* RepeatedPtrFieldBase::Mutable(int index) {
 1727|  47.8M|  GOOGLE_DCHECK_GE(index, 0);
  ------------------
  |  |  188|  47.8M|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|  47.8M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 47.8M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1728|  47.8M|  GOOGLE_DCHECK_LT(index, current_size_);
  ------------------
  |  |  185|  47.8M|#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
  |  |  ------------------
  |  |  |  |  181|  47.8M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 47.8M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1729|  47.8M|  return cast<TypeHandler>(rep_->elements[index]);
 1730|  47.8M|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE3AddEv:
 2193|  11.5M|inline Element* RepeatedPtrField<Element>::Add() {
 2194|  11.5M|  return RepeatedPtrFieldBase::Add<TypeHandler>();
 2195|  11.5M|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE11TypeHandlerEEEPNT_4TypeESB_:
 1741|  11.5M|    typename TypeHandler::Type* prototype) {
 1742|  11.5M|  if (rep_ != NULL && current_size_ < rep_->allocated_size) {
  ------------------
  |  Branch (1742:7): [True: 11.5M, False: 9.38k]
  |  Branch (1742:23): [True: 0, False: 11.5M]
  ------------------
 1743|      0|    return cast<TypeHandler>(rep_->elements[current_size_++]);
 1744|      0|  }
 1745|  11.5M|  if (!rep_ || rep_->allocated_size == total_size_) {
  ------------------
  |  Branch (1745:7): [True: 9.38k, False: 11.5M]
  |  Branch (1745:16): [True: 24.9k, False: 11.4M]
  ------------------
 1746|  34.3k|    Reserve(total_size_ + 1);
 1747|  34.3k|  }
 1748|  11.5M|  ++rep_->allocated_size;
 1749|  11.5M|  typename TypeHandler::Type* result =
 1750|  11.5M|      TypeHandler::NewFromPrototype(prototype, arena_);
 1751|  11.5M|  rep_->elements[current_size_++] = result;
 1752|  11.5M|  return result;
 1753|  11.5M|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece31SentencePieceText_SentencePieceEE16NewFromPrototypeEPKS4_PNS0_5ArenaE:
  836|  11.5M|    const GenericType* /* prototype */, Arena* arena) {
  837|  11.5M|  return New(arena);
  838|  11.5M|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece31SentencePieceText_SentencePieceEE3NewEPNS0_5ArenaE:
  806|  11.5M|  static inline GenericType* New(Arena* arena) {
  807|  11.5M|    return Arena::CreateMaybeMessage<Type>(arena);
  808|  11.5M|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece17SentencePieceTextEE4sizeEv:
 2167|  3.16k|inline int RepeatedPtrField<Element>::size() const {
 2168|  3.16k|  return RepeatedPtrFieldBase::size();
 2169|  3.16k|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8raw_dataEv:
 1857|  36.6k|inline void* const* RepeatedPtrFieldBase::raw_data() const {
 1858|  36.6k|  return rep_ ? rep_->elements : NULL;
  ------------------
  |  Branch (1858:10): [True: 30.9k, False: 5.79k]
  ------------------
 1859|  36.6k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN13sentencepiece31SentencePieceText_SentencePieceEEC2EPKPv:
 2432|  20.3k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN13sentencepiece17SentencePieceTextEEC2EPKPv:
 2432|  3.16k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE5beginEv:
 2613|  2.11k|RepeatedPtrField<Element>::begin() const {
 2614|  2.11k|  return iterator(raw_data());
 2615|  2.11k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN13sentencepiece19SelfTestData_SampleEEC2EPKPv:
 2432|  4.22k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece19SelfTestData_SampleEEC2IS4_EERKNS2_IT_EE:
 2438|  4.22k|      : it_(other.it_) {
 2439|       |    // Force a compiler error if the other type is not convertible to ours.
 2440|  4.22k|    if (false) {
  ------------------
  |  Branch (2440:9): [Folded, False: 4.22k]
  ------------------
 2441|      0|      implicit_cast<Element*>(static_cast<OtherElement*>(nullptr));
 2442|      0|    }
 2443|  4.22k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE3endEv:
 2628|  2.11k|RepeatedPtrField<Element>::end() const {
 2629|  2.11k|  return iterator(raw_data() + size());
 2630|  2.11k|}
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece19SelfTestData_SampleEEneERKS6_:
 2463|  2.50k|  bool operator!=(const iterator& x) const { return it_ != x.it_; }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece19SelfTestData_SampleEEppEv:
 2450|    392|  iterator& operator++() {
 2451|    392|    ++it_;
 2452|    392|    return *this;
 2453|    392|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece19SelfTestData_SampleEEdeEv:
 2446|    392|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN13sentencepiece24ModelProto_SentencePieceEEC2EPKPv:
 2432|  8.97k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE5beginEv:
 2613|  10.1k|RepeatedPtrField<Element>::begin() const {
 2614|  10.1k|  return iterator(raw_data());
 2615|  10.1k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece31SentencePieceText_SentencePieceEEC2IS4_EERKNS2_IT_EE:
 2438|  20.3k|      : it_(other.it_) {
 2439|       |    // Force a compiler error if the other type is not convertible to ours.
 2440|  20.3k|    if (false) {
  ------------------
  |  Branch (2440:9): [Folded, False: 20.3k]
  ------------------
 2441|      0|      implicit_cast<Element*>(static_cast<OtherElement*>(nullptr));
 2442|      0|    }
 2443|  20.3k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE3endEv:
 2628|  10.1k|RepeatedPtrField<Element>::end() const {
 2629|  10.1k|  return iterator(raw_data() + size());
 2630|  10.1k|}
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece31SentencePieceText_SentencePieceEEneERKS6_:
 2463|  8.39M|  bool operator!=(const iterator& x) const { return it_ != x.it_; }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece31SentencePieceText_SentencePieceEEppEv:
 2450|  8.38M|  iterator& operator++() {
 2451|  8.38M|    ++it_;
 2452|  8.38M|    return *this;
 2453|  8.38M|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece31SentencePieceText_SentencePieceEEdeEv:
 2446|  8.38M|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece17SentencePieceTextEE5beginEv:
 2613|  1.58k|RepeatedPtrField<Element>::begin() const {
 2614|  1.58k|  return iterator(raw_data());
 2615|  1.58k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece17SentencePieceTextEEC2IS4_EERKNS2_IT_EE:
 2438|  3.16k|      : it_(other.it_) {
 2439|       |    // Force a compiler error if the other type is not convertible to ours.
 2440|  3.16k|    if (false) {
  ------------------
  |  Branch (2440:9): [Folded, False: 3.16k]
  ------------------
 2441|      0|      implicit_cast<Element*>(static_cast<OtherElement*>(nullptr));
 2442|      0|    }
 2443|  3.16k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece17SentencePieceTextEE3endEv:
 2628|  1.58k|RepeatedPtrField<Element>::end() const {
 2629|  1.58k|  return iterator(raw_data() + size());
 2630|  1.58k|}
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece17SentencePieceTextEEneERKS6_:
 2463|  3.72k|  bool operator!=(const iterator& x) const { return it_ != x.it_; }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece17SentencePieceTextEEppEv:
 2450|  2.14k|  iterator& operator++() {
 2451|  2.14k|    ++it_;
 2452|  2.14k|    return *this;
 2453|  2.14k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece17SentencePieceTextEEdeEv:
 2446|  2.14k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE7ReserveEi:
 2397|  3.88k|inline void RepeatedPtrField<Element>::Reserve(int new_size) {
 2398|  3.88k|  return RepeatedPtrFieldBase::Reserve(new_size);
 2399|  3.88k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseD2Ev:
  582|  36.4k|  ~RepeatedPtrFieldBase() {
  583|       |#ifndef NDEBUG
  584|       |    // Try to trigger segfault / asan failure in non-opt builds. If arena_
  585|       |    // lifetime has ended before the destructor.
  586|       |    if (arena_) (void)arena_->SpaceAllocated();
  587|       |#endif
  588|  36.4k|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8GetArenaEv:
  719|  50.3k|  inline Arena* GetArena() const { return arena_; }
_ZN6google8protobuf8internal17StringTypeHandler3NewEPNS0_5ArenaE:
  888|  15.8k|  static inline std::string* New(Arena* arena) {
  889|  15.8k|    return Arena::Create<std::string>(arena);
  890|  15.8k|  }
_ZN6google8protobuf8internal17StringTypeHandler16NewFromPrototypeEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPNS0_5ArenaE:
  895|  15.8k|                                              Arena* arena) {
  896|  15.8k|    return New(arena);
  897|  15.8k|  }
_ZN6google8protobuf8internal17StringTypeHandler6DeleteEPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPNS0_5ArenaE:
  902|  15.8k|  static inline void Delete(std::string* value, Arena* arena) {
  903|  15.8k|    if (arena == NULL) {
  ------------------
  |  Branch (903:9): [True: 15.8k, False: 0]
  ------------------
  904|  15.8k|      delete value;
  905|  15.8k|    }
  906|  15.8k|  }
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE4sizeEv:
 2167|  6.67k|inline int RepeatedPtrField<Element>::size() const {
 2168|  6.67k|  return RepeatedPtrFieldBase::size();
 2169|  6.67k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEPNT_4TypeEPv:
  748|  17.1k|  static inline typename TypeHandler::Type* cast(void* element) {
  749|  17.1k|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  750|  17.1k|  }
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE3GetEi:
 2172|  1.31k|inline const Element& RepeatedPtrField<Element>::Get(int index) const {
 2173|  1.31k|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 2174|  1.31k|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEERKNT_4TypeEi:
 1704|  1.31k|    int index) const {
 1705|  1.31k|  GOOGLE_DCHECK_GE(index, 0);
  ------------------
  |  |  188|  1.31k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|  1.31k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 1.31k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1706|  1.31k|  GOOGLE_DCHECK_LT(index, current_size_);
  ------------------
  |  |  185|  1.31k|#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
  |  |  ------------------
  |  |  |  |  181|  1.31k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 1.31k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1707|  1.31k|  return *cast<TypeHandler>(rep_->elements[index]);
 1708|  1.31k|}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE3AddEv:
 2193|  15.8k|inline Element* RepeatedPtrField<Element>::Add() {
 2194|  15.8k|  return RepeatedPtrFieldBase::Add<TypeHandler>();
 2195|  15.8k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEPNT_4TypeESG_:
 1741|  15.8k|    typename TypeHandler::Type* prototype) {
 1742|  15.8k|  if (rep_ != NULL && current_size_ < rep_->allocated_size) {
  ------------------
  |  Branch (1742:7): [True: 14.7k, False: 1.03k]
  |  Branch (1742:23): [True: 0, False: 14.7k]
  ------------------
 1743|      0|    return cast<TypeHandler>(rep_->elements[current_size_++]);
 1744|      0|  }
 1745|  15.8k|  if (!rep_ || rep_->allocated_size == total_size_) {
  ------------------
  |  Branch (1745:7): [True: 1.03k, False: 14.7k]
  |  Branch (1745:16): [True: 185, False: 14.5k]
  ------------------
 1746|  1.21k|    Reserve(total_size_ + 1);
 1747|  1.21k|  }
 1748|  15.8k|  ++rep_->allocated_size;
 1749|  15.8k|  typename TypeHandler::Type* result =
 1750|  15.8k|      TypeHandler::NewFromPrototype(prototype, arena_);
 1751|  15.8k|  rep_->elements[current_size_++] = result;
 1752|  15.8k|  return result;
 1753|  15.8k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE11TypeHandlerEEEPNT_4TypeEPv:
  748|  1.67k|  static inline typename TypeHandler::Type* cast(void* element) {
  749|  1.67k|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  750|  1.67k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE3GetEi:
 2172|     91|inline const Element& RepeatedPtrField<Element>::Get(int index) const {
 2173|     91|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 2174|     91|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE11TypeHandlerEEERKNT_4TypeEi:
 1704|     91|    int index) const {
 1705|     91|  GOOGLE_DCHECK_GE(index, 0);
  ------------------
  |  |  188|     91|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|     91|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 91]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1706|     91|  GOOGLE_DCHECK_LT(index, current_size_);
  ------------------
  |  |  185|     91|#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
  |  |  ------------------
  |  |  |  |  181|     91|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 91]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1707|     91|  return *cast<TypeHandler>(rep_->elements[index]);
 1708|     91|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE3AddEv:
 2193|  1.58k|inline Element* RepeatedPtrField<Element>::Add() {
 2194|  1.58k|  return RepeatedPtrFieldBase::Add<TypeHandler>();
 2195|  1.58k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE11TypeHandlerEEEPNT_4TypeESB_:
 1741|  1.58k|    typename TypeHandler::Type* prototype) {
 1742|  1.58k|  if (rep_ != NULL && current_size_ < rep_->allocated_size) {
  ------------------
  |  Branch (1742:7): [True: 1.20k, False: 380]
  |  Branch (1742:23): [True: 0, False: 1.20k]
  ------------------
 1743|      0|    return cast<TypeHandler>(rep_->elements[current_size_++]);
 1744|      0|  }
 1745|  1.58k|  if (!rep_ || rep_->allocated_size == total_size_) {
  ------------------
  |  Branch (1745:7): [True: 380, False: 1.20k]
  |  Branch (1745:16): [True: 108, False: 1.09k]
  ------------------
 1746|    488|    Reserve(total_size_ + 1);
 1747|    488|  }
 1748|  1.58k|  ++rep_->allocated_size;
 1749|  1.58k|  typename TypeHandler::Type* result =
 1750|  1.58k|      TypeHandler::NewFromPrototype(prototype, arena_);
 1751|  1.58k|  rep_->elements[current_size_++] = result;
 1752|  1.58k|  return result;
 1753|  1.58k|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece19SelfTestData_SampleEE16NewFromPrototypeEPKS4_PNS0_5ArenaE:
  836|  1.58k|    const GenericType* /* prototype */, Arena* arena) {
  837|  1.58k|  return New(arena);
  838|  1.58k|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece19SelfTestData_SampleEE3NewEPNS0_5ArenaE:
  806|  1.58k|  static inline GenericType* New(Arena* arena) {
  807|  1.58k|    return Arena::CreateMaybeMessage<Type>(arena);
  808|  1.58k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE5ClearEv:
 2293|  7.70k|inline void RepeatedPtrField<Element>::Clear() {
 2294|  7.70k|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 2295|  7.70k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEvv:
 1778|  7.70k|void RepeatedPtrFieldBase::Clear() {
 1779|  7.70k|  const int n = current_size_;
 1780|  7.70k|  GOOGLE_DCHECK_GE(n, 0);
  ------------------
  |  |  188|  7.70k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|  7.70k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 7.70k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1781|  7.70k|  if (n > 0) {
  ------------------
  |  Branch (1781:7): [True: 0, False: 7.70k]
  ------------------
 1782|      0|    void* const* elements = rep_->elements;
 1783|      0|    int i = 0;
 1784|      0|    do {
 1785|      0|      TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
 1786|      0|    } while (i < n);
  ------------------
  |  Branch (1786:14): [True: 0, False: 0]
  ------------------
 1787|      0|    current_size_ = 0;
 1788|      0|  }
 1789|  7.70k|}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3GetEi:
 2172|   164M|inline const Element& RepeatedPtrField<Element>::Get(int index) const {
 2173|   164M|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 2174|   164M|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEERKNT_4TypeEi:
 1704|   164M|    int index) const {
 1705|   164M|  GOOGLE_DCHECK_GE(index, 0);
  ------------------
  |  |  188|   164M|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|   164M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 164M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1706|   164M|  GOOGLE_DCHECK_LT(index, current_size_);
  ------------------
  |  |  185|   164M|#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
  |  |  ------------------
  |  |  |  |  181|   164M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 164M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1707|   164M|  return *cast<TypeHandler>(rep_->elements[index]);
 1708|   164M|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3AddEv:
 2193|  1.48M|inline Element* RepeatedPtrField<Element>::Add() {
 2194|  1.48M|  return RepeatedPtrFieldBase::Add<TypeHandler>();
 2195|  1.48M|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEPNT_4TypeESB_:
 1741|  1.48M|    typename TypeHandler::Type* prototype) {
 1742|  1.48M|  if (rep_ != NULL && current_size_ < rep_->allocated_size) {
  ------------------
  |  Branch (1742:7): [True: 1.48M, False: 4.29k]
  |  Branch (1742:23): [True: 0, False: 1.48M]
  ------------------
 1743|      0|    return cast<TypeHandler>(rep_->elements[current_size_++]);
 1744|      0|  }
 1745|  1.48M|  if (!rep_ || rep_->allocated_size == total_size_) {
  ------------------
  |  Branch (1745:7): [True: 4.29k, False: 1.48M]
  |  Branch (1745:16): [True: 4.61k, False: 1.48M]
  ------------------
 1746|  8.91k|    Reserve(total_size_ + 1);
 1747|  8.91k|  }
 1748|  1.48M|  ++rep_->allocated_size;
 1749|  1.48M|  typename TypeHandler::Type* result =
 1750|  1.48M|      TypeHandler::NewFromPrototype(prototype, arena_);
 1751|  1.48M|  rep_->elements[current_size_++] = result;
 1752|  1.48M|  return result;
 1753|  1.48M|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE16NewFromPrototypeEPKS4_PNS0_5ArenaE:
  836|  1.48M|    const GenericType* /* prototype */, Arena* arena) {
  837|  1.48M|  return New(arena);
  838|  1.48M|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE3NewEPNS0_5ArenaE:
  806|  1.48M|  static inline GenericType* New(Arena* arena) {
  807|  1.48M|    return Arena::CreateMaybeMessage<Type>(arena);
  808|  1.48M|  }
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE5ClearEv:
 2293|  12.3k|inline void RepeatedPtrField<Element>::Clear() {
 2294|  12.3k|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 2295|  12.3k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE11TypeHandlerEEEvv:
 1778|  12.3k|void RepeatedPtrFieldBase::Clear() {
 1779|  12.3k|  const int n = current_size_;
 1780|  12.3k|  GOOGLE_DCHECK_GE(n, 0);
  ------------------
  |  |  188|  12.3k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|  12.3k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 12.3k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1781|  12.3k|  if (n > 0) {
  ------------------
  |  Branch (1781:7): [True: 0, False: 12.3k]
  ------------------
 1782|      0|    void* const* elements = rep_->elements;
 1783|      0|    int i = 0;
 1784|      0|    do {
 1785|      0|      TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
 1786|      0|    } while (i < n);
  ------------------
  |  Branch (1786:14): [True: 0, False: 0]
  ------------------
 1787|      0|    current_size_ = 0;
 1788|      0|  }
 1789|  12.3k|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece17SentencePieceTextEE5ClearEv:
 2293|  2.03k|inline void RepeatedPtrField<Element>::Clear() {
 2294|  2.03k|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 2295|  2.03k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN13sentencepiece17SentencePieceTextEE11TypeHandlerEEEvv:
 1778|  2.03k|void RepeatedPtrFieldBase::Clear() {
 1779|  2.03k|  const int n = current_size_;
 1780|  2.03k|  GOOGLE_DCHECK_GE(n, 0);
  ------------------
  |  |  188|  2.03k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|  2.03k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 2.03k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1781|  2.03k|  if (n > 0) {
  ------------------
  |  Branch (1781:7): [True: 0, False: 2.03k]
  ------------------
 1782|      0|    void* const* elements = rep_->elements;
 1783|      0|    int i = 0;
 1784|      0|    do {
 1785|      0|      TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
 1786|      0|    } while (i < n);
  ------------------
  |  Branch (1786:14): [True: 0, False: 0]
  ------------------
 1787|      0|    current_size_ = 0;
 1788|      0|  }
 1789|  2.03k|}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPNS0_5ArenaE:
 2098|  11.6k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEED2Ev:
 2121|  11.5k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 2122|  11.5k|  Destroy<TypeHandler>();
 2123|  11.5k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2EPNS0_5ArenaE:
 1654|  36.4k|    : arena_(arena), current_size_(0), total_size_(0), rep_(NULL) {}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7DestroyINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEvv:
 1657|  11.5k|void RepeatedPtrFieldBase::Destroy() {
 1658|  11.5k|  if (rep_ != NULL && arena_ == NULL) {
  ------------------
  |  Branch (1658:7): [True: 1.03k, False: 10.5k]
  |  Branch (1658:23): [True: 1.03k, False: 0]
  ------------------
 1659|  1.03k|    int n = rep_->allocated_size;
 1660|  1.03k|    void* const* elements = rep_->elements;
 1661|  16.8k|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1661:21): [True: 15.8k, False: 1.03k]
  ------------------
 1662|  15.8k|      TypeHandler::Delete(cast<TypeHandler>(elements[i]), NULL);
 1663|  15.8k|    }
 1664|  1.03k|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
 1665|  1.03k|    const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
 1666|  1.03k|    ::operator delete(static_cast<void*>(rep_), size);
 1667|       |#else
 1668|       |    ::operator delete(static_cast<void*>(rep_));
 1669|       |#endif
 1670|  1.03k|  }
 1671|       |  rep_ = NULL;
 1672|  11.5k|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEEC2EPNS0_5ArenaE:
 2098|  14.4k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEED2Ev:
 2121|  14.4k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 2122|  14.4k|  Destroy<TypeHandler>();
 2123|  14.4k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7DestroyINS0_16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE11TypeHandlerEEEvv:
 1657|  14.4k|void RepeatedPtrFieldBase::Destroy() {
 1658|  14.4k|  if (rep_ != NULL && arena_ == NULL) {
  ------------------
  |  Branch (1658:7): [True: 13.2k, False: 1.19k]
  |  Branch (1658:23): [True: 13.2k, False: 0]
  ------------------
 1659|  13.2k|    int n = rep_->allocated_size;
 1660|  13.2k|    void* const* elements = rep_->elements;
 1661|  11.5M|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1661:21): [True: 11.5M, False: 13.2k]
  ------------------
 1662|  11.5M|      TypeHandler::Delete(cast<TypeHandler>(elements[i]), NULL);
 1663|  11.5M|    }
 1664|  13.2k|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
 1665|  13.2k|    const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
 1666|  13.2k|    ::operator delete(static_cast<void*>(rep_), size);
 1667|       |#else
 1668|       |    ::operator delete(static_cast<void*>(rep_));
 1669|       |#endif
 1670|  13.2k|  }
 1671|       |  rep_ = NULL;
 1672|  14.4k|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece31SentencePieceText_SentencePieceEE6DeleteEPS4_PNS0_5ArenaE:
  814|  11.5M|  static inline void Delete(GenericType* value, Arena* arena) {
  815|  11.5M|    if (arena == NULL) {
  ------------------
  |  Branch (815:9): [True: 11.5M, False: 0]
  ------------------
  816|  11.5M|      delete value;
  817|  11.5M|    }
  818|  11.5M|  }
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece17SentencePieceTextEEC2EPNS0_5ArenaE:
 2098|  2.03k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece17SentencePieceTextEED2Ev:
 2121|  2.03k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 2122|  2.03k|  Destroy<TypeHandler>();
 2123|  2.03k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7DestroyINS0_16RepeatedPtrFieldIN13sentencepiece17SentencePieceTextEE11TypeHandlerEEEvv:
 1657|  2.03k|void RepeatedPtrFieldBase::Destroy() {
 1658|  2.03k|  if (rep_ != NULL && arena_ == NULL) {
  ------------------
  |  Branch (1658:7): [True: 1.58k, False: 452]
  |  Branch (1658:23): [True: 1.58k, False: 0]
  ------------------
 1659|  1.58k|    int n = rep_->allocated_size;
 1660|  1.58k|    void* const* elements = rep_->elements;
 1661|  3.72k|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1661:21): [True: 2.14k, False: 1.58k]
  ------------------
 1662|  2.14k|      TypeHandler::Delete(cast<TypeHandler>(elements[i]), NULL);
 1663|  2.14k|    }
 1664|  1.58k|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
 1665|  1.58k|    const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
 1666|  1.58k|    ::operator delete(static_cast<void*>(rep_), size);
 1667|       |#else
 1668|       |    ::operator delete(static_cast<void*>(rep_));
 1669|       |#endif
 1670|  1.58k|  }
 1671|       |  rep_ = NULL;
 1672|  2.03k|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece17SentencePieceTextEE6DeleteEPS4_PNS0_5ArenaE:
  814|  2.14k|  static inline void Delete(GenericType* value, Arena* arena) {
  815|  2.14k|    if (arena == NULL) {
  ------------------
  |  Branch (815:9): [True: 2.14k, False: 0]
  ------------------
  816|  2.14k|      delete value;
  817|  2.14k|    }
  818|  2.14k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEEC2EPNS0_5ArenaE:
 2098|    626|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEED2Ev:
 2121|    625|RepeatedPtrField<Element>::~RepeatedPtrField() {
 2122|    625|  Destroy<TypeHandler>();
 2123|    625|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7DestroyINS0_16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE11TypeHandlerEEEvv:
 1657|    625|void RepeatedPtrFieldBase::Destroy() {
 1658|    625|  if (rep_ != NULL && arena_ == NULL) {
  ------------------
  |  Branch (1658:7): [True: 380, False: 245]
  |  Branch (1658:23): [True: 380, False: 0]
  ------------------
 1659|    380|    int n = rep_->allocated_size;
 1660|    380|    void* const* elements = rep_->elements;
 1661|  1.96k|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1661:21): [True: 1.58k, False: 380]
  ------------------
 1662|  1.58k|      TypeHandler::Delete(cast<TypeHandler>(elements[i]), NULL);
 1663|  1.58k|    }
 1664|    380|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
 1665|    380|    const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
 1666|    380|    ::operator delete(static_cast<void*>(rep_), size);
 1667|       |#else
 1668|       |    ::operator delete(static_cast<void*>(rep_));
 1669|       |#endif
 1670|    380|  }
 1671|       |  rep_ = NULL;
 1672|    625|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece19SelfTestData_SampleEE6DeleteEPS4_PNS0_5ArenaE:
  814|  1.58k|  static inline void Delete(GenericType* value, Arena* arena) {
  815|  1.58k|    if (arena == NULL) {
  ------------------
  |  Branch (815:9): [True: 1.58k, False: 0]
  ------------------
  816|  1.58k|      delete value;
  817|  1.58k|    }
  818|  1.58k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEEC2EPNS0_5ArenaE:
 2098|  7.70k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEED2Ev:
 2121|  7.70k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 2122|  7.70k|  Destroy<TypeHandler>();
 2123|  7.70k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7DestroyINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEvv:
 1657|  7.70k|void RepeatedPtrFieldBase::Destroy() {
 1658|  7.70k|  if (rep_ != NULL && arena_ == NULL) {
  ------------------
  |  Branch (1658:7): [True: 4.29k, False: 3.40k]
  |  Branch (1658:23): [True: 4.29k, False: 0]
  ------------------
 1659|  4.29k|    int n = rep_->allocated_size;
 1660|  4.29k|    void* const* elements = rep_->elements;
 1661|  1.49M|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1661:21): [True: 1.48M, False: 4.29k]
  ------------------
 1662|  1.48M|      TypeHandler::Delete(cast<TypeHandler>(elements[i]), NULL);
 1663|  1.48M|    }
 1664|  4.29k|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
 1665|  4.29k|    const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
 1666|  4.29k|    ::operator delete(static_cast<void*>(rep_), size);
 1667|       |#else
 1668|       |    ::operator delete(static_cast<void*>(rep_));
 1669|       |#endif
 1670|  4.29k|  }
 1671|       |  rep_ = NULL;
 1672|  7.70k|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE6DeleteEPS4_PNS0_5ArenaE:
  814|  1.48M|  static inline void Delete(GenericType* value, Arena* arena) {
  815|  1.48M|    if (arena == NULL) {
  ------------------
  |  Branch (815:9): [True: 1.48M, False: 0]
  ------------------
  816|  1.48M|      delete value;
  817|  1.48M|    }
  818|  1.48M|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE5beginEv:
 2613|  4.48k|RepeatedPtrField<Element>::begin() const {
 2614|  4.48k|  return iterator(raw_data());
 2615|  4.48k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEC2IS4_EERKNS2_IT_EE:
 2438|  8.97k|      : it_(other.it_) {
 2439|       |    // Force a compiler error if the other type is not convertible to ours.
 2440|  8.97k|    if (false) {
  ------------------
  |  Branch (2440:9): [Folded, False: 8.97k]
  ------------------
 2441|      0|      implicit_cast<Element*>(static_cast<OtherElement*>(nullptr));
 2442|      0|    }
 2443|  8.97k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3endEv:
 2628|  4.48k|RepeatedPtrField<Element>::end() const {
 2629|  4.48k|  return iterator(raw_data() + size());
 2630|  4.48k|}
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEneERKS6_:
 2463|  1.33M|  bool operator!=(const iterator& x) const { return it_ != x.it_; }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEppEv:
 2450|  1.32M|  iterator& operator++() {
 2451|  1.32M|    ++it_;
 2452|  1.32M|    return *this;
 2453|  1.32M|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEdeEv:
 2446|  1.32M|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }

_ZN6google8protobuf8internal8bit_castIjfEET_RKT0_:
  118|  27.1k|inline To bit_cast(const From& from) {
  119|  27.1k|  GOOGLE_COMPILE_ASSERT(sizeof(From) == sizeof(To),
  ------------------
  |  |  115|  27.1k|#define GOOGLE_COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)
  ------------------
  120|  27.1k|                        bit_cast_with_different_sizes);
  121|  27.1k|  To dest;
  122|  27.1k|  memcpy(&dest, &from, sizeof(dest));
  123|  27.1k|  return dest;
  124|  27.1k|}

_ZN6google8protobuf8internal12WrappedMutex4LockEv:
   99|     18|  void Lock() GOOGLE_PROTOBUF_ACQUIRE() { mu_.lock(); }
_ZN6google8protobuf8internal12WrappedMutex6UnlockEv:
  100|     18|  void Unlock() GOOGLE_PROTOBUF_RELEASE() { mu_.unlock(); }
_ZN6google8protobuf8internal9MutexLockC2EPNS1_12WrappedMutexE:
  118|     10|  explicit MutexLock(Mutex *mu) : mu_(mu) { this->mu_->Lock(); }
_ZN6google8protobuf8internal9MutexLockD2Ev:
  119|     10|  ~MutexLock() { this->mu_->Unlock(); }
_ZN6google8protobuf8internal12WrappedMutexC2Ev:
   98|      1|  WrappedMutex() = default;

_ZN6google8protobuf4Bits16Log2FloorNonZeroEj:
  282|  18.6M|  static uint32 Log2FloorNonZero(uint32 n) {
  283|  18.6M|#if defined(__GNUC__)
  284|  18.6M|  return 31 ^ static_cast<uint32>(__builtin_clz(n));
  285|       |#elif defined(_MSC_VER)
  286|       |  unsigned long where;
  287|       |  _BitScanReverse(&where, n);
  288|       |  return where;
  289|       |#else
  290|       |  return Log2FloorNonZero_Portable(n);
  291|       |#endif
  292|  18.6M|  }
_ZN6google8protobuf4Bits18Log2FloorNonZero64Em:
  294|      2|  static uint32 Log2FloorNonZero64(uint64 n) {
  295|       |    // Older versions of clang run into an instruction-selection failure when
  296|       |    // it encounters __builtin_clzll:
  297|       |    // https://bugs.chromium.org/p/nativeclient/issues/detail?id=4395
  298|       |    // This includes arm-nacl-clang and clang in older Android NDK versions.
  299|       |    // To work around this, when we build with those we use the portable
  300|       |    // implementation instead.
  301|      2|#if defined(__GNUC__) && !defined(GOOGLE_PROTOBUF_USE_PORTABLE_LOG2)
  302|      2|  return 63 ^ static_cast<uint32>(__builtin_clzll(n));
  303|       |#elif defined(_MSC_VER) && defined(_M_X64)
  304|       |  unsigned long where;
  305|       |  _BitScanReverse64(&where, n);
  306|       |  return where;
  307|       |#else
  308|       |  return Log2FloorNonZero64_Portable(n);
  309|       |#endif
  310|      2|  }

_ZN6google8protobuf28STLStringResizeUninitializedEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEm:
   47|  6.09k|inline void STLStringResizeUninitialized(std::string* s, size_t new_size) {
   48|  6.09k|  s->resize(new_size);
   49|  6.09k|}

_ZN6google8protobuf11StringPiece22CheckedSsizeTFromSizeTEm:
  186|      4|  static stringpiece_ssize_type CheckedSsizeTFromSizeT(size_t size) {
  187|       |#if STRINGPIECE_CHECK_SIZE > 0
  188|       |#ifdef max
  189|       |#undef max
  190|       |#endif
  191|       |    if (size > static_cast<size_t>(
  192|       |        std::numeric_limits<stringpiece_ssize_type>::max())) {
  193|       |      // Some people grep for this message in logs
  194|       |      // so take care if you ever change it.
  195|       |      LogFatalSizeTooBig(size, "size_t to int conversion");
  196|       |    }
  197|       |#endif
  198|      4|    return static_cast<stringpiece_ssize_type>(size);
  199|      4|  }
_ZN6google8protobuf11StringPieceC2EPKc:
  214|      4|      : ptr_(str), length_(0) {
  215|      4|    if (str != nullptr) {
  ------------------
  |  Branch (215:9): [True: 4, False: 0]
  ------------------
  216|      4|      length_ = CheckedSsizeTFromSizeT(strlen(str));
  217|      4|    }
  218|      4|  }
_ZN6google8protobuf11StringPieceC2EPKcl:
  228|  7.72k|      : ptr_(offset), length_(len) {
  229|       |    assert(len >= 0);
  230|  7.72k|  }
_ZNK6google8protobuf11StringPiece4dataEv:
  246|  13.0k|  const char* data() const { return ptr_; }
_ZNK6google8protobuf11StringPiece4sizeEv:
  247|  17.7k|  stringpiece_ssize_type size() const { return length_; }
_ZNK6google8protobuf11StringPiece8ToStringEv:
  310|      4|  std::string ToString() const {
  311|      4|    if (ptr_ == nullptr) return "";
  ------------------
  |  Branch (311:9): [True: 0, False: 4]
  ------------------
  312|      4|    return std::string(data(), static_cast<size_type>(size()));
  313|      4|  }

_ZN6google8protobuf8internal14WireFormatLite7MakeTagEiNS2_8WireTypeE:
  785|  12.4M|                                                WireType type) {
  786|  12.4M|  return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
  ------------------
  |  |  204|  12.4M|  static_cast<uint32>((static_cast<uint32>(FIELD_NUMBER) << 3) | (TYPE))
  ------------------
  787|  12.4M|}
_ZN6google8protobuf8internal14WireFormatLite11EncodeFloatEf:
  809|  27.1k|inline uint32 WireFormatLite::EncodeFloat(float value) {
  810|  27.1k|  return bit_cast<uint32>(value);
  811|  27.1k|}
_ZN6google8protobuf8internal14WireFormatLite15WriteTagToArrayEiNS2_8WireTypeEPh:
 1355|  12.4M|                                              uint8* target) {
 1356|  12.4M|  return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type),
 1357|  12.4M|                                                target);
 1358|  12.4M|}
_ZN6google8protobuf8internal14WireFormatLite22WriteInt32NoTagToArrayEiPh:
 1361|    140|                                                     uint8* target) {
 1362|    140|  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
 1363|    140|}
_ZN6google8protobuf8internal14WireFormatLite23WriteUInt32NoTagToArrayEjPh:
 1370|  9.30M|                                                      uint8* target) {
 1371|  9.30M|  return io::CodedOutputStream::WriteVarint32ToArray(value, target);
 1372|  9.30M|}
_ZN6google8protobuf8internal14WireFormatLite23WriteUInt64NoTagToArrayEmPh:
 1374|      2|                                                      uint8* target) {
 1375|      2|  return io::CodedOutputStream::WriteVarint64ToArray(value, target);
 1376|      2|}
_ZN6google8protobuf8internal14WireFormatLite22WriteFloatNoTagToArrayEfPh:
 1406|  27.1k|                                                     uint8* target) {
 1407|  27.1k|  return io::CodedOutputStream::WriteLittleEndian32ToArray(EncodeFloat(value),
 1408|  27.1k|                                                           target);
 1409|  27.1k|}
_ZN6google8protobuf8internal14WireFormatLite21WriteBoolNoTagToArrayEbPh:
 1415|    266|inline uint8* WireFormatLite::WriteBoolNoTagToArray(bool value, uint8* target) {
 1416|    266|  return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target);
  ------------------
  |  Branch (1416:54): [True: 240, False: 26]
  ------------------
 1417|    266|}
_ZN6google8protobuf8internal14WireFormatLite21WriteEnumNoTagToArrayEiPh:
 1418|  12.0k|inline uint8* WireFormatLite::WriteEnumNoTagToArray(int value, uint8* target) {
 1419|  12.0k|  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
 1420|  12.0k|}
_ZN6google8protobuf8internal14WireFormatLite17WriteInt32ToArrayEiiPh:
 1513|    140|                                                uint8* target) {
 1514|    140|  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 1515|    140|  return WriteInt32NoTagToArray(value, target);
 1516|    140|}
_ZN6google8protobuf8internal14WireFormatLite18WriteUInt32ToArrayEijPh:
 1523|  9.30M|                                                 uint8* target) {
 1524|  9.30M|  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 1525|  9.30M|  return WriteUInt32NoTagToArray(value, target);
 1526|  9.30M|}
_ZN6google8protobuf8internal14WireFormatLite18WriteUInt64ToArrayEimPh:
 1528|      2|                                                 uint8* target) {
 1529|      2|  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 1530|      2|  return WriteUInt64NoTagToArray(value, target);
 1531|      2|}
_ZN6google8protobuf8internal14WireFormatLite17WriteFloatToArrayEifPh:
 1563|  27.1k|                                                uint8* target) {
 1564|  27.1k|  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
 1565|  27.1k|  return WriteFloatNoTagToArray(value, target);
 1566|  27.1k|}
_ZN6google8protobuf8internal14WireFormatLite16WriteBoolToArrayEibPh:
 1573|    266|                                               uint8* target) {
 1574|    266|  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 1575|    266|  return WriteBoolNoTagToArray(value, target);
 1576|    266|}
_ZN6google8protobuf8internal14WireFormatLite16WriteEnumToArrayEiiPh:
 1578|  12.0k|                                               uint8* target) {
 1579|  12.0k|  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 1580|  12.0k|  return WriteEnumNoTagToArray(value, target);
 1581|  12.0k|}
_ZN6google8protobuf8internal14WireFormatLite9Int32SizeEi:
 1727|    140|inline size_t WireFormatLite::Int32Size(int32 value) {
 1728|    140|  return io::CodedOutputStream::VarintSize32SignExtended(value);
 1729|    140|}
_ZN6google8protobuf8internal14WireFormatLite10UInt32SizeEj:
 1733|  9.30M|inline size_t WireFormatLite::UInt32Size(uint32 value) {
 1734|  9.30M|  return io::CodedOutputStream::VarintSize32(value);
 1735|  9.30M|}
_ZN6google8protobuf8internal14WireFormatLite10UInt64SizeEm:
 1736|      2|inline size_t WireFormatLite::UInt64Size(uint64 value) {
 1737|      2|  return io::CodedOutputStream::VarintSize64(value);
 1738|      2|}
_ZN6google8protobuf8internal14WireFormatLite8EnumSizeEi:
 1745|  12.0k|inline size_t WireFormatLite::EnumSize(int value) {
 1746|  12.0k|  return io::CodedOutputStream::VarintSize32SignExtended(value);
 1747|  12.0k|}
_ZN6google8protobuf8internal14WireFormatLite10StringSizeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1749|  6.23M|inline size_t WireFormatLite::StringSize(const std::string& value) {
 1750|  6.23M|  return LengthDelimitedSize(value.size());
 1751|  6.23M|}
_ZN6google8protobuf8internal14WireFormatLite9BytesSizeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1752|      9|inline size_t WireFormatLite::BytesSize(const std::string& value) {
 1753|      9|  return LengthDelimitedSize(value.size());
 1754|      9|}
_ZN6google8protobuf8internal14WireFormatLite19LengthDelimitedSizeEm:
 1780|  9.36M|inline size_t WireFormatLite::LengthDelimitedSize(size_t length) {
 1781|       |  // The static_cast here prevents an error in certain compiler configurations
 1782|       |  // but is not technically correct--if length is too large to fit in a uint32
 1783|       |  // then it will be silently truncated. We will need to fix this if we ever
 1784|       |  // decide to start supporting serialized messages greater than 2 GiB in size.
 1785|  9.36M|  return length +
 1786|  9.36M|         io::CodedOutputStream::VarintSize32(static_cast<uint32>(length));
 1787|  9.36M|}
_ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageIN13sentencepiece31SentencePieceText_SentencePieceEEEPhiRKT_S6_PNS0_2io19EpsCopyOutputStreamE:
 1693|  3.10M|    io::EpsCopyOutputStream* stream) {
 1694|  3.10M|  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 1695|  3.10M|  target = io::CodedOutputStream::WriteVarint32ToArray(
 1696|  3.10M|      static_cast<uint32>(value.GetCachedSize()), target);
 1697|  3.10M|  return value._InternalSerialize(target, stream);
 1698|  3.10M|}
_ZN6google8protobuf8internal14WireFormatLite11MessageSizeIN13sentencepiece31SentencePieceText_SentencePieceEEEmRKT_:
 1762|  3.10M|inline size_t WireFormatLite::MessageSize(const MessageType& value) {
 1763|  3.10M|  return LengthDelimitedSize(value.ByteSizeLong());
 1764|  3.10M|}
_ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageIN13sentencepiece19SelfTestData_SampleEEEPhiRKT_S6_PNS0_2io19EpsCopyOutputStreamE:
 1693|     91|    io::EpsCopyOutputStream* stream) {
 1694|     91|  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 1695|     91|  target = io::CodedOutputStream::WriteVarint32ToArray(
 1696|     91|      static_cast<uint32>(value.GetCachedSize()), target);
 1697|     91|  return value._InternalSerialize(target, stream);
 1698|     91|}
_ZN6google8protobuf8internal14WireFormatLite11MessageSizeIN13sentencepiece19SelfTestData_SampleEEEmRKT_:
 1762|     91|inline size_t WireFormatLite::MessageSize(const MessageType& value) {
 1763|     91|  return LengthDelimitedSize(value.ByteSizeLong());
 1764|     91|}
_ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageIN13sentencepiece24ModelProto_SentencePieceEEEPhiRKT_S6_PNS0_2io19EpsCopyOutputStreamE:
 1693|  27.3k|    io::EpsCopyOutputStream* stream) {
 1694|  27.3k|  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 1695|  27.3k|  target = io::CodedOutputStream::WriteVarint32ToArray(
 1696|  27.3k|      static_cast<uint32>(value.GetCachedSize()), target);
 1697|  27.3k|  return value._InternalSerialize(target, stream);
 1698|  27.3k|}
_ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageIN13sentencepiece11TrainerSpecEEEPhiRKT_S6_PNS0_2io19EpsCopyOutputStreamE:
 1693|    556|    io::EpsCopyOutputStream* stream) {
 1694|    556|  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 1695|    556|  target = io::CodedOutputStream::WriteVarint32ToArray(
 1696|    556|      static_cast<uint32>(value.GetCachedSize()), target);
 1697|    556|  return value._InternalSerialize(target, stream);
 1698|    556|}
_ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageIN13sentencepiece14NormalizerSpecEEEPhiRKT_S6_PNS0_2io19EpsCopyOutputStreamE:
 1693|    222|    io::EpsCopyOutputStream* stream) {
 1694|    222|  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 1695|    222|  target = io::CodedOutputStream::WriteVarint32ToArray(
 1696|    222|      static_cast<uint32>(value.GetCachedSize()), target);
 1697|    222|  return value._InternalSerialize(target, stream);
 1698|    222|}
_ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageIN13sentencepiece12SelfTestDataEEEPhiRKT_S6_PNS0_2io19EpsCopyOutputStreamE:
 1693|     32|    io::EpsCopyOutputStream* stream) {
 1694|     32|  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 1695|     32|  target = io::CodedOutputStream::WriteVarint32ToArray(
 1696|     32|      static_cast<uint32>(value.GetCachedSize()), target);
 1697|     32|  return value._InternalSerialize(target, stream);
 1698|     32|}
_ZN6google8protobuf8internal14WireFormatLite11MessageSizeIN13sentencepiece24ModelProto_SentencePieceEEEmRKT_:
 1762|  27.3k|inline size_t WireFormatLite::MessageSize(const MessageType& value) {
 1763|  27.3k|  return LengthDelimitedSize(value.ByteSizeLong());
 1764|  27.3k|}
_ZN6google8protobuf8internal14WireFormatLite11MessageSizeIN13sentencepiece11TrainerSpecEEEmRKT_:
 1762|    556|inline size_t WireFormatLite::MessageSize(const MessageType& value) {
 1763|    556|  return LengthDelimitedSize(value.ByteSizeLong());
 1764|    556|}
_ZN6google8protobuf8internal14WireFormatLite11MessageSizeIN13sentencepiece14NormalizerSpecEEEmRKT_:
 1762|    222|inline size_t WireFormatLite::MessageSize(const MessageType& value) {
 1763|    222|  return LengthDelimitedSize(value.ByteSizeLong());
 1764|    222|}
_ZN6google8protobuf8internal14WireFormatLite11MessageSizeIN13sentencepiece12SelfTestDataEEEmRKT_:
 1762|     32|inline size_t WireFormatLite::MessageSize(const MessageType& value) {
 1763|     32|  return LengthDelimitedSize(value.ByteSizeLong());
 1764|     32|}

_ZN6google8protobuf8internal13MergeFromImplILb0EEEbNS0_11StringPieceEPNS0_11MessageLiteENS4_10ParseFlagsE:
  140|  7.70k|                   MessageLite::ParseFlags parse_flags) {
  141|  7.70k|  const char* ptr;
  142|  7.70k|  internal::ParseContext ctx(io::CodedInputStream::GetDefaultRecursionLimit(),
  143|  7.70k|                             aliasing, &ptr, input);
  144|  7.70k|  ptr = msg->_InternalParse(ptr, &ctx);
  145|       |  // ctx has an explicit limit set (length of string_view).
  146|  7.70k|  if (PROTOBUF_PREDICT_TRUE(ptr && ctx.EndedAtLimit())) {
  ------------------
  |  |  236|  10.9k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 3.17k, False: 4.52k]
  |  |  |  Branch (236:55): [True: 3.28k, False: 4.41k]
  |  |  |  Branch (236:55): [True: 3.17k, False: 108]
  |  |  ------------------
  ------------------
  147|  3.17k|    return CheckFieldPresence(ctx, *msg, parse_flags);
  148|  3.17k|  }
  149|  4.52k|  return false;
  150|  7.70k|}
_ZN6google8protobuf11MessageLite14ParseFromArrayEPKvi:
  324|  7.70k|bool MessageLite::ParseFromArray(const void* data, int size) {
  325|  7.70k|  return ParseFrom<kParse>(as_string_view(data, size));
  326|  7.70k|}
_ZNK6google8protobuf11MessageLite14AppendToStringEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  448|  6.09k|bool MessageLite::AppendToString(std::string* output) const {
  449|  6.09k|  GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
  ------------------
  |  |  181|  6.09k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 6.09k]
  |  |  ------------------
  ------------------
  450|  6.09k|  return AppendPartialToString(output);
  451|  6.09k|}
_ZNK6google8protobuf11MessageLite21AppendPartialToStringEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  453|  6.09k|bool MessageLite::AppendPartialToString(std::string* output) const {
  454|  6.09k|  size_t old_size = output->size();
  455|  6.09k|  size_t byte_size = ByteSizeLong();
  456|  6.09k|  if (byte_size > INT_MAX) {
  ------------------
  |  Branch (456:7): [True: 0, False: 6.09k]
  ------------------
  457|      0|    GOOGLE_LOG(ERROR) << GetTypeName()
  ------------------
  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  ------------------
  458|      0|               << " exceeded maximum protobuf size of 2GB: " << byte_size;
  459|      0|    return false;
  460|      0|  }
  461|       |
  462|  6.09k|  STLStringResizeUninitialized(output, old_size + byte_size);
  463|  6.09k|  uint8* start =
  464|  6.09k|      reinterpret_cast<uint8*>(io::mutable_string_data(output) + old_size);
  465|  6.09k|  SerializeToArrayImpl(*this, start, byte_size);
  466|  6.09k|  return true;
  467|  6.09k|}
_ZNK6google8protobuf11MessageLite17SerializeAsStringEv:
  497|  6.09k|std::string MessageLite::SerializeAsString() const {
  498|       |  // If the compiler implements the (Named) Return Value Optimization,
  499|       |  // the local variable 'output' will not actually reside on the stack
  500|       |  // of this function, but will be overlaid with the object that the
  501|       |  // caller supplied for the return value to be constructed in.
  502|  6.09k|  std::string output;
  503|  6.09k|  if (!AppendToString(&output)) output.clear();
  ------------------
  |  Branch (503:7): [True: 0, False: 6.09k]
  ------------------
  504|  6.09k|  return output;
  505|  6.09k|}
_ZN6google8protobuf8internal13OnShutdownRunEPFvPKvES3_:
  564|     10|void OnShutdownRun(void (*f)(const void*), const void* arg) {
  565|     10|  auto shutdown_data = ShutdownData::get();
  566|     10|  MutexLock lock(&shutdown_data->mutex);
  567|     10|  shutdown_data->functions.push_back(std::make_pair(f, arg));
  568|     10|}
message_lite.cc:_ZN6google8protobuf12_GLOBAL__N_118CheckFieldPresenceERKNS0_8internal12ParseContextERKNS0_11MessageLiteENS6_10ParseFlagsE:
  123|  3.17k|                               MessageLite::ParseFlags parse_flags) {
  124|  3.17k|  if (PROTOBUF_PREDICT_FALSE((parse_flags & MessageLite::kMergePartial) != 0)) {
  ------------------
  |  |  247|  3.17k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 3.17k]
  |  |  ------------------
  ------------------
  125|      0|    return true;
  126|      0|  }
  127|  3.17k|  return msg.IsInitializedWithErrors();
  128|  3.17k|}
message_lite.cc:_ZN6google8protobuf12_GLOBAL__N_114as_string_viewEPKvi:
  116|  7.70k|inline StringPiece as_string_view(const void* data, int size) {
  117|  7.70k|  return StringPiece(static_cast<const char*>(data), size);
  118|  7.70k|}
_ZN6google8protobuf20SerializeToArrayImplERKNS0_11MessageLiteEPhi:
  340|  6.09k|                                   int size) {
  341|  6.09k|  constexpr bool debug = false;
  342|  6.09k|  if (debug) {
  ------------------
  |  Branch (342:7): [Folded, False: 6.09k]
  ------------------
  343|       |    // Force serialization to a stream with a block size of 1, which forces
  344|       |    // all writes to the stream to cross buffers triggering all fallback paths
  345|       |    // in the unittests when serializing to string / array.
  346|      0|    io::ArrayOutputStream stream(target, size, 1);
  347|      0|    uint8* ptr;
  348|      0|    io::EpsCopyOutputStream out(
  349|      0|        &stream, io::CodedOutputStream::IsDefaultSerializationDeterministic(),
  350|      0|        &ptr);
  351|      0|    ptr = msg._InternalSerialize(ptr, &out);
  352|      0|    out.Trim(ptr);
  353|      0|    GOOGLE_DCHECK(!out.HadError() && stream.ByteCount() == size);
  ------------------
  |  |  181|      0|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 0]
  |  |  ------------------
  ------------------
  354|      0|    return target + size;
  355|  6.09k|  } else {
  356|  6.09k|    io::EpsCopyOutputStream out(
  357|  6.09k|        target, size,
  358|  6.09k|        io::CodedOutputStream::IsDefaultSerializationDeterministic());
  359|  6.09k|    auto res = msg._InternalSerialize(target, &out);
  360|  6.09k|    GOOGLE_DCHECK(target + size == res);
  ------------------
  |  |  181|  6.09k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 6.09k]
  |  |  ------------------
  ------------------
  361|  6.09k|    return res;
  362|  6.09k|  }
  363|  6.09k|}
_ZN6google8protobuf8internal12ShutdownData3getEv:
  546|     10|  static ShutdownData* get() {
  547|     10|    static auto* data = new ShutdownData;
  548|     10|    return data;
  549|     10|  }

_ZN6google8protobuf8internal18EpsCopyInputStream4NextEv:
  157|    105|const char* EpsCopyInputStream::Next() {
  158|    105|  GOOGLE_DCHECK(limit_ > kSlopBytes);
  ------------------
  |  |  181|    105|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 105]
  |  |  ------------------
  ------------------
  159|    105|  auto p = NextBuffer(0 /* immaterial */, -1);
  160|    105|  if (p == nullptr) {
  ------------------
  |  Branch (160:7): [True: 0, False: 105]
  ------------------
  161|      0|    limit_end_ = buffer_end_;
  162|       |    // Distinguish ending on a pushed limit or ending on end-of-stream.
  163|      0|    SetEndOfStream();
  164|      0|    return nullptr;
  165|      0|  }
  166|    105|  limit_ -= buffer_end_ - p;  // Adjust limit_ relative to new anchor
  167|    105|  limit_end_ = buffer_end_ + std::min(0, limit_);
  168|    105|  return p;
  169|    105|}
_ZN6google8protobuf8internal18EpsCopyInputStream12DoneFallbackEii:
  172|  6.43k|                                                              int depth) {
  173|       |  // Did we exceeded the limit (parse error).
  174|  6.43k|  if (PROTOBUF_PREDICT_FALSE(overrun > limit_)) return {nullptr, true};
  ------------------
  |  |  247|  6.43k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 500, False: 5.93k]
  |  |  ------------------
  ------------------
  175|  5.93k|  GOOGLE_DCHECK(overrun != limit_);  // Guaranteed by caller.
  ------------------
  |  |  181|  6.43k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 5.93k]
  |  |  ------------------
  ------------------
  176|  5.93k|  GOOGLE_DCHECK(overrun < limit_);   // Follows from above
  ------------------
  |  |  181|  5.93k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 5.93k]
  |  |  ------------------
  ------------------
  177|       |  // TODO(gerbens) Instead of this dcheck we could just assign, and remove
  178|       |  // updating the limit_end from PopLimit, ie.
  179|       |  // limit_end_ = buffer_end_ + (std::min)(0, limit_);
  180|       |  // if (ptr < limit_end_) return {ptr, false};
  181|  5.93k|  GOOGLE_DCHECK(limit_end_ == buffer_end_ + (std::min)(0, limit_));
  ------------------
  |  |  181|  5.93k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 5.93k]
  |  |  ------------------
  ------------------
  182|       |  // At this point we know the following assertion holds.
  183|  5.93k|  GOOGLE_DCHECK(limit_ > 0);
  ------------------
  |  |  181|  5.93k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 5.93k]
  |  |  ------------------
  ------------------
  184|  5.93k|  GOOGLE_DCHECK(limit_end_ == buffer_end_);  // because limit_ > 0
  ------------------
  |  |  181|  5.93k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 5.93k]
  |  |  ------------------
  ------------------
  185|  5.93k|  const char* p;
  186|  5.93k|  do {
  187|       |    // We are past the end of buffer_end_, in the slop region.
  188|  5.93k|    GOOGLE_DCHECK(overrun >= 0);
  ------------------
  |  |  181|  5.93k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 5.93k]
  |  |  ------------------
  ------------------
  189|  5.93k|    p = NextBuffer(overrun, depth);
  190|  5.93k|    if (p == nullptr) {
  ------------------
  |  Branch (190:9): [True: 1.44k, False: 4.48k]
  ------------------
  191|       |      // We are at the end of the stream
  192|  1.44k|      if (PROTOBUF_PREDICT_FALSE(overrun != 0)) return {nullptr, true};
  ------------------
  |  |  247|  1.44k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 1.08k, False: 367]
  |  |  ------------------
  ------------------
  193|    367|      GOOGLE_DCHECK(limit_ > 0);
  ------------------
  |  |  181|  1.44k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 367]
  |  |  ------------------
  ------------------
  194|    367|      limit_end_ = buffer_end_;
  195|       |      // Distinguish ending on a pushed limit or ending on end-of-stream.
  196|    367|      SetEndOfStream();
  197|    367|      return {buffer_end_, true};
  198|  1.44k|    }
  199|  4.48k|    limit_ -= buffer_end_ - p;  // Adjust limit_ relative to new anchor
  200|  4.48k|    p += overrun;
  201|  4.48k|    overrun = p - buffer_end_;
  202|  4.48k|  } while (overrun >= 0);
  ------------------
  |  Branch (202:12): [True: 2, False: 4.48k]
  ------------------
  203|  4.48k|  limit_end_ = buffer_end_ + std::min(0, limit_);
  204|  4.48k|  return {p, false};
  205|  5.93k|}
_ZN6google8protobuf8internal18EpsCopyInputStream18ReadStringFallbackEPKciPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  212|    336|                                                   std::string* str) {
  213|    336|  str->clear();
  214|    336|  if (PROTOBUF_PREDICT_TRUE(size <= buffer_end_ - ptr + limit_)) {
  ------------------
  |  |  236|    336|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 144, False: 192]
  |  |  ------------------
  ------------------
  215|       |    // Reserve the string up to a static safe size. If strings are bigger than
  216|       |    // this we proceed by growing the string as needed. This protects against
  217|       |    // malicious payloads making protobuf hold on to a lot of memory.
  218|    144|    str->reserve(str->size() + std::min<int>(size, kSafeStringSize));
  219|    144|  }
  220|    336|  return AppendSize(ptr, size,
  221|    336|                    [str](const char* p, int s) { str->append(p, s); });
  222|    336|}
_ZN6google8protobuf8internal18EpsCopyInputStream20AppendStringFallbackEPKciPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  225|    307|                                                     std::string* str) {
  226|    307|  if (PROTOBUF_PREDICT_TRUE(size <= buffer_end_ - ptr + limit_)) {
  ------------------
  |  |  236|    307|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 109, False: 198]
  |  |  ------------------
  ------------------
  227|       |    // Reserve the string up to a static safe size. If strings are bigger than
  228|       |    // this we proceed by growing the string as needed. This protects against
  229|       |    // malicious payloads making protobuf hold on to a lot of memory.
  230|    109|    str->reserve(str->size() + std::min<int>(size, kSafeStringSize));
  231|    109|  }
  232|    307|  return AppendSize(ptr, size,
  233|    307|                    [str](const char* p, int s) { str->append(p, s); });
  234|    307|}
_ZN6google8protobuf8internal11WriteVarintEjmPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  346|  5.35k|void WriteVarint(uint32 num, uint64 val, std::string* s) {
  347|  5.35k|  WriteVarint(num << 3, s);
  348|  5.35k|  WriteVarint(val, s);
  349|  5.35k|}
_ZN6google8protobuf8internal17VarintParseSlow64EPKcj:
  375|  12.0k|std::pair<const char*, uint64> VarintParseSlow64(const char* p, uint32 res32) {
  376|  12.0k|  uint64 res = res32;
  377|  34.9k|  for (std::uint32_t i = 2; i < 10; i++) {
  ------------------
  |  Branch (377:29): [True: 34.9k, False: 65]
  ------------------
  378|  34.9k|    uint64 byte = static_cast<uint8>(p[i]);
  379|  34.9k|    res += (byte - 1) << (7 * i);
  380|  34.9k|    if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
  ------------------
  |  |  236|  34.9k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 11.9k, False: 22.9k]
  |  |  ------------------
  ------------------
  381|  11.9k|      return {p + i + 1, res};
  382|  11.9k|    }
  383|  34.9k|  }
  384|     65|  return {nullptr, 0};
  385|  12.0k|}
_ZN6google8protobuf8internal15ReadTagFallbackEPKcj:
  387|  7.47k|std::pair<const char*, uint32> ReadTagFallback(const char* p, uint32 res) {
  388|  16.5k|  for (std::uint32_t i = 2; i < 5; i++) {
  ------------------
  |  Branch (388:29): [True: 16.3k, False: 135]
  ------------------
  389|  16.3k|    uint32 byte = static_cast<uint8>(p[i]);
  390|  16.3k|    res += (byte - 1) << (7 * i);
  391|  16.3k|    if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
  ------------------
  |  |  236|  16.3k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 7.34k, False: 9.02k]
  |  |  ------------------
  ------------------
  392|  7.34k|      return {p + i + 1, res};
  393|  7.34k|    }
  394|  16.3k|  }
  395|    135|  return {nullptr, 0};
  396|  7.47k|}
_ZN6google8protobuf8internal16ReadSizeFallbackEPKcj:
  398|  2.50k|std::pair<const char*, int32> ReadSizeFallback(const char* p, uint32 res) {
  399|  4.42k|  for (std::uint32_t i = 1; i < 4; i++) {
  ------------------
  |  Branch (399:29): [True: 4.17k, False: 251]
  ------------------
  400|  4.17k|    uint32 byte = static_cast<uint8>(p[i]);
  401|  4.17k|    res += (byte - 1) << (7 * i);
  402|  4.17k|    if (PROTOBUF_PREDICT_TRUE(byte < 128)) {
  ------------------
  |  |  236|  4.17k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 2.25k, False: 1.92k]
  |  |  ------------------
  ------------------
  403|  2.25k|      return {p + i + 1, res};
  404|  2.25k|    }
  405|  4.17k|  }
  406|    251|  std::uint32_t byte = static_cast<uint8>(p[4]);
  407|    251|  if (PROTOBUF_PREDICT_FALSE(byte >= 8)) return {nullptr, 0};  // size >= 2gb
  ------------------
  |  |  247|    251|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 30, False: 221]
  |  |  ------------------
  ------------------
  408|    221|  res += (byte - 1) << 28;
  409|       |  // Protect against sign integer overflow in PushLimit. Limits are relative
  410|       |  // to buffer ends and ptr could potential be kSlopBytes beyond a buffer end.
  411|       |  // To protect against overflow we reject limits absurdly close to INT_MAX.
  412|    221|  if (PROTOBUF_PREDICT_FALSE(res > INT_MAX - ParseContext::kSlopBytes)) {
  ------------------
  |  |  247|    221|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 3, False: 218]
  |  |  ------------------
  ------------------
  413|      3|    return {nullptr, 0};
  414|      3|  }
  415|    218|  return {p + 5, res};
  416|    221|}
_ZN6google8protobuf8internal24InlineGreedyStringParserEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKcPNS1_12ParseContextE:
  438|   111k|                                     ParseContext* ctx) {
  439|   111k|  int size = ReadSize(&ptr);
  440|   111k|  if (!ptr) return nullptr;
  ------------------
  |  Branch (440:7): [True: 10, False: 111k]
  ------------------
  441|   111k|  return ctx->ReadString(ptr, size, s);
  442|   111k|}
_ZN6google8protobuf8internal17UnknownFieldParseEjPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKcPNS1_12ParseContextE:
  586|   170k|                              ParseContext* ctx) {
  587|   170k|  UnknownFieldLiteParserHelper field_parser(unknown);
  588|   170k|  return FieldParser(tag, field_parser, ptr, ctx);
  589|   170k|}
_ZN6google8protobuf8internal18EpsCopyInputStream10NextBufferEii:
  102|  6.03k|const char* EpsCopyInputStream::NextBuffer(int overrun, int depth) {
  103|  6.03k|  if (next_chunk_ == nullptr) return nullptr;  // We've reached end of stream.
  ------------------
  |  Branch (103:7): [True: 1.44k, False: 4.59k]
  ------------------
  104|  4.59k|  if (next_chunk_ != buffer_) {
  ------------------
  |  Branch (104:7): [True: 0, False: 4.59k]
  ------------------
  105|      0|    GOOGLE_DCHECK(size_ > kSlopBytes);
  ------------------
  |  |  181|      0|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 0]
  |  |  ------------------
  ------------------
  106|       |    // The chunk is large enough to be used directly
  107|      0|    buffer_end_ = next_chunk_ + size_ - kSlopBytes;
  108|      0|    auto res = next_chunk_;
  109|      0|    next_chunk_ = buffer_;
  110|      0|    if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
  ------------------
  |  Branch (110:9): [True: 0, False: 0]
  ------------------
  111|      0|    return res;
  112|      0|  }
  113|       |  // Move the slop bytes of previous buffer to start of the patch buffer.
  114|       |  // Note we must use memmove because the previous buffer could be part of
  115|       |  // buffer_.
  116|  4.59k|  std::memmove(buffer_, buffer_end_, kSlopBytes);
  117|  4.59k|  if (overall_limit_ > 0 &&
  ------------------
  |  Branch (117:7): [True: 0, False: 4.59k]
  ------------------
  118|      0|      (depth < 0 || !ParseEndsInSlopRegion(buffer_, overrun, depth))) {
  ------------------
  |  Branch (118:8): [True: 0, False: 0]
  |  Branch (118:21): [True: 0, False: 0]
  ------------------
  119|      0|    const void* data;
  120|       |    // ZeroCopyInputStream indicates Next may return 0 size buffers. Hence
  121|       |    // we loop.
  122|      0|    while (StreamNext(&data)) {
  ------------------
  |  Branch (122:12): [True: 0, False: 0]
  ------------------
  123|      0|      if (size_ > kSlopBytes) {
  ------------------
  |  Branch (123:11): [True: 0, False: 0]
  ------------------
  124|       |        // We got a large chunk
  125|      0|        std::memcpy(buffer_ + kSlopBytes, data, kSlopBytes);
  126|      0|        next_chunk_ = static_cast<const char*>(data);
  127|      0|        buffer_end_ = buffer_ + kSlopBytes;
  128|      0|        if (aliasing_ >= kNoDelta) aliasing_ = kOnPatch;
  ------------------
  |  Branch (128:13): [True: 0, False: 0]
  ------------------
  129|      0|        return buffer_;
  130|      0|      } else if (size_ > 0) {
  ------------------
  |  Branch (130:18): [True: 0, False: 0]
  ------------------
  131|      0|        std::memcpy(buffer_ + kSlopBytes, data, size_);
  132|      0|        next_chunk_ = buffer_;
  133|      0|        buffer_end_ = buffer_ + size_;
  134|      0|        if (aliasing_ >= kNoDelta) aliasing_ = kOnPatch;
  ------------------
  |  Branch (134:13): [True: 0, False: 0]
  ------------------
  135|      0|        return buffer_;
  136|      0|      }
  137|      0|      GOOGLE_DCHECK(size_ == 0) << size_;
  ------------------
  |  |  181|      0|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 0]
  |  |  ------------------
  ------------------
  138|      0|    }
  139|      0|    overall_limit_ = 0;  // Next failed, no more needs for next
  140|      0|  }
  141|       |  // End of stream or array
  142|  4.59k|  if (aliasing_ == kNoDelta) {
  ------------------
  |  Branch (142:7): [True: 0, False: 4.59k]
  ------------------
  143|       |    // If there is no more block and aliasing is true, the previous block
  144|       |    // is still valid and we can alias. We have users relying on string_view's
  145|       |    // obtained from protos to outlive the proto, when the parse was from an
  146|       |    // array. This guarantees string_view's are always aliased if parsed from
  147|       |    // an array.
  148|      0|    aliasing_ = reinterpret_cast<std::uintptr_t>(buffer_end_) -
  149|      0|                reinterpret_cast<std::uintptr_t>(buffer_);
  150|      0|  }
  151|  4.59k|  next_chunk_ = nullptr;
  152|  4.59k|  buffer_end_ = buffer_ + kSlopBytes;
  153|  4.59k|  size_ = 0;
  154|  4.59k|  return buffer_;
  155|  4.59k|}
_ZN6google8protobuf8internal11WriteVarintEmPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  337|   376k|inline void WriteVarint(uint64 val, std::string* s) {
  338|   428k|  while (val >= 128) {
  ------------------
  |  Branch (338:10): [True: 51.4k, False: 376k]
  ------------------
  339|  51.4k|    uint8 c = val | 0x80;
  340|  51.4k|    s->push_back(c);
  341|  51.4k|    val >>= 7;
  342|  51.4k|  }
  343|   376k|  s->push_back(val);
  344|   376k|}
_ZN6google8protobuf8internal28UnknownFieldLiteParserHelperC2EPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  531|   170k|      : unknown_(unknown) {}
parse_context.cc:_ZZN6google8protobuf8internal18EpsCopyInputStream18ReadStringFallbackEPKciPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEENK3$_0clES4_i:
  221|    120|                    [str](const char* p, int s) { str->append(p, s); });
parse_context.cc:_ZZN6google8protobuf8internal18EpsCopyInputStream20AppendStringFallbackEPKciPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEENK3$_0clES4_i:
  233|     95|                    [str](const char* p, int s) { str->append(p, s); });
_ZN6google8protobuf8internal28UnknownFieldLiteParserHelper9AddVarintEjm:
  533|   166k|  void AddVarint(uint32 num, uint64 value) {
  534|   166k|    if (unknown_ == nullptr) return;
  ------------------
  |  Branch (534:9): [True: 0, False: 166k]
  ------------------
  535|   166k|    WriteVarint(num * 8, unknown_);
  536|   166k|    WriteVarint(value, unknown_);
  537|   166k|  }
_ZN6google8protobuf8internal28UnknownFieldLiteParserHelper10AddFixed64Ejm:
  538|  10.2k|  void AddFixed64(uint32 num, uint64 value) {
  539|  10.2k|    if (unknown_ == nullptr) return;
  ------------------
  |  Branch (539:9): [True: 0, False: 10.2k]
  ------------------
  540|  10.2k|    WriteVarint(num * 8 + 1, unknown_);
  541|  10.2k|    char buffer[8];
  542|  10.2k|    io::CodedOutputStream::WriteLittleEndian64ToArray(
  543|  10.2k|        value, reinterpret_cast<uint8*>(buffer));
  544|  10.2k|    unknown_->append(buffer, 8);
  545|  10.2k|  }
_ZN6google8protobuf8internal28UnknownFieldLiteParserHelper20ParseLengthDelimitedEjPKcPNS1_12ParseContextE:
  547|  3.70k|                                   ParseContext* ctx) {
  548|  3.70k|    int size = ReadSize(&ptr);
  549|  3.70k|    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
  ------------------
  |  |  724|  3.70k|  GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
  |  |  ------------------
  |  |  |  |  717|  3.70k|  if (!(predicate)) {                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (717:7): [True: 13, False: 3.69k]
  |  |  |  |  ------------------
  |  |  |  |  718|     13|    /*  ::raise(SIGINT);  */                           \
  |  |  |  |  719|     13|    /*  GOOGLE_LOG(ERROR) << "Parse failure";  */             \
  |  |  |  |  720|     13|    return ret;                                        \
  |  |  |  |  721|     13|  }
  |  |  ------------------
  ------------------
  550|  3.69k|    if (unknown_ == nullptr) return ctx->Skip(ptr, size);
  ------------------
  |  Branch (550:9): [True: 0, False: 3.69k]
  ------------------
  551|  3.69k|    WriteVarint(num * 8 + 2, unknown_);
  552|  3.69k|    WriteVarint(size, unknown_);
  553|  3.69k|    return ctx->AppendString(ptr, size, unknown_);
  554|  3.69k|  }
_ZN6google8protobuf8internal28UnknownFieldLiteParserHelper10ParseGroupEjPKcPNS1_12ParseContextE:
  555|  3.51k|  const char* ParseGroup(uint32 num, const char* ptr, ParseContext* ctx) {
  556|  3.51k|    if (unknown_) WriteVarint(num * 8 + 3, unknown_);
  ------------------
  |  Branch (556:9): [True: 3.51k, False: 0]
  ------------------
  557|  3.51k|    ptr = ctx->ParseGroup(this, ptr, num * 8 + 3);
  558|  3.51k|    GOOGLE_PROTOBUF_PARSER_ASSERT(ptr);
  ------------------
  |  |  724|  3.51k|  GOOGLE_PROTOBUF_ASSERT_RETURN(predicate, nullptr)
  |  |  ------------------
  |  |  |  |  717|  3.51k|  if (!(predicate)) {                                  \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (717:7): [True: 3.17k, False: 338]
  |  |  |  |  ------------------
  |  |  |  |  718|  3.17k|    /*  ::raise(SIGINT);  */                           \
  |  |  |  |  719|  3.17k|    /*  GOOGLE_LOG(ERROR) << "Parse failure";  */             \
  |  |  |  |  720|  3.17k|    return ret;                                        \
  |  |  |  |  721|  3.17k|  }
  |  |  ------------------
  ------------------
  559|    338|    if (unknown_) WriteVarint(num * 8 + 4, unknown_);
  ------------------
  |  Branch (559:9): [True: 338, False: 0]
  ------------------
  560|    338|    return ptr;
  561|  3.51k|  }
_ZN6google8protobuf8internal28UnknownFieldLiteParserHelper14_InternalParseEPKcPNS1_12ParseContextE:
  571|  3.51k|  const char* _InternalParse(const char* ptr, ParseContext* ctx) {
  572|  3.51k|    return WireFormatParser(*this, ptr, ctx);
  573|  3.51k|  }
_ZN6google8protobuf8internal28UnknownFieldLiteParserHelper10AddFixed32Ejj:
  562|  12.5k|  void AddFixed32(uint32 num, uint32 value) {
  563|  12.5k|    if (unknown_ == nullptr) return;
  ------------------
  |  Branch (563:9): [True: 0, False: 12.5k]
  ------------------
  564|  12.5k|    WriteVarint(num * 8 + 5, unknown_);
  565|  12.5k|    char buffer[4];
  566|  12.5k|    io::CodedOutputStream::WriteLittleEndian32ToArray(
  567|  12.5k|        value, reinterpret_cast<uint8*>(buffer));
  568|  12.5k|    unknown_->append(buffer, 4);
  569|  12.5k|  }

_ZN6google8protobuf8internal20RepeatedPtrFieldBase14InternalExtendEi:
   50|  50.3k|void** RepeatedPtrFieldBase::InternalExtend(int extend_amount) {
   51|  50.3k|  int new_size = current_size_ + extend_amount;
   52|  50.3k|  if (total_size_ >= new_size) {
  ------------------
  |  Branch (52:7): [True: 0, False: 50.3k]
  ------------------
   53|       |    // N.B.: rep_ is non-NULL because extend_amount is always > 0, hence
   54|       |    // total_size must be non-zero since it is lower-bounded by new_size.
   55|      0|    return &rep_->elements[current_size_];
   56|      0|  }
   57|  50.3k|  Rep* old_rep = rep_;
   58|  50.3k|  Arena* arena = GetArena();
   59|  50.3k|  new_size = std::max(internal::kRepeatedFieldLowerClampLimit,
   60|  50.3k|                      std::max(total_size_ * 2, new_size));
   61|  50.3k|  GOOGLE_CHECK_LE(new_size, (std::numeric_limits<size_t>::max() - kRepHeaderSize) /
  ------------------
  |  |  159|      0|#define GOOGLE_CHECK_LE(A, B) GOOGLE_CHECK((A) <= (B))
  |  |  ------------------
  |  |  |  |  154|  50.3k|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|  50.3k|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 50.3k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   62|      0|                         sizeof(old_rep->elements[0]))
   63|      0|      << "Requested size is too large to fit into size_t.";
   64|  50.3k|  size_t bytes = kRepHeaderSize + sizeof(old_rep->elements[0]) * new_size;
   65|  50.3k|  if (arena == NULL) {
  ------------------
  |  Branch (65:7): [True: 50.3k, False: 0]
  ------------------
   66|  50.3k|    rep_ = reinterpret_cast<Rep*>(::operator new(bytes));
   67|  50.3k|  } else {
   68|      0|    rep_ = reinterpret_cast<Rep*>(Arena::CreateArray<char>(arena, bytes));
   69|      0|  }
   70|  50.3k|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
   71|  50.3k|  const int old_total_size = total_size_;
   72|  50.3k|#endif
   73|  50.3k|  total_size_ = new_size;
   74|  50.3k|  if (old_rep && old_rep->allocated_size > 0) {
  ------------------
  |  Branch (74:7): [True: 29.8k, False: 20.5k]
  |  Branch (74:18): [True: 29.8k, False: 0]
  ------------------
   75|  29.8k|    memcpy(rep_->elements, old_rep->elements,
   76|  29.8k|           old_rep->allocated_size * sizeof(rep_->elements[0]));
   77|  29.8k|    rep_->allocated_size = old_rep->allocated_size;
   78|  29.8k|  } else {
   79|  20.5k|    rep_->allocated_size = 0;
   80|  20.5k|  }
   81|  50.3k|  if (arena == NULL) {
  ------------------
  |  Branch (81:7): [True: 50.3k, False: 0]
  ------------------
   82|  50.3k|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
   83|  50.3k|    const size_t old_size =
   84|  50.3k|        old_total_size * sizeof(rep_->elements[0]) + kRepHeaderSize;
   85|  50.3k|    ::operator delete(static_cast<void*>(old_rep), old_size);
   86|       |#else
   87|       |    ::operator delete(static_cast<void*>(old_rep));
   88|       |#endif
   89|  50.3k|  }
   90|  50.3k|  return &rep_->elements[current_size_];
   91|  50.3k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7ReserveEi:
   93|  50.3k|void RepeatedPtrFieldBase::Reserve(int new_size) {
   94|  50.3k|  if (new_size > current_size_) {
  ------------------
  |  Branch (94:7): [True: 50.3k, False: 0]
  ------------------
   95|  50.3k|    InternalExtend(new_size - current_size_);
   96|  50.3k|  }
   97|  50.3k|}

_ZN6google8protobuf4util6StatusC2Ev:
   89|      2|Status::Status() : error_code_(error::OK) {
   90|      2|}
_ZN6google8protobuf4util6StatusC2ENS1_5error4CodeENS0_11StringPieceE:
   93|      4|    : error_code_(error_code) {
   94|      4|  if (error_code != error::OK) {
  ------------------
  |  Branch (94:7): [True: 4, False: 0]
  ------------------
   95|      4|    error_message_ = error_message.ToString();
   96|      4|  }
   97|      4|}

structurally_valid.cc:_ZN6google8protobuf8internal12_GLOBAL__N_112InitDetectorC2Ev:
  547|      2|  InitDetector() {
  548|      2|    module_initialized_ = true;
  549|      2|  }