_ZNK13sentencepiece3bpe7Trainer6Symbol8ToStringEv:
   38|  1.08M|std::string Trainer::Symbol::ToString() const {
   39|  1.08M|  return string_util::UnicodeTextToUTF8(chars);
   40|  1.08M|}
_ZN13sentencepiece3bpe7Trainer13GetCharSymbolEj:
   42|  1.38M|Trainer::Symbol* Trainer::GetCharSymbol(char32 c) {
   43|  1.38M|  const uint64_t freq = port::FindWithDefault(required_chars_, c, 1);
   44|  1.38M|  CHECK_GT(freq, 0);
  ------------------
  |  |  128|  1.38M|  ABSL_LOG_INTERNAL_CHECK_GT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   59|  1.38M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_GT, >, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  1.38M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 1.38M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  1.38M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  1.38M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  1.38M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  1.38M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  1.38M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  1.38M|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   45|  1.38M|  const auto it = symbols_cache_.find(c);
   46|  1.38M|  if (it != symbols_cache_.end()) {
  ------------------
  |  Branch (46:7): [True: 1.35M, False: 36.4k]
  ------------------
   47|  1.35M|    return it->second;
   48|  1.35M|  }
   49|  36.4k|  Symbol* s = new Symbol;
   50|  36.4k|  allocated_.push_back(s);
   51|  36.4k|  s->is_unk = (kUNKChar == c);
   52|  36.4k|  s->fp = c;
   53|  36.4k|  s->chars.push_back(c);
   54|  36.4k|  s->freq = freq;
   55|  36.4k|  port::InsertOrDie(&symbols_cache_, s->fp, s);
   56|  36.4k|  return s;
   57|  1.38M|}
_ZN13sentencepiece3bpe7Trainer13GetPairSymbolEPKNS1_6SymbolES4_:
   60|  4.14M|                                        const Symbol* right) {
   61|  4.14M|  if (left == nullptr || right == nullptr || left->is_unk || right->is_unk) {
  ------------------
  |  Branch (61:7): [True: 0, False: 4.14M]
  |  Branch (61:26): [True: 0, False: 4.14M]
  |  Branch (61:46): [True: 96.8k, False: 4.04M]
  |  Branch (61:62): [True: 38.9k, False: 4.00M]
  ------------------
   62|   135k|    return nullptr;
   63|   135k|  }
   64|       |
   65|  4.00M|  const uint64_t fp = absl::HashOf(left->fp, right->fp);
   66|  4.00M|  const auto it = symbols_cache_.find(fp);
   67|  4.00M|  if (it != symbols_cache_.end()) {
  ------------------
  |  Branch (67:7): [True: 3.45M, False: 556k]
  ------------------
   68|  3.45M|    return it->second;
   69|  3.45M|  }
   70|       |
   71|   556k|  CHECK(!left->chars.empty());
  ------------------
  |  |   58|  4.00M|#define CHECK(condition) ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   27|  1.67M|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  180|   556k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  1.11M|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  1.11M|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 556k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|   556k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 556k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  1.11M|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 556k, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 556k]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 556k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  1.67M|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |   29|  1.67M|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   72|   556k|  CHECK(!right->chars.empty());
  ------------------
  |  |   58|   556k|#define CHECK(condition) ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   27|  1.67M|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  180|   556k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  1.11M|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  1.11M|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 556k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|   556k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 556k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  1.11M|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 556k, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 556k]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 556k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  1.67M|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |   29|  1.67M|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   73|   556k|  string_util::UnicodeText ut;
   74|  1.93M|  for (const char32 c : left->chars) ut.push_back(c);
  ------------------
  |  Branch (74:23): [True: 1.93M, False: 556k]
  ------------------
   75|  1.85M|  for (const char32 c : right->chars) ut.push_back(c);
  ------------------
  |  Branch (75:23): [True: 1.85M, False: 556k]
  ------------------
   76|       |
   77|       |  // Do not make an invalid piece.
   78|   556k|  if (!IsValidSentencePiece(ut)) {
  ------------------
  |  Branch (78:7): [True: 233k, False: 323k]
  ------------------
   79|   233k|    return nullptr;
   80|   233k|  }
   81|       |
   82|   323k|  Symbol* s = new Symbol;
   83|   323k|  allocated_.push_back(s);
   84|   323k|  s->fp = fp;
   85|   323k|  s->left = left;
   86|   323k|  s->right = right;
   87|   323k|  s->chars = ut;
   88|   323k|  port::InsertOrDie(&symbols_cache_, s->fp, s);
   89|   323k|  return s;
   90|   556k|}
_ZNK13sentencepiece3bpe7Trainer11ComputeFreqEPNS1_6SymbolE:
   92|  9.76M|void Trainer::ComputeFreq(Symbol* symbol) const {
   93|  9.76M|  if (symbol->freq > 0) {  // if freq == 0, re-computation is required.
  ------------------
  |  Branch (93:7): [True: 7.12M, False: 2.63M]
  ------------------
   94|  7.12M|    return;
   95|  7.12M|  }
   96|  2.63M|  CHECK_EQ(0, symbol->freq);
  ------------------
  |  |  118|  2.63M|  ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   49|  2.63M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  2.63M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 2.63M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  2.63M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  2.63M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  2.63M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  2.63M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  2.63M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  2.63M|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   97|  7.02M|  for (auto it = symbol->positions.begin(); it != symbol->positions.end();) {
  ------------------
  |  Branch (97:45): [True: 4.39M, False: 2.63M]
  ------------------
   98|  4.39M|    const Position pos = DecodePos(*it);
   99|       |    // symbols_[sid][left] and symbols_[sid]right] must store
  100|       |    // the same symbols in symbol->left and symbols->right.
  101|  4.39M|    if (symbol->left != symbols_[pos.sid][pos.left] ||
  ------------------
  |  Branch (101:9): [True: 344k, False: 4.04M]
  ------------------
  102|  4.04M|        symbol->right != symbols_[pos.sid][pos.right]) {
  ------------------
  |  Branch (102:9): [True: 636k, False: 3.40M]
  ------------------
  103|   981k|      it = symbol->positions.erase(it);
  104|  3.40M|    } else {
  105|  3.40M|      symbol->freq += sentences_[pos.sid].second;
  106|  3.40M|      ++it;
  107|  3.40M|    }
  108|  4.39M|  }
  109|  2.63M|}
_ZNK13sentencepiece3bpe7Trainer12GetNextIndexEii:
  111|   724k|int Trainer::GetNextIndex(int sid, int index) const {
  112|  1.23M|  for (size_t i = index + 1; i < symbols_[sid].size(); ++i) {
  ------------------
  |  Branch (112:30): [True: 1.21M, False: 19.0k]
  ------------------
  113|  1.21M|    if (symbols_[sid][i] == nullptr) continue;
  ------------------
  |  Branch (113:9): [True: 513k, False: 705k]
  ------------------
  114|   705k|    return i;
  115|  1.21M|  }
  116|  19.0k|  return -1;
  117|   724k|}
_ZNK13sentencepiece3bpe7Trainer12GetPrevIndexEii:
  119|   724k|int Trainer::GetPrevIndex(int sid, int index) const {
  120|  1.95M|  for (int i = index - 1; i >= 0; --i) {
  ------------------
  |  Branch (120:27): [True: 1.93M, False: 13.9k]
  ------------------
  121|  1.93M|    if (symbols_[sid][i] == nullptr) continue;
  ------------------
  |  Branch (121:9): [True: 1.22M, False: 710k]
  ------------------
  122|   710k|    return i;
  123|  1.93M|  }
  124|  13.9k|  return -1;
  125|   724k|}
_ZN13sentencepiece3bpe7Trainer10AddNewPairEiii:
  127|  2.76M|void Trainer::AddNewPair(int sid, int left, int right) {
  128|  2.76M|  if (left == -1 || right == -1) return;
  ------------------
  |  Branch (128:7): [True: 13.9k, False: 2.74M]
  |  Branch (128:21): [True: 19.0k, False: 2.72M]
  ------------------
  129|  2.72M|  auto* symbol = GetPairSymbol(symbols_[sid][left], symbols_[sid][right]);
  130|  2.72M|  if (symbol != nullptr) {
  ------------------
  |  Branch (130:7): [True: 2.46M, False: 260k]
  ------------------
  131|  2.46M|    active_symbols_.insert(symbol);
  132|  2.46M|    symbol->positions.insert(EncodePos(sid, left, right));
  133|  2.46M|  }
  134|  2.72M|}
_ZN13sentencepiece3bpe7Trainer9ResetFreqEiiiPKNS1_6SymbolE:
  136|  1.44M|void Trainer::ResetFreq(int sid, int left, int right, const Symbol* best) {
  137|  1.44M|  if (left == -1 || right == -1) return;
  ------------------
  |  Branch (137:7): [True: 13.9k, False: 1.43M]
  |  Branch (137:21): [True: 19.0k, False: 1.41M]
  ------------------
  138|  1.41M|  auto* symbol = GetPairSymbol(symbols_[sid][left], symbols_[sid][right]);
  139|  1.41M|  if (symbol != nullptr && symbol != best) {
  ------------------
  |  Branch (139:7): [True: 1.30M, False: 108k]
  |  Branch (139:28): [True: 993k, False: 313k]
  ------------------
  140|   993k|    symbol->freq = 0;
  141|   993k|  }
  142|  1.41M|}
_ZN13sentencepiece3bpe7Trainer12AcceptSymbolEPNS1_6SymbolE:
  144|  56.8k|util::Status Trainer::AcceptSymbol(Symbol* symbol) {
  145|       |  // Add new bigrams which are created after symbol replacement.
  146|       |  // We do not need to scan all characters, but scan the neighbors in
  147|       |  // best_symbol.
  148|  1.03M|  for (const uint64_t& encoded_pos : symbol->positions) {
  ------------------
  |  Branch (148:36): [True: 1.03M, False: 56.8k]
  ------------------
  149|  1.03M|    const Position pos = DecodePos(encoded_pos);
  150|       |
  151|  1.03M|    if (symbols_[pos.sid][pos.left] == nullptr) {
  ------------------
  |  Branch (151:9): [True: 313k, False: 724k]
  ------------------
  152|       |      // left index might be NULL (set in the previous iteration)
  153|       |      // when left_symbol == right_symbol.
  154|   313k|      continue;
  155|   313k|    }
  156|   724k|    RET_CHECK(symbols_[pos.sid][pos.right]);
  ------------------
  |  |  321|   724k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 724k, False: 0]
  |  |  ------------------
  |  |  322|   724k|  } else /* NOLINT */                                        \
  |  |  323|   724k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  157|       |
  158|       |    // We have three bigrams [prev, left], [left, right], [right, next],
  159|       |    // which are affected with this symbol replacement.
  160|   724k|    const int next = GetNextIndex(pos.sid, pos.right);
  161|   724k|    const int prev = GetPrevIndex(pos.sid, pos.left);
  162|       |
  163|       |    // Resets the frequencies of bigrams [prev, left] and [right, next].
  164|   724k|    ResetFreq(pos.sid, prev, pos.left, symbol);
  165|   724k|    ResetFreq(pos.sid, pos.right, next, symbol);
  166|       |
  167|       |    // Merges two symbols.
  168|   724k|    symbols_[pos.sid][pos.left] = symbol;
  169|   724k|    symbols_[pos.sid][pos.right] = nullptr;
  170|       |
  171|       |    // Makes new symbol bigrams [prev, left] and [left, next].
  172|   724k|    AddNewPair(pos.sid, prev, pos.left);
  173|   724k|    AddNewPair(pos.sid, pos.left, next);
  174|   724k|  }
  175|       |
  176|       |  // Removes best_symbol so it is not selected again.
  177|  56.8k|  symbols_cache_.erase(symbol->fp);
  178|  56.8k|  active_symbols_.erase(symbol);
  179|       |
  180|  56.8k|  return util::OkStatus();
  181|  56.8k|}
_ZN13sentencepiece3bpe7Trainer19UpdateActiveSymbolsEv:
  183|  1.78k|void Trainer::UpdateActiveSymbols() {
  184|  1.78k|  std::vector<Symbol*> symbols;
  185|   137k|  for (auto& it : symbols_cache_) {
  ------------------
  |  Branch (185:17): [True: 137k, False: 1.78k]
  ------------------
  186|   137k|    Symbol* symbol = it.second;
  187|   137k|    if (symbol->IsBigram()) {
  ------------------
  |  Branch (187:9): [True: 101k, False: 35.9k]
  ------------------
  188|   101k|      ComputeFreq(symbol);
  189|   101k|      symbols.push_back(symbol);
  190|   101k|    }
  191|   137k|  }
  192|       |
  193|       |  // At least kMinActiveSymbolsSize symbols must be in |active_symbols_|.
  194|  1.78k|  constexpr int kMinActiveSymbolsSize = 1000;
  195|       |
  196|       |  // Keeps top 5% frequent symbols.
  197|  1.78k|  constexpr float kTopFrequentRatio = 0.05;
  198|  1.78k|  const int size =
  199|  1.78k|      std::min<int>(std::max<int>(kMinActiveSymbolsSize,
  200|  1.78k|                                  symbols_cache_.size() * kTopFrequentRatio),
  201|  1.78k|                    symbols.size());
  202|       |
  203|  1.78k|  if (size > 0) {
  ------------------
  |  Branch (203:7): [True: 1.75k, False: 28]
  ------------------
  204|  1.75k|    std::partial_sort(
  205|  1.75k|        symbols.begin(), symbols.begin() + size, symbols.end(),
  206|  1.75k|        [](Symbol* s1, Symbol* s2) { return s1->freq > s2->freq; });
  207|  5.26k|    LOG(INFO) << "Updating active symbols. max_freq=" << symbols.front()->freq
  ------------------
  |  |  218|  1.75k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  1.75k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  1.75k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  3.51k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  3.51k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1.75k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  1.75k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1.75k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  1.75k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 1.75k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  1.75k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  8.77k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  8.77k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  208|  5.26k|              << " min_freq=" << symbols.back()->freq;
  209|  1.75k|  }
  210|       |
  211|  1.78k|  active_symbols_.clear();
  212|  1.78k|  active_symbols_.insert(symbols.begin(), symbols.begin() + size);
  213|  1.78k|}
_ZN13sentencepiece3bpe7Trainer5TrainEv:
  215|  1.81k|util::Status Trainer::Train() {
  216|  1.81k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  1.81k|  do {                                 \
  |  |   45|  1.81k|    const auto _status = expr;         \
  |  |   46|  1.81k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 1, False: 1.81k]
  |  |  ------------------
  |  |   47|  1.81k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 1.81k]
  |  |  ------------------
  ------------------
  217|       |
  218|       |#ifdef SPM_NLCODEC_BPE
  219|       |  if (absl::GetFlag(FLAGS_nlcodec_bpe)) {
  220|       |    return TrainFast();
  221|       |  }
  222|       |#endif  // SPM_NLCODEC_BPE
  223|       |
  224|  1.81k|  RET_CHECK(normalizer_spec_.escape_whitespaces());
  ------------------
  |  |  321|  1.81k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 1.81k, False: 0]
  |  |  ------------------
  |  |  322|  1.81k|  } else /* NOLINT */                                        \
  |  |  323|  1.81k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  225|  1.81k|  RET_CHECK_EQ(TrainerSpec::BPE, trainer_spec_.model_type());
  ------------------
  |  |  327|  1.81k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|  1.81k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 1.81k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  1.81k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  1.81k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  226|       |
  227|  1.81k|  symbols_.clear();
  228|  1.81k|  allocated_.clear();
  229|  1.81k|  symbols_cache_.clear();
  230|  1.81k|  active_symbols_.clear();
  231|       |
  232|       |  // Load all sentences
  233|  1.81k|  RETURN_IF_ERROR(LoadSentences());
  ------------------
  |  |   44|  1.81k|  do {                                 \
  |  |   45|  1.81k|    const auto _status = expr;         \
  |  |   46|  1.81k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 20, False: 1.79k]
  |  |  ------------------
  |  |   47|  1.81k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 1.79k]
  |  |  ------------------
  ------------------
  234|       |
  235|  1.79k|  if (trainer_spec_.split_by_whitespace()) {
  ------------------
  |  Branch (235:7): [True: 1.47k, False: 315]
  ------------------
  236|  1.47k|    SplitSentencesByWhitespace();
  237|  1.47k|  }
  238|       |
  239|       |  // Pretokenizer applied only in training time.
  240|       |  // Pretokenizer is used as a constraint of piece extractions.
  241|  1.79k|  const auto* pretokenizer = SentencePieceTrainer::GetPretokenizerForTraining();
  242|       |
  243|  1.79k|  if (pretokenizer || !trainer_spec_.pretokenization_delimiter().empty()) {
  ------------------
  |  Branch (243:7): [True: 0, False: 1.79k]
  |  Branch (243:23): [True: 0, False: 1.79k]
  ------------------
  244|      0|    absl::string_view delimiter = trainer_spec_.pretokenization_delimiter();
  245|      0|    LOG(INFO) << "Preprocessing with pretokenizer...";
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  246|      0|    for (auto& w : sentences_) {
  ------------------
  |  Branch (246:18): [True: 0, False: 0]
  ------------------
  247|      0|      if (pretokenizer) {
  ------------------
  |  Branch (247:11): [True: 0, False: 0]
  ------------------
  248|      0|        w.first = absl::StrJoin(pretokenizer->PreTokenize(w.first),
  249|      0|                                TrainerInterface::kUPPBoundaryStr);
  250|      0|      } else if (!delimiter.empty()) {
  ------------------
  |  Branch (250:18): [True: 0, False: 0]
  ------------------
  251|      0|        w.first = absl::StrReplaceAll(
  252|      0|            w.first, {{delimiter, TrainerInterface::kUPPBoundaryStr}});
  253|      0|      }
  254|      0|    }
  255|      0|  }
  256|       |
  257|       |  // Initializes symbols_. symbols_[sid][i] stores an unary symbol.
  258|  1.79k|  symbols_.resize(sentences_.size());
  259|  42.9k|  for (size_t i = 0; i < sentences_.size(); ++i) {
  ------------------
  |  Branch (259:22): [True: 41.1k, False: 1.79k]
  ------------------
  260|  1.35M|    for (const char32 c : string_util::UTF8ToUnicodeText(sentences_[i].first)) {
  ------------------
  |  Branch (260:25): [True: 1.35M, False: 41.1k]
  ------------------
  261|  1.35M|      symbols_[i].push_back(GetCharSymbol(c));
  262|  1.35M|    }
  263|  41.1k|  }
  264|       |
  265|       |  // Makes all bigram symbols.
  266|  42.9k|  for (size_t sid = 0; sid < symbols_.size(); ++sid) {
  ------------------
  |  Branch (266:24): [True: 41.1k, False: 1.79k]
  ------------------
  267|  1.35M|    for (size_t i = 1; i < symbols_[sid].size(); ++i) {
  ------------------
  |  Branch (267:24): [True: 1.31M, False: 41.1k]
  ------------------
  268|  1.31M|      AddNewPair(sid, i - 1, i);
  269|  1.31M|    }
  270|  41.1k|  }
  271|       |
  272|  1.79k|  const int vocab_size =
  273|  1.79k|      trainer_spec_.vocab_size() - meta_pieces_.size() - required_chars_.size();
  274|  1.79k|  RET_CHECK_GE(vocab_size, 0);
  ------------------
  |  |  329|  1.79k|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  321|  1.79k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 1.79k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  1.79k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  1.79k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  275|       |
  276|       |  // We may see duplicated pieces that are extracted with different path.
  277|       |  // In real segmentation phase, we can consider them as one symbol.
  278|       |  // e.g., "aaa" => "aa" + "a" or "a" + "aa".
  279|  1.79k|  absl::flat_hash_set<std::string> dup;
  280|       |
  281|       |  // Main loop.
  282|  1.79k|  RET_CHECK(final_pieces_.empty());
  ------------------
  |  |  321|  1.79k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 1.79k, False: 0]
  |  |  ------------------
  |  |  322|  1.79k|  } else /* NOLINT */                                        \
  |  |  323|  1.79k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  283|  58.6k|  while (final_pieces_.size() < static_cast<size_t>(vocab_size)) {
  ------------------
  |  Branch (283:10): [True: 57.5k, False: 1.10k]
  ------------------
  284|  57.5k|    constexpr int kUpdateActiveSymbolsInterval = 100;
  285|  57.5k|    if (final_pieces_.size() % kUpdateActiveSymbolsInterval == 0) {
  ------------------
  |  Branch (285:9): [True: 1.78k, False: 55.7k]
  ------------------
  286|  1.78k|      UpdateActiveSymbols();
  287|  1.78k|    }
  288|       |
  289|       |    // Scanning active symbols, finds the best_symbol with highest freq.
  290|  57.5k|    Symbol* best_symbol = nullptr;
  291|  9.66M|    for (auto& it : active_symbols_) {
  ------------------
  |  Branch (291:19): [True: 9.66M, False: 57.5k]
  ------------------
  292|  9.66M|      Symbol* symbol = it;
  293|  9.66M|      ComputeFreq(symbol);
  294|       |      // If the frequency is the same, take shorter symbol.
  295|       |      // if the length is the same, use lexicographical comparison
  296|  9.66M|      if (best_symbol == nullptr ||
  ------------------
  |  Branch (296:11): [True: 56.8k, False: 9.60M]
  |  Branch (296:11): [True: 245k, False: 9.41M]
  ------------------
  297|  9.60M|          (symbol->freq > best_symbol->freq ||
  ------------------
  |  Branch (297:12): [True: 70.5k, False: 9.53M]
  ------------------
  298|  9.53M|           (symbol->freq == best_symbol->freq &&
  ------------------
  |  Branch (298:13): [True: 1.24M, False: 8.28M]
  ------------------
  299|  1.24M|            (symbol->chars.size() < best_symbol->chars.size() ||
  ------------------
  |  Branch (299:14): [True: 28.9k, False: 1.21M]
  ------------------
  300|  1.21M|             (symbol->chars.size() == best_symbol->chars.size() &&
  ------------------
  |  Branch (300:15): [True: 467k, False: 748k]
  ------------------
  301|   467k|              symbol->ToString() < best_symbol->ToString()))))) {
  ------------------
  |  Branch (301:15): [True: 88.8k, False: 378k]
  ------------------
  302|   245k|        best_symbol = symbol;
  303|   245k|      }
  304|  9.66M|    }
  305|       |
  306|  57.5k|    if (best_symbol == nullptr) {
  ------------------
  |  Branch (306:9): [True: 685, False: 56.8k]
  ------------------
  307|  2.05k|      LOG(WARNING) << "No valid symbol found";
  ------------------
  |  |  218|    685|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|    685|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  174|    685|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  1.37k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  1.37k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 685, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|    685|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 685]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|    685|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 685]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|    685|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|  1.37k|  ::absl::log_internal::LogMessage(   \
  |  |  |  |  |  |   61|  1.37k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::WarningTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  308|    685|      break;
  309|    685|    }
  310|       |
  311|  56.8k|    if (!dup.insert(best_symbol->ToString()).second) {
  ------------------
  |  Branch (311:9): [True: 0, False: 56.8k]
  ------------------
  312|       |      // Removes best_symbol so it is not selected again.
  313|      0|      symbols_cache_.erase(best_symbol->fp);
  314|      0|      active_symbols_.erase(best_symbol);
  315|      0|      continue;
  316|      0|    }
  317|       |
  318|       |    // Stores the best_symbol in the final output.
  319|  56.8k|    final_pieces_.emplace_back(best_symbol->ToString(),
  320|  56.8k|                               -static_cast<float>(final_pieces_.size()));
  321|       |
  322|  56.8k|    if (final_pieces_.size() % 20 == 0) {
  ------------------
  |  Branch (322:9): [True: 2.10k, False: 54.7k]
  ------------------
  323|  6.30k|      LOG(INFO) << "Added: freq=" << best_symbol->freq
  ------------------
  |  |  218|  2.10k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  2.10k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  2.10k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  4.20k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  4.20k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2.10k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  2.10k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2.10k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  2.10k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 2.10k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  2.10k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  23.1k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  23.1k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  324|  6.30k|                << " size=" << final_pieces_.size()
  325|  6.30k|                << " all=" << symbols_cache_.size()
  326|  6.30k|                << " active=" << active_symbols_.size()
  327|  6.30k|                << " piece=" << best_symbol->ToString();
  328|  2.10k|    }
  329|       |
  330|  56.8k|    RETURN_IF_ERROR(AcceptSymbol(best_symbol));
  ------------------
  |  |   44|  56.8k|  do {                                 \
  |  |   45|  56.8k|    const auto _status = expr;         \
  |  |   46|  56.8k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 56.8k]
  |  |  ------------------
  |  |   47|  56.8k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 56.8k]
  |  |  ------------------
  ------------------
  331|  56.8k|  }  // end of main loop
  332|       |
  333|       |  // Adds required_chars_
  334|  35.5k|  for (const auto& w : Sorted(required_chars_)) {
  ------------------
  |  Branch (334:22): [True: 35.5k, False: 1.79k]
  ------------------
  335|  35.5k|    const Symbol* symbol = GetCharSymbol(w.first);
  336|  35.5k|    final_pieces_.emplace_back(symbol->ToString(),
  337|  35.5k|                               -static_cast<float>(final_pieces_.size()));
  338|  35.5k|  }
  339|       |
  340|  1.79k|  port::STLDeleteElements(&allocated_);
  341|       |
  342|  1.79k|  return Save();
  343|  1.79k|}
bpe_model_trainer.cc:_ZZN13sentencepiece3bpe7Trainer19UpdateActiveSymbolsEvENK3$_0clEPNS1_6SymbolES4_:
  206|   798k|        [](Symbol* s1, Symbol* s2) { return s1->freq > s2->freq; });

_ZN13sentencepiece3bpe7TrainerC2ERKNS_11TrainerSpecERKNS_14NormalizerSpecES7_:
   37|  1.81k|      : TrainerInterface::TrainerInterface(trainer_spec, normalizer_spec,
   38|  1.81k|                                           denormalizer_spec) {}
_ZNK13sentencepiece3bpe7Trainer6Symbol8IsBigramEv:
   64|   137k|    bool IsBigram() const { return left != nullptr && right != nullptr; }
  ------------------
  |  Branch (64:36): [True: 101k, False: 35.9k]
  |  Branch (64:55): [True: 101k, False: 0]
  ------------------
_ZN13sentencepiece3bpe7Trainer6SymbolC2Ev:
   66|   359k|    Symbol() : left(nullptr), right(nullptr), is_unk(false), fp(0), freq(0) {}
_ZN13sentencepiece3bpe7Trainer9EncodePosEiii:
   77|  2.46M|  static uint64_t EncodePos(int sid, int l, int r) {
   78|  2.46M|    CHECK_GE(l, 0);
  ------------------
  |  |  126|  2.46M|  ABSL_LOG_INTERNAL_CHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   57|  2.46M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_GE, >=, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  2.46M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 2.46M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  2.46M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  2.46M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  2.46M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  2.46M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  2.46M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  2.46M|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   79|  2.46M|    CHECK_GE(r, 0);
  ------------------
  |  |  126|  2.46M|  ABSL_LOG_INTERNAL_CHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   57|  2.46M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_GE, >=, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  2.46M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 2.46M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  2.46M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  2.46M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  2.46M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  2.46M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  2.46M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  2.46M|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   80|  2.46M|    CHECK_LE(l, std::numeric_limits<uint16_t>::max());
  ------------------
  |  |  122|  2.46M|  ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   53|  2.46M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  2.46M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 2.46M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  2.46M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  2.46M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  2.46M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  2.46M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  2.46M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  2.46M|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   81|  2.46M|    CHECK_LE(r, std::numeric_limits<uint16_t>::max());
  ------------------
  |  |  122|  2.46M|  ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   53|  2.46M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  2.46M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 2.46M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  2.46M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  2.46M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  2.46M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  2.46M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  2.46M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  2.46M|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   82|  2.46M|    const uint64_t n = (static_cast<uint64_t>(sid) << 32) |
   83|  2.46M|                       (static_cast<uint64_t>(l) << 16) | r;
   84|  2.46M|    return n;
   85|  2.46M|  }
_ZN13sentencepiece3bpe7Trainer9DecodePosEm:
   88|  5.43M|  static Position DecodePos(uint64_t n) {
   89|  5.43M|    Position p;
   90|  5.43M|    p.sid = n >> 32;
   91|  5.43M|    p.left = (n >> 16) & 0xffff;
   92|  5.43M|    p.right = n & 0xffff;
   93|  5.43M|    return p;
   94|  5.43M|  }

_ZN13sentencepiece10normalizer7Builder22GetPrecompiledCharsMapENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEE:
  288|  10.1k|                                             std::string *output) {
  289|  10.1k|  RET_CHECK(output);
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  290|       |
  291|  10.1k|  if (name == "identity") {
  ------------------
  |  Branch (291:7): [True: 0, False: 10.1k]
  ------------------
  292|      0|    output->clear();
  293|      0|    return util::OkStatus();
  294|      0|  }
  295|       |
  296|  10.1k|  if (!std::all_of(name.begin(), name.end(), [](auto c) {
  ------------------
  |  Branch (296:7): [True: 0, False: 10.1k]
  ------------------
  297|  10.1k|        return (c >= 'a' && c <= 'z') || c == '_' || c == '-';
  298|  10.1k|      })) {
  299|      0|    return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC)
  ------------------
  |  |  300|      0|#define GTL_LOC (0)
  ------------------
  300|      0|           << "Invalid charsmap name " << name;
  301|      0|  }
  302|       |
  303|  10.1k|  std::string result;
  304|       |
  305|  10.1k|#ifndef DISABLE_EMBEDDED_DATA
  306|  20.2k|  for (size_t i = 0; i < kNormalizationRules_size; ++i) {
  ------------------
  |  Branch (306:22): [True: 20.2k, False: 0]
  ------------------
  307|  20.2k|    const auto *blob = &kNormalizationRules_blob[i];
  308|  20.2k|    if (blob->name == name) {
  ------------------
  |  Branch (308:9): [True: 10.1k, False: 10.1k]
  ------------------
  309|  10.1k|      output->assign(blob->data, blob->size);
  310|  10.1k|      return IsValidNormalizerData(*output);
  311|  10.1k|    }
  312|  20.2k|  }
  313|       |#else   // DISABLE_EMBEDDED_DATA
  314|       |  {
  315|       |    const std::string filename =
  316|       |        absl::StrCat(util::JoinPath(GetDataDir(), name), ".bin");
  317|       |    auto input = filesystem::NewReadableFile(filename, true /* is binary */);
  318|       |    if (input->status().ok()) {
  319|       |      input->ReadAll(output);
  320|       |      return IsValidNormalizerData(*output);
  321|       |    }
  322|       |  }
  323|       |#endif  // DISABLE_EMBEDDED_DATA
  324|       |
  325|      0|  return util::StatusBuilder(util::StatusCode::kNotFound, GTL_LOC)
  ------------------
  |  |  300|      0|#define GTL_LOC (0)
  ------------------
  326|      0|         << "No precompiled charsmap is found: " << name << " in "
  327|      0|         << GetDataDir();
  328|  10.1k|}
builder.cc:_ZN13sentencepiece10normalizer12_GLOBAL__N_121IsValidNormalizerDataENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  156|  10.1k|util::Status IsValidNormalizerData(absl::string_view blob_data) {
  157|  10.1k|  NormalizerSpec spec;
  158|  10.1k|  spec.set_precompiled_charsmap(blob_data.data(), blob_data.size());
  159|  10.1k|  const Normalizer normalizer(spec);
  160|  10.1k|  return normalizer.status();
  161|  10.1k|}
builder.cc:_ZZN13sentencepiece10normalizer7Builder22GetPrecompiledCharsMapENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEEENK3$_0clIcEEDaT_:
  296|  81.0k|  if (!std::all_of(name.begin(), name.end(), [](auto c) {
  297|  81.0k|        return (c >= 'a' && c <= 'z') || c == '_' || c == '-';
  ------------------
  |  Branch (297:17): [True: 70.9k, False: 10.1k]
  |  Branch (297:29): [True: 70.9k, False: 0]
  |  Branch (297:42): [True: 10.1k, False: 0]
  |  Branch (297:54): [True: 0, False: 0]
  ------------------
  298|  81.0k|      })) {

_ZN13sentencepiece11TrainerSpecC2EPN6google8protobuf5ArenaE:
  415|  20.1k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  416|  20.1k|  _extensions_(arena),
  417|  20.1k|  input_(arena),
  418|  20.1k|  accept_language_(arena),
  419|  20.1k|  control_symbols_(arena),
  420|  20.1k|  user_defined_symbols_(arena) {
  421|  20.1k|  SharedCtor();
  422|  20.1k|  RegisterArenaDtor(arena);
  423|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.TrainerSpec)
  424|  20.1k|}
_ZN13sentencepiece11TrainerSpecC2ERKS0_:
  426|  17.0k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
  427|  17.0k|      _has_bits_(from._has_bits_),
  428|  17.0k|      input_(from.input_),
  429|  17.0k|      accept_language_(from.accept_language_),
  430|  17.0k|      control_symbols_(from.control_symbols_),
  431|  17.0k|      user_defined_symbols_(from.user_defined_symbols_) {
  432|  17.0k|  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  433|  17.0k|  _extensions_.MergeFrom(from._extensions_);
  434|  17.0k|  model_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  435|  17.0k|  if (from._internal_has_model_prefix()) {
  ------------------
  |  Branch (435:7): [True: 0, False: 17.0k]
  ------------------
  436|      0|    model_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_model_prefix(), 
  437|      0|      GetArena());
  438|      0|  }
  439|  17.0k|  input_format_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  440|  17.0k|  if (from._internal_has_input_format()) {
  ------------------
  |  Branch (440:7): [True: 0, False: 17.0k]
  ------------------
  441|      0|    input_format_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_input_format(), 
  442|      0|      GetArena());
  443|      0|  }
  444|  17.0k|  required_chars_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  445|  17.0k|  if (from._internal_has_required_chars()) {
  ------------------
  |  Branch (445:7): [True: 0, False: 17.0k]
  ------------------
  446|      0|    required_chars_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_required_chars(), 
  447|      0|      GetArena());
  448|      0|  }
  449|  17.0k|  unk_surface_.UnsafeSetDefault(nullptr);
  450|  17.0k|  if (from._internal_has_unk_surface()) {
  ------------------
  |  Branch (450:7): [True: 0, False: 17.0k]
  ------------------
  451|      0|    unk_surface_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_unk_surface(), 
  452|      0|      GetArena());
  453|      0|  }
  454|  17.0k|  unk_piece_.UnsafeSetDefault(nullptr);
  455|  17.0k|  if (from._internal_has_unk_piece()) {
  ------------------
  |  Branch (455:7): [True: 0, False: 17.0k]
  ------------------
  456|      0|    unk_piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_unk_piece(), 
  457|      0|      GetArena());
  458|      0|  }
  459|  17.0k|  bos_piece_.UnsafeSetDefault(nullptr);
  460|  17.0k|  if (from._internal_has_bos_piece()) {
  ------------------
  |  Branch (460:7): [True: 0, False: 17.0k]
  ------------------
  461|      0|    bos_piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_bos_piece(), 
  462|      0|      GetArena());
  463|      0|  }
  464|  17.0k|  eos_piece_.UnsafeSetDefault(nullptr);
  465|  17.0k|  if (from._internal_has_eos_piece()) {
  ------------------
  |  Branch (465:7): [True: 0, False: 17.0k]
  ------------------
  466|      0|    eos_piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_eos_piece(), 
  467|      0|      GetArena());
  468|      0|  }
  469|  17.0k|  pad_piece_.UnsafeSetDefault(nullptr);
  470|  17.0k|  if (from._internal_has_pad_piece()) {
  ------------------
  |  Branch (470:7): [True: 0, False: 17.0k]
  ------------------
  471|      0|    pad_piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_pad_piece(), 
  472|      0|      GetArena());
  473|      0|  }
  474|  17.0k|  pretokenization_delimiter_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  475|  17.0k|  if (from._internal_has_pretokenization_delimiter()) {
  ------------------
  |  Branch (475:7): [True: 0, False: 17.0k]
  ------------------
  476|      0|    pretokenization_delimiter_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pretokenization_delimiter(), 
  477|      0|      GetArena());
  478|      0|  }
  479|  17.0k|  seed_sentencepieces_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  480|  17.0k|  if (from._internal_has_seed_sentencepieces_file()) {
  ------------------
  |  Branch (480:7): [True: 0, False: 17.0k]
  ------------------
  481|      0|    seed_sentencepieces_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_seed_sentencepieces_file(), 
  482|      0|      GetArena());
  483|      0|  }
  484|  17.0k|  ::memcpy(&self_test_sample_size_, &from.self_test_sample_size_,
  485|  17.0k|    static_cast<size_t>(reinterpret_cast<char*>(&pad_id_) -
  486|  17.0k|    reinterpret_cast<char*>(&self_test_sample_size_)) + sizeof(pad_id_));
  487|       |  // @@protoc_insertion_point(copy_constructor:sentencepiece.TrainerSpec)
  488|  17.0k|}
_ZN13sentencepiece11TrainerSpecD2Ev:
  526|  37.1k|TrainerSpec::~TrainerSpec() {
  527|       |  // @@protoc_insertion_point(destructor:sentencepiece.TrainerSpec)
  528|  37.1k|  SharedDtor();
  529|  37.1k|  _internal_metadata_.Delete<std::string>();
  530|  37.1k|}
_ZNK13sentencepiece11TrainerSpec13SetCachedSizeEi:
  552|  4.89k|void TrainerSpec::SetCachedSize(int size) const {
  553|  4.89k|  _cached_size_.Set(size);
  554|  4.89k|}
_ZN13sentencepiece11TrainerSpec5ClearEv:
  561|  9.97k|void TrainerSpec::Clear() {
  562|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.TrainerSpec)
  563|  9.97k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  564|       |  // Prevent compiler warnings about cached_has_bits being unused
  565|  9.97k|  (void) cached_has_bits;
  566|       |
  567|  9.97k|  _extensions_.Clear();
  568|  9.97k|  input_.Clear();
  569|  9.97k|  accept_language_.Clear();
  570|  9.97k|  control_symbols_.Clear();
  571|  9.97k|  user_defined_symbols_.Clear();
  572|  9.97k|  cached_has_bits = _has_bits_[0];
  573|  9.97k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (573:7): [True: 0, False: 9.97k]
  ------------------
  574|      0|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (574:9): [True: 0, False: 0]
  ------------------
  575|      0|      model_prefix_.ClearNonDefaultToEmpty();
  576|      0|    }
  577|      0|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (577:9): [True: 0, False: 0]
  ------------------
  578|      0|      input_format_.ClearNonDefaultToEmpty();
  579|      0|    }
  580|      0|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (580:9): [True: 0, False: 0]
  ------------------
  581|      0|      required_chars_.ClearNonDefaultToEmpty();
  582|      0|    }
  583|      0|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (583:9): [True: 0, False: 0]
  ------------------
  584|      0|      unk_surface_.ClearToDefault(::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_surface_, GetArena());
  585|      0|       }
  586|      0|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (586:9): [True: 0, False: 0]
  ------------------
  587|      0|      unk_piece_.ClearToDefault(::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_piece_, GetArena());
  588|      0|       }
  589|      0|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (589:9): [True: 0, False: 0]
  ------------------
  590|      0|      bos_piece_.ClearToDefault(::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_bos_piece_, GetArena());
  591|      0|       }
  592|      0|    if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (592:9): [True: 0, False: 0]
  ------------------
  593|      0|      eos_piece_.ClearToDefault(::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_eos_piece_, GetArena());
  594|      0|       }
  595|      0|    if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (595:9): [True: 0, False: 0]
  ------------------
  596|      0|      pad_piece_.ClearToDefault(::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_pad_piece_, GetArena());
  597|      0|       }
  598|      0|  }
  599|  9.97k|  if (cached_has_bits & 0x00000300u) {
  ------------------
  |  Branch (599:7): [True: 0, False: 9.97k]
  ------------------
  600|      0|    if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (600:9): [True: 0, False: 0]
  ------------------
  601|      0|      pretokenization_delimiter_.ClearNonDefaultToEmpty();
  602|      0|    }
  603|      0|    if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (603:9): [True: 0, False: 0]
  ------------------
  604|      0|      seed_sentencepieces_file_.ClearNonDefaultToEmpty();
  605|      0|    }
  606|      0|  }
  607|  9.97k|  if (cached_has_bits & 0x0000fc00u) {
  ------------------
  |  Branch (607:7): [True: 0, False: 9.97k]
  ------------------
  608|      0|    ::memset(&self_test_sample_size_, 0, static_cast<size_t>(
  609|      0|        reinterpret_cast<char*>(&treat_whitespace_as_suffix_) -
  610|      0|        reinterpret_cast<char*>(&self_test_sample_size_)) + sizeof(treat_whitespace_as_suffix_));
  611|      0|  }
  612|  9.97k|  if (cached_has_bits & 0x00ff0000u) {
  ------------------
  |  Branch (612:7): [True: 0, False: 9.97k]
  ------------------
  613|      0|    ::memset(&allow_whitespace_only_pieces_, 0, static_cast<size_t>(
  614|      0|        reinterpret_cast<char*>(&differential_privacy_clipping_threshold_) -
  615|      0|        reinterpret_cast<char*>(&allow_whitespace_only_pieces_)) + sizeof(differential_privacy_clipping_threshold_));
  616|      0|  }
  617|  9.97k|  if (cached_has_bits & 0xff000000u) {
  ------------------
  |  Branch (617:7): [True: 0, False: 9.97k]
  ------------------
  618|      0|    model_type_ = 1;
  619|      0|    vocab_size_ = 8000;
  620|      0|    character_coverage_ = 0.9995f;
  621|      0|    seed_sentencepiece_size_ = 1000000;
  622|      0|    shrinking_factor_ = 0.75f;
  623|      0|    num_threads_ = 16;
  624|      0|    num_sub_iterations_ = 2;
  625|      0|    max_sentence_length_ = 4192;
  626|      0|  }
  627|  9.97k|  cached_has_bits = _has_bits_[1];
  628|  9.97k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (628:7): [True: 0, False: 9.97k]
  ------------------
  629|      0|    max_sentencepiece_length_ = 16;
  630|      0|    shuffle_input_sentence_ = true;
  631|      0|    split_by_unicode_script_ = true;
  632|      0|    split_by_number_ = true;
  633|      0|    split_by_whitespace_ = true;
  634|      0|    vocabulary_output_piece_score_ = true;
  635|      0|    hard_vocab_limit_ = true;
  636|      0|    bos_id_ = 1;
  637|      0|  }
  638|  9.97k|  if (cached_has_bits & 0x00000300u) {
  ------------------
  |  Branch (638:7): [True: 0, False: 9.97k]
  ------------------
  639|      0|    eos_id_ = 2;
  640|      0|    pad_id_ = -1;
  641|      0|  }
  642|  9.97k|  _has_bits_.Clear();
  643|  9.97k|  _internal_metadata_.Clear<std::string>();
  644|  9.97k|}
_ZNK13sentencepiece11TrainerSpec18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 1074|  4.89k|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 1075|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.TrainerSpec)
 1076|  4.89k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 1077|  4.89k|  (void) cached_has_bits;
 1078|       |
 1079|       |  // repeated string input = 1;
 1080|  4.89k|  for (int i = 0, n = this->_internal_input_size(); i < n; i++) {
  ------------------
  |  Branch (1080:53): [True: 0, False: 4.89k]
  ------------------
 1081|      0|    const auto& s = this->_internal_input(i);
 1082|      0|    target = stream->WriteString(1, s, target);
 1083|      0|  }
 1084|       |
 1085|  4.89k|  cached_has_bits = _has_bits_[0];
 1086|       |  // optional string model_prefix = 2;
 1087|  4.89k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1087:7): [True: 0, False: 4.89k]
  ------------------
 1088|      0|    target = stream->WriteStringMaybeAliased(
 1089|      0|        2, this->_internal_model_prefix(), target);
 1090|      0|  }
 1091|       |
 1092|       |  // optional .sentencepiece.TrainerSpec.ModelType model_type = 3 [default = UNIGRAM];
 1093|  4.89k|  if (cached_has_bits & 0x01000000u) {
  ------------------
  |  Branch (1093:7): [True: 4.89k, False: 0]
  ------------------
 1094|  4.89k|    target = stream->EnsureSpace(target);
 1095|  4.89k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
 1096|  4.89k|      3, this->_internal_model_type(), target);
 1097|  4.89k|  }
 1098|       |
 1099|       |  // optional int32 vocab_size = 4 [default = 8000];
 1100|  4.89k|  if (cached_has_bits & 0x02000000u) {
  ------------------
  |  Branch (1100:7): [True: 4.89k, False: 0]
  ------------------
 1101|  4.89k|    target = stream->EnsureSpace(target);
 1102|  4.89k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_vocab_size(), target);
 1103|  4.89k|  }
 1104|       |
 1105|       |  // repeated string accept_language = 5;
 1106|  4.89k|  for (int i = 0, n = this->_internal_accept_language_size(); i < n; i++) {
  ------------------
  |  Branch (1106:63): [True: 0, False: 4.89k]
  ------------------
 1107|      0|    const auto& s = this->_internal_accept_language(i);
 1108|      0|    target = stream->WriteString(5, s, target);
 1109|      0|  }
 1110|       |
 1111|       |  // optional int32 self_test_sample_size = 6 [default = 0];
 1112|  4.89k|  if (cached_has_bits & 0x00000400u) {
  ------------------
  |  Branch (1112:7): [True: 0, False: 4.89k]
  ------------------
 1113|      0|    target = stream->EnsureSpace(target);
 1114|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(6, this->_internal_self_test_sample_size(), target);
 1115|      0|  }
 1116|       |
 1117|       |  // optional string input_format = 7;
 1118|  4.89k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1118:7): [True: 0, False: 4.89k]
  ------------------
 1119|      0|    target = stream->WriteStringMaybeAliased(
 1120|      0|        7, this->_internal_input_format(), target);
 1121|      0|  }
 1122|       |
 1123|       |  // optional float character_coverage = 10 [default = 0.9995];
 1124|  4.89k|  if (cached_has_bits & 0x04000000u) {
  ------------------
  |  Branch (1124:7): [True: 1.61k, False: 3.27k]
  ------------------
 1125|  1.61k|    target = stream->EnsureSpace(target);
 1126|  1.61k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_character_coverage(), target);
 1127|  1.61k|  }
 1128|       |
 1129|       |  // optional uint64 input_sentence_size = 11 [default = 0];
 1130|  4.89k|  if (cached_has_bits & 0x00001000u) {
  ------------------
  |  Branch (1130:7): [True: 1.19k, False: 3.70k]
  ------------------
 1131|  1.19k|    target = stream->EnsureSpace(target);
 1132|  1.19k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(11, this->_internal_input_sentence_size(), target);
 1133|  1.19k|  }
 1134|       |
 1135|       |  // optional int32 mining_sentence_size = 12 [deprecated = true];
 1136|  4.89k|  if (cached_has_bits & 0x00000800u) {
  ------------------
  |  Branch (1136:7): [True: 0, False: 4.89k]
  ------------------
 1137|      0|    target = stream->EnsureSpace(target);
 1138|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(12, this->_internal_mining_sentence_size(), target);
 1139|      0|  }
 1140|       |
 1141|       |  // optional int32 training_sentence_size = 13 [deprecated = true];
 1142|  4.89k|  if (cached_has_bits & 0x00002000u) {
  ------------------
  |  Branch (1142:7): [True: 0, False: 4.89k]
  ------------------
 1143|      0|    target = stream->EnsureSpace(target);
 1144|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(13, this->_internal_training_sentence_size(), target);
 1145|      0|  }
 1146|       |
 1147|       |  // optional int32 seed_sentencepiece_size = 14 [default = 1000000];
 1148|  4.89k|  if (cached_has_bits & 0x08000000u) {
  ------------------
  |  Branch (1148:7): [True: 0, False: 4.89k]
  ------------------
 1149|      0|    target = stream->EnsureSpace(target);
 1150|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(14, this->_internal_seed_sentencepiece_size(), target);
 1151|      0|  }
 1152|       |
 1153|       |  // optional float shrinking_factor = 15 [default = 0.75];
 1154|  4.89k|  if (cached_has_bits & 0x10000000u) {
  ------------------
  |  Branch (1154:7): [True: 0, False: 4.89k]
  ------------------
 1155|      0|    target = stream->EnsureSpace(target);
 1156|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(15, this->_internal_shrinking_factor(), target);
 1157|      0|  }
 1158|       |
 1159|       |  // optional int32 num_threads = 16 [default = 16];
 1160|  4.89k|  if (cached_has_bits & 0x20000000u) {
  ------------------
  |  Branch (1160:7): [True: 4.89k, False: 0]
  ------------------
 1161|  4.89k|    target = stream->EnsureSpace(target);
 1162|  4.89k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(16, this->_internal_num_threads(), target);
 1163|  4.89k|  }
 1164|       |
 1165|       |  // optional int32 num_sub_iterations = 17 [default = 2];
 1166|  4.89k|  if (cached_has_bits & 0x40000000u) {
  ------------------
  |  Branch (1166:7): [True: 0, False: 4.89k]
  ------------------
 1167|      0|    target = stream->EnsureSpace(target);
 1168|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(17, this->_internal_num_sub_iterations(), target);
 1169|      0|  }
 1170|       |
 1171|       |  // optional int32 max_sentence_length = 18 [default = 4192];
 1172|  4.89k|  if (cached_has_bits & 0x80000000u) {
  ------------------
  |  Branch (1172:7): [True: 0, False: 4.89k]
  ------------------
 1173|      0|    target = stream->EnsureSpace(target);
 1174|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(18, this->_internal_max_sentence_length(), target);
 1175|      0|  }
 1176|       |
 1177|  4.89k|  cached_has_bits = _has_bits_[1];
 1178|       |  // optional bool shuffle_input_sentence = 19 [default = true];
 1179|  4.89k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1179:7): [True: 1.42k, False: 3.47k]
  ------------------
 1180|  1.42k|    target = stream->EnsureSpace(target);
 1181|  1.42k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(19, this->_internal_shuffle_input_sentence(), target);
 1182|  1.42k|  }
 1183|       |
 1184|       |  // optional int32 max_sentencepiece_length = 20 [default = 16];
 1185|  4.89k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1185:7): [True: 0, False: 4.89k]
  ------------------
 1186|      0|    target = stream->EnsureSpace(target);
 1187|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(20, this->_internal_max_sentencepiece_length(), target);
 1188|      0|  }
 1189|       |
 1190|       |  // optional bool split_by_unicode_script = 21 [default = true];
 1191|  4.89k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1191:7): [True: 2.31k, False: 2.57k]
  ------------------
 1192|  2.31k|    target = stream->EnsureSpace(target);
 1193|  2.31k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(21, this->_internal_split_by_unicode_script(), target);
 1194|  2.31k|  }
 1195|       |
 1196|       |  // optional bool split_by_whitespace = 22 [default = true];
 1197|  4.89k|  if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1197:7): [True: 1.48k, False: 3.41k]
  ------------------
 1198|  1.48k|    target = stream->EnsureSpace(target);
 1199|  1.48k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(22, this->_internal_split_by_whitespace(), target);
 1200|  1.48k|  }
 1201|       |
 1202|       |  // optional bool split_by_number = 23 [default = true];
 1203|  4.89k|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1203:7): [True: 1.52k, False: 3.36k]
  ------------------
 1204|  1.52k|    target = stream->EnsureSpace(target);
 1205|  1.52k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(23, this->_internal_split_by_number(), target);
 1206|  1.52k|  }
 1207|       |
 1208|  4.89k|  cached_has_bits = _has_bits_[0];
 1209|       |  // optional bool treat_whitespace_as_suffix = 24 [default = false];
 1210|  4.89k|  if (cached_has_bits & 0x00008000u) {
  ------------------
  |  Branch (1210:7): [True: 0, False: 4.89k]
  ------------------
 1211|      0|    target = stream->EnsureSpace(target);
 1212|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(24, this->_internal_treat_whitespace_as_suffix(), target);
 1213|      0|  }
 1214|       |
 1215|       |  // optional bool split_digits = 25 [default = false];
 1216|  4.89k|  if (cached_has_bits & 0x00020000u) {
  ------------------
  |  Branch (1216:7): [True: 0, False: 4.89k]
  ------------------
 1217|      0|    target = stream->EnsureSpace(target);
 1218|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(25, this->_internal_split_digits(), target);
 1219|      0|  }
 1220|       |
 1221|       |  // optional bool allow_whitespace_only_pieces = 26 [default = false];
 1222|  4.89k|  if (cached_has_bits & 0x00010000u) {
  ------------------
  |  Branch (1222:7): [True: 0, False: 4.89k]
  ------------------
 1223|      0|    target = stream->EnsureSpace(target);
 1224|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(26, this->_internal_allow_whitespace_only_pieces(), target);
 1225|      0|  }
 1226|       |
 1227|       |  // repeated string control_symbols = 30;
 1228|  4.89k|  for (int i = 0, n = this->_internal_control_symbols_size(); i < n; i++) {
  ------------------
  |  Branch (1228:63): [True: 0, False: 4.89k]
  ------------------
 1229|      0|    const auto& s = this->_internal_control_symbols(i);
 1230|      0|    target = stream->WriteString(30, s, target);
 1231|      0|  }
 1232|       |
 1233|       |  // repeated string user_defined_symbols = 31;
 1234|  4.89k|  for (int i = 0, n = this->_internal_user_defined_symbols_size(); i < n; i++) {
  ------------------
  |  Branch (1234:68): [True: 0, False: 4.89k]
  ------------------
 1235|      0|    const auto& s = this->_internal_user_defined_symbols(i);
 1236|      0|    target = stream->WriteString(31, s, target);
 1237|      0|  }
 1238|       |
 1239|  4.89k|  cached_has_bits = _has_bits_[1];
 1240|       |  // optional bool vocabulary_output_piece_score = 32 [default = true];
 1241|  4.89k|  if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1241:7): [True: 0, False: 4.89k]
  ------------------
 1242|      0|    target = stream->EnsureSpace(target);
 1243|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(32, this->_internal_vocabulary_output_piece_score(), target);
 1244|      0|  }
 1245|       |
 1246|       |  // optional bool hard_vocab_limit = 33 [default = true];
 1247|  4.89k|  if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1247:7): [True: 0, False: 4.89k]
  ------------------
 1248|      0|    target = stream->EnsureSpace(target);
 1249|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(33, this->_internal_hard_vocab_limit(), target);
 1250|      0|  }
 1251|       |
 1252|  4.89k|  cached_has_bits = _has_bits_[0];
 1253|       |  // optional bool use_all_vocab = 34 [default = false];
 1254|  4.89k|  if (cached_has_bits & 0x00080000u) {
  ------------------
  |  Branch (1254:7): [True: 0, False: 4.89k]
  ------------------
 1255|      0|    target = stream->EnsureSpace(target);
 1256|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(34, this->_internal_use_all_vocab(), target);
 1257|      0|  }
 1258|       |
 1259|       |  // optional bool byte_fallback = 35 [default = false];
 1260|  4.89k|  if (cached_has_bits & 0x00040000u) {
  ------------------
  |  Branch (1260:7): [True: 919, False: 3.97k]
  ------------------
 1261|    919|    target = stream->EnsureSpace(target);
 1262|    919|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(35, this->_internal_byte_fallback(), target);
 1263|    919|  }
 1264|       |
 1265|       |  // optional string required_chars = 36;
 1266|  4.89k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1266:7): [True: 0, False: 4.89k]
  ------------------
 1267|      0|    target = stream->WriteStringMaybeAliased(
 1268|      0|        36, this->_internal_required_chars(), target);
 1269|      0|  }
 1270|       |
 1271|       |  // optional int32 unk_id = 40 [default = 0];
 1272|  4.89k|  if (cached_has_bits & 0x00200000u) {
  ------------------
  |  Branch (1272:7): [True: 0, False: 4.89k]
  ------------------
 1273|      0|    target = stream->EnsureSpace(target);
 1274|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(40, this->_internal_unk_id(), target);
 1275|      0|  }
 1276|       |
 1277|  4.89k|  cached_has_bits = _has_bits_[1];
 1278|       |  // optional int32 bos_id = 41 [default = 1];
 1279|  4.89k|  if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1279:7): [True: 0, False: 4.89k]
  ------------------
 1280|      0|    target = stream->EnsureSpace(target);
 1281|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(41, this->_internal_bos_id(), target);
 1282|      0|  }
 1283|       |
 1284|       |  // optional int32 eos_id = 42 [default = 2];
 1285|  4.89k|  if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1285:7): [True: 0, False: 4.89k]
  ------------------
 1286|      0|    target = stream->EnsureSpace(target);
 1287|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(42, this->_internal_eos_id(), target);
 1288|      0|  }
 1289|       |
 1290|       |  // optional int32 pad_id = 43 [default = -1];
 1291|  4.89k|  if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1291:7): [True: 0, False: 4.89k]
  ------------------
 1292|      0|    target = stream->EnsureSpace(target);
 1293|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(43, this->_internal_pad_id(), target);
 1294|      0|  }
 1295|       |
 1296|  4.89k|  cached_has_bits = _has_bits_[0];
 1297|       |  // optional string unk_surface = 44 [default = " \342\201\207 "];
 1298|  4.89k|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1298:7): [True: 0, False: 4.89k]
  ------------------
 1299|      0|    target = stream->WriteStringMaybeAliased(
 1300|      0|        44, this->_internal_unk_surface(), target);
 1301|      0|  }
 1302|       |
 1303|       |  // optional string unk_piece = 45 [default = "<unk>"];
 1304|  4.89k|  if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1304:7): [True: 0, False: 4.89k]
  ------------------
 1305|      0|    target = stream->WriteStringMaybeAliased(
 1306|      0|        45, this->_internal_unk_piece(), target);
 1307|      0|  }
 1308|       |
 1309|       |  // optional string bos_piece = 46 [default = "<s>"];
 1310|  4.89k|  if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1310:7): [True: 0, False: 4.89k]
  ------------------
 1311|      0|    target = stream->WriteStringMaybeAliased(
 1312|      0|        46, this->_internal_bos_piece(), target);
 1313|      0|  }
 1314|       |
 1315|       |  // optional string eos_piece = 47 [default = "</s>"];
 1316|  4.89k|  if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1316:7): [True: 0, False: 4.89k]
  ------------------
 1317|      0|    target = stream->WriteStringMaybeAliased(
 1318|      0|        47, this->_internal_eos_piece(), target);
 1319|      0|  }
 1320|       |
 1321|       |  // optional string pad_piece = 48 [default = "<pad>"];
 1322|  4.89k|  if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1322:7): [True: 0, False: 4.89k]
  ------------------
 1323|      0|    target = stream->WriteStringMaybeAliased(
 1324|      0|        48, this->_internal_pad_piece(), target);
 1325|      0|  }
 1326|       |
 1327|       |  // optional bool train_extremely_large_corpus = 49 [default = false];
 1328|  4.89k|  if (cached_has_bits & 0x00100000u) {
  ------------------
  |  Branch (1328:7): [True: 0, False: 4.89k]
  ------------------
 1329|      0|    target = stream->EnsureSpace(target);
 1330|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(49, this->_internal_train_extremely_large_corpus(), target);
 1331|      0|  }
 1332|       |
 1333|       |  // optional bool enable_differential_privacy = 50 [default = false];
 1334|  4.89k|  if (cached_has_bits & 0x00004000u) {
  ------------------
  |  Branch (1334:7): [True: 0, False: 4.89k]
  ------------------
 1335|      0|    target = stream->EnsureSpace(target);
 1336|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(50, this->_internal_enable_differential_privacy(), target);
 1337|      0|  }
 1338|       |
 1339|       |  // optional float differential_privacy_noise_level = 51 [default = 0];
 1340|  4.89k|  if (cached_has_bits & 0x00400000u) {
  ------------------
  |  Branch (1340:7): [True: 0, False: 4.89k]
  ------------------
 1341|      0|    target = stream->EnsureSpace(target);
 1342|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(51, this->_internal_differential_privacy_noise_level(), target);
 1343|      0|  }
 1344|       |
 1345|       |  // optional uint64 differential_privacy_clipping_threshold = 52 [default = 0];
 1346|  4.89k|  if (cached_has_bits & 0x00800000u) {
  ------------------
  |  Branch (1346:7): [True: 0, False: 4.89k]
  ------------------
 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|  4.89k|  if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1352:7): [True: 0, False: 4.89k]
  ------------------
 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|  4.89k|  if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1358:7): [True: 0, False: 4.89k]
  ------------------
 1359|      0|    target = stream->WriteStringMaybeAliased(
 1360|      0|        54, this->_internal_seed_sentencepieces_file(), target);
 1361|      0|  }
 1362|       |
 1363|       |  // Extension range [200, 536870912)
 1364|  4.89k|  target = _extensions_._InternalSerialize(
 1365|  4.89k|      200, 536870912, target, stream);
 1366|       |
 1367|  4.89k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.89k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.89k]
  |  |  ------------------
  ------------------
 1368|      0|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
 1369|      0|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
 1370|      0|  }
 1371|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.TrainerSpec)
 1372|  4.89k|  return target;
 1373|  4.89k|}
_ZNK13sentencepiece11TrainerSpec12ByteSizeLongEv:
 1375|  4.89k|size_t TrainerSpec::ByteSizeLong() const {
 1376|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.TrainerSpec)
 1377|  4.89k|  size_t total_size = 0;
 1378|       |
 1379|  4.89k|  total_size += _extensions_.ByteSize();
 1380|       |
 1381|  4.89k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 1382|       |  // Prevent compiler warnings about cached_has_bits being unused
 1383|  4.89k|  (void) cached_has_bits;
 1384|       |
 1385|       |  // repeated string input = 1;
 1386|  4.89k|  total_size += 1 *
 1387|  4.89k|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(input_.size());
 1388|  4.89k|  for (int i = 0, n = input_.size(); i < n; i++) {
  ------------------
  |  Branch (1388:38): [True: 0, False: 4.89k]
  ------------------
 1389|      0|    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1390|      0|      input_.Get(i));
 1391|      0|  }
 1392|       |
 1393|       |  // repeated string accept_language = 5;
 1394|  4.89k|  total_size += 1 *
 1395|  4.89k|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(accept_language_.size());
 1396|  4.89k|  for (int i = 0, n = accept_language_.size(); i < n; i++) {
  ------------------
  |  Branch (1396:48): [True: 0, False: 4.89k]
  ------------------
 1397|      0|    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1398|      0|      accept_language_.Get(i));
 1399|      0|  }
 1400|       |
 1401|       |  // repeated string control_symbols = 30;
 1402|  4.89k|  total_size += 2 *
 1403|  4.89k|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(control_symbols_.size());
 1404|  4.89k|  for (int i = 0, n = control_symbols_.size(); i < n; i++) {
  ------------------
  |  Branch (1404:48): [True: 0, False: 4.89k]
  ------------------
 1405|      0|    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1406|      0|      control_symbols_.Get(i));
 1407|      0|  }
 1408|       |
 1409|       |  // repeated string user_defined_symbols = 31;
 1410|  4.89k|  total_size += 2 *
 1411|  4.89k|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(user_defined_symbols_.size());
 1412|  4.89k|  for (int i = 0, n = user_defined_symbols_.size(); i < n; i++) {
  ------------------
  |  Branch (1412:53): [True: 0, False: 4.89k]
  ------------------
 1413|      0|    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1414|      0|      user_defined_symbols_.Get(i));
 1415|      0|  }
 1416|       |
 1417|  4.89k|  cached_has_bits = _has_bits_[0];
 1418|  4.89k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (1418:7): [True: 0, False: 4.89k]
  ------------------
 1419|       |    // optional string model_prefix = 2;
 1420|      0|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1420:9): [True: 0, False: 0]
  ------------------
 1421|      0|      total_size += 1 +
 1422|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1423|      0|          this->_internal_model_prefix());
 1424|      0|    }
 1425|       |
 1426|       |    // optional string input_format = 7;
 1427|      0|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1427:9): [True: 0, False: 0]
  ------------------
 1428|      0|      total_size += 1 +
 1429|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1430|      0|          this->_internal_input_format());
 1431|      0|    }
 1432|       |
 1433|       |    // optional string required_chars = 36;
 1434|      0|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1434:9): [True: 0, False: 0]
  ------------------
 1435|      0|      total_size += 2 +
 1436|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1437|      0|          this->_internal_required_chars());
 1438|      0|    }
 1439|       |
 1440|       |    // optional string unk_surface = 44 [default = " \342\201\207 "];
 1441|      0|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1441:9): [True: 0, False: 0]
  ------------------
 1442|      0|      total_size += 2 +
 1443|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1444|      0|          this->_internal_unk_surface());
 1445|      0|    }
 1446|       |
 1447|       |    // optional string unk_piece = 45 [default = "<unk>"];
 1448|      0|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1448:9): [True: 0, False: 0]
  ------------------
 1449|      0|      total_size += 2 +
 1450|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1451|      0|          this->_internal_unk_piece());
 1452|      0|    }
 1453|       |
 1454|       |    // optional string bos_piece = 46 [default = "<s>"];
 1455|      0|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1455:9): [True: 0, False: 0]
  ------------------
 1456|      0|      total_size += 2 +
 1457|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1458|      0|          this->_internal_bos_piece());
 1459|      0|    }
 1460|       |
 1461|       |    // optional string eos_piece = 47 [default = "</s>"];
 1462|      0|    if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1462:9): [True: 0, False: 0]
  ------------------
 1463|      0|      total_size += 2 +
 1464|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1465|      0|          this->_internal_eos_piece());
 1466|      0|    }
 1467|       |
 1468|       |    // optional string pad_piece = 48 [default = "<pad>"];
 1469|      0|    if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1469:9): [True: 0, False: 0]
  ------------------
 1470|      0|      total_size += 2 +
 1471|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1472|      0|          this->_internal_pad_piece());
 1473|      0|    }
 1474|       |
 1475|      0|  }
 1476|  4.89k|  if (cached_has_bits & 0x0000ff00u) {
  ------------------
  |  Branch (1476:7): [True: 1.19k, False: 3.70k]
  ------------------
 1477|       |    // optional string pretokenization_delimiter = 53 [default = ""];
 1478|  1.19k|    if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1478:9): [True: 0, False: 1.19k]
  ------------------
 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|  1.19k|    if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1485:9): [True: 0, False: 1.19k]
  ------------------
 1486|      0|      total_size += 2 +
 1487|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1488|      0|          this->_internal_seed_sentencepieces_file());
 1489|      0|    }
 1490|       |
 1491|       |    // optional int32 self_test_sample_size = 6 [default = 0];
 1492|  1.19k|    if (cached_has_bits & 0x00000400u) {
  ------------------
  |  Branch (1492:9): [True: 0, False: 1.19k]
  ------------------
 1493|      0|      total_size += 1 +
 1494|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1495|      0|          this->_internal_self_test_sample_size());
 1496|      0|    }
 1497|       |
 1498|       |    // optional int32 mining_sentence_size = 12 [deprecated = true];
 1499|  1.19k|    if (cached_has_bits & 0x00000800u) {
  ------------------
  |  Branch (1499:9): [True: 0, False: 1.19k]
  ------------------
 1500|      0|      total_size += 1 +
 1501|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1502|      0|          this->_internal_mining_sentence_size());
 1503|      0|    }
 1504|       |
 1505|       |    // optional uint64 input_sentence_size = 11 [default = 0];
 1506|  1.19k|    if (cached_has_bits & 0x00001000u) {
  ------------------
  |  Branch (1506:9): [True: 1.19k, False: 0]
  ------------------
 1507|  1.19k|      total_size += 1 +
 1508|  1.19k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
 1509|  1.19k|          this->_internal_input_sentence_size());
 1510|  1.19k|    }
 1511|       |
 1512|       |    // optional int32 training_sentence_size = 13 [deprecated = true];
 1513|  1.19k|    if (cached_has_bits & 0x00002000u) {
  ------------------
  |  Branch (1513:9): [True: 0, False: 1.19k]
  ------------------
 1514|      0|      total_size += 1 +
 1515|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1516|      0|          this->_internal_training_sentence_size());
 1517|      0|    }
 1518|       |
 1519|       |    // optional bool enable_differential_privacy = 50 [default = false];
 1520|  1.19k|    if (cached_has_bits & 0x00004000u) {
  ------------------
  |  Branch (1520:9): [True: 0, False: 1.19k]
  ------------------
 1521|      0|      total_size += 2 + 1;
 1522|      0|    }
 1523|       |
 1524|       |    // optional bool treat_whitespace_as_suffix = 24 [default = false];
 1525|  1.19k|    if (cached_has_bits & 0x00008000u) {
  ------------------
  |  Branch (1525:9): [True: 0, False: 1.19k]
  ------------------
 1526|      0|      total_size += 2 + 1;
 1527|      0|    }
 1528|       |
 1529|  1.19k|  }
 1530|  4.89k|  if (cached_has_bits & 0x00ff0000u) {
  ------------------
  |  Branch (1530:7): [True: 919, False: 3.97k]
  ------------------
 1531|       |    // optional bool allow_whitespace_only_pieces = 26 [default = false];
 1532|    919|    if (cached_has_bits & 0x00010000u) {
  ------------------
  |  Branch (1532:9): [True: 0, False: 919]
  ------------------
 1533|      0|      total_size += 2 + 1;
 1534|      0|    }
 1535|       |
 1536|       |    // optional bool split_digits = 25 [default = false];
 1537|    919|    if (cached_has_bits & 0x00020000u) {
  ------------------
  |  Branch (1537:9): [True: 0, False: 919]
  ------------------
 1538|      0|      total_size += 2 + 1;
 1539|      0|    }
 1540|       |
 1541|       |    // optional bool byte_fallback = 35 [default = false];
 1542|    919|    if (cached_has_bits & 0x00040000u) {
  ------------------
  |  Branch (1542:9): [True: 919, False: 0]
  ------------------
 1543|    919|      total_size += 2 + 1;
 1544|    919|    }
 1545|       |
 1546|       |    // optional bool use_all_vocab = 34 [default = false];
 1547|    919|    if (cached_has_bits & 0x00080000u) {
  ------------------
  |  Branch (1547:9): [True: 0, False: 919]
  ------------------
 1548|      0|      total_size += 2 + 1;
 1549|      0|    }
 1550|       |
 1551|       |    // optional bool train_extremely_large_corpus = 49 [default = false];
 1552|    919|    if (cached_has_bits & 0x00100000u) {
  ------------------
  |  Branch (1552:9): [True: 0, False: 919]
  ------------------
 1553|      0|      total_size += 2 + 1;
 1554|      0|    }
 1555|       |
 1556|       |    // optional int32 unk_id = 40 [default = 0];
 1557|    919|    if (cached_has_bits & 0x00200000u) {
  ------------------
  |  Branch (1557:9): [True: 0, False: 919]
  ------------------
 1558|      0|      total_size += 2 +
 1559|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1560|      0|          this->_internal_unk_id());
 1561|      0|    }
 1562|       |
 1563|       |    // optional float differential_privacy_noise_level = 51 [default = 0];
 1564|    919|    if (cached_has_bits & 0x00400000u) {
  ------------------
  |  Branch (1564:9): [True: 0, False: 919]
  ------------------
 1565|      0|      total_size += 2 + 4;
 1566|      0|    }
 1567|       |
 1568|       |    // optional uint64 differential_privacy_clipping_threshold = 52 [default = 0];
 1569|    919|    if (cached_has_bits & 0x00800000u) {
  ------------------
  |  Branch (1569:9): [True: 0, False: 919]
  ------------------
 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|    919|  }
 1576|  4.89k|  if (cached_has_bits & 0xff000000u) {
  ------------------
  |  Branch (1576:7): [True: 4.89k, False: 0]
  ------------------
 1577|       |    // optional .sentencepiece.TrainerSpec.ModelType model_type = 3 [default = UNIGRAM];
 1578|  4.89k|    if (cached_has_bits & 0x01000000u) {
  ------------------
  |  Branch (1578:9): [True: 4.89k, False: 0]
  ------------------
 1579|  4.89k|      total_size += 1 +
 1580|  4.89k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_model_type());
 1581|  4.89k|    }
 1582|       |
 1583|       |    // optional int32 vocab_size = 4 [default = 8000];
 1584|  4.89k|    if (cached_has_bits & 0x02000000u) {
  ------------------
  |  Branch (1584:9): [True: 4.89k, False: 0]
  ------------------
 1585|  4.89k|      total_size += 1 +
 1586|  4.89k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1587|  4.89k|          this->_internal_vocab_size());
 1588|  4.89k|    }
 1589|       |
 1590|       |    // optional float character_coverage = 10 [default = 0.9995];
 1591|  4.89k|    if (cached_has_bits & 0x04000000u) {
  ------------------
  |  Branch (1591:9): [True: 1.61k, False: 3.27k]
  ------------------
 1592|  1.61k|      total_size += 1 + 4;
 1593|  1.61k|    }
 1594|       |
 1595|       |    // optional int32 seed_sentencepiece_size = 14 [default = 1000000];
 1596|  4.89k|    if (cached_has_bits & 0x08000000u) {
  ------------------
  |  Branch (1596:9): [True: 0, False: 4.89k]
  ------------------
 1597|      0|      total_size += 1 +
 1598|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1599|      0|          this->_internal_seed_sentencepiece_size());
 1600|      0|    }
 1601|       |
 1602|       |    // optional float shrinking_factor = 15 [default = 0.75];
 1603|  4.89k|    if (cached_has_bits & 0x10000000u) {
  ------------------
  |  Branch (1603:9): [True: 0, False: 4.89k]
  ------------------
 1604|      0|      total_size += 1 + 4;
 1605|      0|    }
 1606|       |
 1607|       |    // optional int32 num_threads = 16 [default = 16];
 1608|  4.89k|    if (cached_has_bits & 0x20000000u) {
  ------------------
  |  Branch (1608:9): [True: 4.89k, False: 0]
  ------------------
 1609|  4.89k|      total_size += 2 +
 1610|  4.89k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1611|  4.89k|          this->_internal_num_threads());
 1612|  4.89k|    }
 1613|       |
 1614|       |    // optional int32 num_sub_iterations = 17 [default = 2];
 1615|  4.89k|    if (cached_has_bits & 0x40000000u) {
  ------------------
  |  Branch (1615:9): [True: 0, False: 4.89k]
  ------------------
 1616|      0|      total_size += 2 +
 1617|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1618|      0|          this->_internal_num_sub_iterations());
 1619|      0|    }
 1620|       |
 1621|       |    // optional int32 max_sentence_length = 18 [default = 4192];
 1622|  4.89k|    if (cached_has_bits & 0x80000000u) {
  ------------------
  |  Branch (1622:9): [True: 0, False: 4.89k]
  ------------------
 1623|      0|      total_size += 2 +
 1624|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1625|      0|          this->_internal_max_sentence_length());
 1626|      0|    }
 1627|       |
 1628|  4.89k|  }
 1629|  4.89k|  cached_has_bits = _has_bits_[1];
 1630|  4.89k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (1630:7): [True: 3.58k, False: 1.30k]
  ------------------
 1631|       |    // optional int32 max_sentencepiece_length = 20 [default = 16];
 1632|  3.58k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1632:9): [True: 0, False: 3.58k]
  ------------------
 1633|      0|      total_size += 2 +
 1634|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1635|      0|          this->_internal_max_sentencepiece_length());
 1636|      0|    }
 1637|       |
 1638|       |    // optional bool shuffle_input_sentence = 19 [default = true];
 1639|  3.58k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1639:9): [True: 1.42k, False: 2.16k]
  ------------------
 1640|  1.42k|      total_size += 2 + 1;
 1641|  1.42k|    }
 1642|       |
 1643|       |    // optional bool split_by_unicode_script = 21 [default = true];
 1644|  3.58k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1644:9): [True: 2.31k, False: 1.27k]
  ------------------
 1645|  2.31k|      total_size += 2 + 1;
 1646|  2.31k|    }
 1647|       |
 1648|       |    // optional bool split_by_number = 23 [default = true];
 1649|  3.58k|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1649:9): [True: 1.52k, False: 2.05k]
  ------------------
 1650|  1.52k|      total_size += 2 + 1;
 1651|  1.52k|    }
 1652|       |
 1653|       |    // optional bool split_by_whitespace = 22 [default = true];
 1654|  3.58k|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1654:9): [True: 1.48k, False: 2.10k]
  ------------------
 1655|  1.48k|      total_size += 2 + 1;
 1656|  1.48k|    }
 1657|       |
 1658|       |    // optional bool vocabulary_output_piece_score = 32 [default = true];
 1659|  3.58k|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1659:9): [True: 0, False: 3.58k]
  ------------------
 1660|      0|      total_size += 2 + 1;
 1661|      0|    }
 1662|       |
 1663|       |    // optional bool hard_vocab_limit = 33 [default = true];
 1664|  3.58k|    if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1664:9): [True: 0, False: 3.58k]
  ------------------
 1665|      0|      total_size += 2 + 1;
 1666|      0|    }
 1667|       |
 1668|       |    // optional int32 bos_id = 41 [default = 1];
 1669|  3.58k|    if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1669:9): [True: 0, False: 3.58k]
  ------------------
 1670|      0|      total_size += 2 +
 1671|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1672|      0|          this->_internal_bos_id());
 1673|      0|    }
 1674|       |
 1675|  3.58k|  }
 1676|  4.89k|  if (cached_has_bits & 0x00000300u) {
  ------------------
  |  Branch (1676:7): [True: 0, False: 4.89k]
  ------------------
 1677|       |    // optional int32 eos_id = 42 [default = 2];
 1678|      0|    if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1678:9): [True: 0, False: 0]
  ------------------
 1679|      0|      total_size += 2 +
 1680|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1681|      0|          this->_internal_eos_id());
 1682|      0|    }
 1683|       |
 1684|       |    // optional int32 pad_id = 43 [default = -1];
 1685|      0|    if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1685:9): [True: 0, False: 0]
  ------------------
 1686|      0|      total_size += 2 +
 1687|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1688|      0|          this->_internal_pad_id());
 1689|      0|    }
 1690|       |
 1691|      0|  }
 1692|  4.89k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.89k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.89k]
  |  |  ------------------
  ------------------
 1693|      0|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 1694|      0|  }
 1695|  4.89k|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 1696|  4.89k|  SetCachedSize(cached_size);
 1697|  4.89k|  return total_size;
 1698|  4.89k|}
_ZN13sentencepiece11TrainerSpec9MergeFromERKS0_:
 1706|  9.97k|void TrainerSpec::MergeFrom(const TrainerSpec& from) {
 1707|       |// @@protoc_insertion_point(class_specific_merge_from_start:sentencepiece.TrainerSpec)
 1708|  9.97k|  GOOGLE_DCHECK_NE(&from, this);
  ------------------
  |  |  184|  9.97k|#define GOOGLE_DCHECK_NE(A, B) GOOGLE_DCHECK((A) != (B))
  |  |  ------------------
  |  |  |  |  181|  9.97k|#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: 9.97k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1709|  9.97k|  _extensions_.MergeFrom(from._extensions_);
 1710|  9.97k|  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
 1711|  9.97k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 1712|  9.97k|  (void) cached_has_bits;
 1713|       |
 1714|  9.97k|  input_.MergeFrom(from.input_);
 1715|  9.97k|  accept_language_.MergeFrom(from.accept_language_);
 1716|  9.97k|  control_symbols_.MergeFrom(from.control_symbols_);
 1717|  9.97k|  user_defined_symbols_.MergeFrom(from.user_defined_symbols_);
 1718|  9.97k|  cached_has_bits = from._has_bits_[0];
 1719|  9.97k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (1719:7): [True: 0, False: 9.97k]
  ------------------
 1720|      0|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1720:9): [True: 0, False: 0]
  ------------------
 1721|      0|      _internal_set_model_prefix(from._internal_model_prefix());
 1722|      0|    }
 1723|      0|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1723:9): [True: 0, False: 0]
  ------------------
 1724|      0|      _internal_set_input_format(from._internal_input_format());
 1725|      0|    }
 1726|      0|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1726:9): [True: 0, False: 0]
  ------------------
 1727|      0|      _internal_set_required_chars(from._internal_required_chars());
 1728|      0|    }
 1729|      0|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1729:9): [True: 0, False: 0]
  ------------------
 1730|      0|      _internal_set_unk_surface(from._internal_unk_surface());
 1731|      0|    }
 1732|      0|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1732:9): [True: 0, False: 0]
  ------------------
 1733|      0|      _internal_set_unk_piece(from._internal_unk_piece());
 1734|      0|    }
 1735|      0|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1735:9): [True: 0, False: 0]
  ------------------
 1736|      0|      _internal_set_bos_piece(from._internal_bos_piece());
 1737|      0|    }
 1738|      0|    if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1738:9): [True: 0, False: 0]
  ------------------
 1739|      0|      _internal_set_eos_piece(from._internal_eos_piece());
 1740|      0|    }
 1741|      0|    if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1741:9): [True: 0, False: 0]
  ------------------
 1742|      0|      _internal_set_pad_piece(from._internal_pad_piece());
 1743|      0|    }
 1744|      0|  }
 1745|  9.97k|  if (cached_has_bits & 0x0000ff00u) {
  ------------------
  |  Branch (1745:7): [True: 1.99k, False: 7.97k]
  ------------------
 1746|  1.99k|    if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1746:9): [True: 0, False: 1.99k]
  ------------------
 1747|      0|      _internal_set_pretokenization_delimiter(from._internal_pretokenization_delimiter());
 1748|      0|    }
 1749|  1.99k|    if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1749:9): [True: 0, False: 1.99k]
  ------------------
 1750|      0|      _internal_set_seed_sentencepieces_file(from._internal_seed_sentencepieces_file());
 1751|      0|    }
 1752|  1.99k|    if (cached_has_bits & 0x00000400u) {
  ------------------
  |  Branch (1752:9): [True: 0, False: 1.99k]
  ------------------
 1753|      0|      self_test_sample_size_ = from.self_test_sample_size_;
 1754|      0|    }
 1755|  1.99k|    if (cached_has_bits & 0x00000800u) {
  ------------------
  |  Branch (1755:9): [True: 0, False: 1.99k]
  ------------------
 1756|      0|      mining_sentence_size_ = from.mining_sentence_size_;
 1757|      0|    }
 1758|  1.99k|    if (cached_has_bits & 0x00001000u) {
  ------------------
  |  Branch (1758:9): [True: 1.99k, False: 0]
  ------------------
 1759|  1.99k|      input_sentence_size_ = from.input_sentence_size_;
 1760|  1.99k|    }
 1761|  1.99k|    if (cached_has_bits & 0x00002000u) {
  ------------------
  |  Branch (1761:9): [True: 0, False: 1.99k]
  ------------------
 1762|      0|      training_sentence_size_ = from.training_sentence_size_;
 1763|      0|    }
 1764|  1.99k|    if (cached_has_bits & 0x00004000u) {
  ------------------
  |  Branch (1764:9): [True: 0, False: 1.99k]
  ------------------
 1765|      0|      enable_differential_privacy_ = from.enable_differential_privacy_;
 1766|      0|    }
 1767|  1.99k|    if (cached_has_bits & 0x00008000u) {
  ------------------
  |  Branch (1767:9): [True: 0, False: 1.99k]
  ------------------
 1768|      0|      treat_whitespace_as_suffix_ = from.treat_whitespace_as_suffix_;
 1769|      0|    }
 1770|  1.99k|    _has_bits_[0] |= cached_has_bits;
 1771|  1.99k|  }
 1772|  9.97k|  if (cached_has_bits & 0x00ff0000u) {
  ------------------
  |  Branch (1772:7): [True: 1.55k, False: 8.42k]
  ------------------
 1773|  1.55k|    if (cached_has_bits & 0x00010000u) {
  ------------------
  |  Branch (1773:9): [True: 0, False: 1.55k]
  ------------------
 1774|      0|      allow_whitespace_only_pieces_ = from.allow_whitespace_only_pieces_;
 1775|      0|    }
 1776|  1.55k|    if (cached_has_bits & 0x00020000u) {
  ------------------
  |  Branch (1776:9): [True: 0, False: 1.55k]
  ------------------
 1777|      0|      split_digits_ = from.split_digits_;
 1778|      0|    }
 1779|  1.55k|    if (cached_has_bits & 0x00040000u) {
  ------------------
  |  Branch (1779:9): [True: 1.55k, False: 0]
  ------------------
 1780|  1.55k|      byte_fallback_ = from.byte_fallback_;
 1781|  1.55k|    }
 1782|  1.55k|    if (cached_has_bits & 0x00080000u) {
  ------------------
  |  Branch (1782:9): [True: 0, False: 1.55k]
  ------------------
 1783|      0|      use_all_vocab_ = from.use_all_vocab_;
 1784|      0|    }
 1785|  1.55k|    if (cached_has_bits & 0x00100000u) {
  ------------------
  |  Branch (1785:9): [True: 0, False: 1.55k]
  ------------------
 1786|      0|      train_extremely_large_corpus_ = from.train_extremely_large_corpus_;
 1787|      0|    }
 1788|  1.55k|    if (cached_has_bits & 0x00200000u) {
  ------------------
  |  Branch (1788:9): [True: 0, False: 1.55k]
  ------------------
 1789|      0|      unk_id_ = from.unk_id_;
 1790|      0|    }
 1791|  1.55k|    if (cached_has_bits & 0x00400000u) {
  ------------------
  |  Branch (1791:9): [True: 0, False: 1.55k]
  ------------------
 1792|      0|      differential_privacy_noise_level_ = from.differential_privacy_noise_level_;
 1793|      0|    }
 1794|  1.55k|    if (cached_has_bits & 0x00800000u) {
  ------------------
  |  Branch (1794:9): [True: 0, False: 1.55k]
  ------------------
 1795|      0|      differential_privacy_clipping_threshold_ = from.differential_privacy_clipping_threshold_;
 1796|      0|    }
 1797|  1.55k|    _has_bits_[0] |= cached_has_bits;
 1798|  1.55k|  }
 1799|  9.97k|  if (cached_has_bits & 0xff000000u) {
  ------------------
  |  Branch (1799:7): [True: 9.97k, False: 0]
  ------------------
 1800|  9.97k|    if (cached_has_bits & 0x01000000u) {
  ------------------
  |  Branch (1800:9): [True: 9.97k, False: 0]
  ------------------
 1801|  9.97k|      model_type_ = from.model_type_;
 1802|  9.97k|    }
 1803|  9.97k|    if (cached_has_bits & 0x02000000u) {
  ------------------
  |  Branch (1803:9): [True: 9.97k, False: 0]
  ------------------
 1804|  9.97k|      vocab_size_ = from.vocab_size_;
 1805|  9.97k|    }
 1806|  9.97k|    if (cached_has_bits & 0x04000000u) {
  ------------------
  |  Branch (1806:9): [True: 2.49k, False: 7.47k]
  ------------------
 1807|  2.49k|      character_coverage_ = from.character_coverage_;
 1808|  2.49k|    }
 1809|  9.97k|    if (cached_has_bits & 0x08000000u) {
  ------------------
  |  Branch (1809:9): [True: 0, False: 9.97k]
  ------------------
 1810|      0|      seed_sentencepiece_size_ = from.seed_sentencepiece_size_;
 1811|      0|    }
 1812|  9.97k|    if (cached_has_bits & 0x10000000u) {
  ------------------
  |  Branch (1812:9): [True: 0, False: 9.97k]
  ------------------
 1813|      0|      shrinking_factor_ = from.shrinking_factor_;
 1814|      0|    }
 1815|  9.97k|    if (cached_has_bits & 0x20000000u) {
  ------------------
  |  Branch (1815:9): [True: 9.97k, False: 0]
  ------------------
 1816|  9.97k|      num_threads_ = from.num_threads_;
 1817|  9.97k|    }
 1818|  9.97k|    if (cached_has_bits & 0x40000000u) {
  ------------------
  |  Branch (1818:9): [True: 0, False: 9.97k]
  ------------------
 1819|      0|      num_sub_iterations_ = from.num_sub_iterations_;
 1820|      0|    }
 1821|  9.97k|    if (cached_has_bits & 0x80000000u) {
  ------------------
  |  Branch (1821:9): [True: 0, False: 9.97k]
  ------------------
 1822|      0|      max_sentence_length_ = from.max_sentence_length_;
 1823|      0|    }
 1824|  9.97k|    _has_bits_[0] |= cached_has_bits;
 1825|  9.97k|  }
 1826|  9.97k|  cached_has_bits = from._has_bits_[1];
 1827|  9.97k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (1827:7): [True: 6.32k, False: 3.64k]
  ------------------
 1828|  6.32k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1828:9): [True: 0, False: 6.32k]
  ------------------
 1829|      0|      max_sentencepiece_length_ = from.max_sentencepiece_length_;
 1830|      0|    }
 1831|  6.32k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1831:9): [True: 2.48k, False: 3.84k]
  ------------------
 1832|  2.48k|      shuffle_input_sentence_ = from.shuffle_input_sentence_;
 1833|  2.48k|    }
 1834|  6.32k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1834:9): [True: 3.50k, False: 2.82k]
  ------------------
 1835|  3.50k|      split_by_unicode_script_ = from.split_by_unicode_script_;
 1836|  3.50k|    }
 1837|  6.32k|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1837:9): [True: 2.69k, False: 3.63k]
  ------------------
 1838|  2.69k|      split_by_number_ = from.split_by_number_;
 1839|  2.69k|    }
 1840|  6.32k|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1840:9): [True: 2.59k, False: 3.73k]
  ------------------
 1841|  2.59k|      split_by_whitespace_ = from.split_by_whitespace_;
 1842|  2.59k|    }
 1843|  6.32k|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1843:9): [True: 0, False: 6.32k]
  ------------------
 1844|      0|      vocabulary_output_piece_score_ = from.vocabulary_output_piece_score_;
 1845|      0|    }
 1846|  6.32k|    if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1846:9): [True: 0, False: 6.32k]
  ------------------
 1847|      0|      hard_vocab_limit_ = from.hard_vocab_limit_;
 1848|      0|    }
 1849|  6.32k|    if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1849:9): [True: 0, False: 6.32k]
  ------------------
 1850|      0|      bos_id_ = from.bos_id_;
 1851|      0|    }
 1852|  6.32k|    _has_bits_[1] |= cached_has_bits;
 1853|  6.32k|  }
 1854|  9.97k|  if (cached_has_bits & 0x00000300u) {
  ------------------
  |  Branch (1854:7): [True: 0, False: 9.97k]
  ------------------
 1855|      0|    if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1855:9): [True: 0, False: 0]
  ------------------
 1856|      0|      eos_id_ = from.eos_id_;
 1857|      0|    }
 1858|      0|    if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1858:9): [True: 0, False: 0]
  ------------------
 1859|      0|      pad_id_ = from.pad_id_;
 1860|      0|    }
 1861|      0|    _has_bits_[1] |= cached_has_bits;
 1862|      0|  }
 1863|  9.97k|}
_ZN13sentencepiece11TrainerSpec8CopyFromERKS0_:
 1865|  9.97k|void TrainerSpec::CopyFrom(const TrainerSpec& from) {
 1866|       |// @@protoc_insertion_point(class_specific_copy_from_start:sentencepiece.TrainerSpec)
 1867|  9.97k|  if (&from == this) return;
  ------------------
  |  Branch (1867:7): [True: 0, False: 9.97k]
  ------------------
 1868|  9.97k|  Clear();
 1869|  9.97k|  MergeFrom(from);
 1870|  9.97k|}
_ZN13sentencepiece14NormalizerSpecC2EPN6google8protobuf5ArenaE:
 1957|  40.3k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 1958|  40.3k|  _extensions_(arena) {
 1959|  40.3k|  SharedCtor();
 1960|  40.3k|  RegisterArenaDtor(arena);
 1961|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.NormalizerSpec)
 1962|  40.3k|}
_ZN13sentencepiece14NormalizerSpecC2ERKS0_:
 1964|  47.4k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
 1965|  47.4k|      _has_bits_(from._has_bits_) {
 1966|  47.4k|  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
 1967|  47.4k|  _extensions_.MergeFrom(from._extensions_);
 1968|  47.4k|  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1969|  47.4k|  if (from._internal_has_name()) {
  ------------------
  |  Branch (1969:7): [True: 17.0k, False: 30.3k]
  ------------------
 1970|  17.0k|    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
 1971|  17.0k|      GetArena());
 1972|  17.0k|  }
 1973|  47.4k|  precompiled_charsmap_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1974|  47.4k|  if (from._internal_has_precompiled_charsmap()) {
  ------------------
  |  Branch (1974:7): [True: 17.0k, False: 30.3k]
  ------------------
 1975|  17.0k|    precompiled_charsmap_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_precompiled_charsmap(), 
 1976|  17.0k|      GetArena());
 1977|  17.0k|  }
 1978|  47.4k|  normalization_rule_tsv_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1979|  47.4k|  if (from._internal_has_normalization_rule_tsv()) {
  ------------------
  |  Branch (1979:7): [True: 0, False: 47.4k]
  ------------------
 1980|      0|    normalization_rule_tsv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_normalization_rule_tsv(), 
 1981|      0|      GetArena());
 1982|      0|  }
 1983|  47.4k|  ::memcpy(&add_dummy_prefix_, &from.add_dummy_prefix_,
 1984|  47.4k|    static_cast<size_t>(reinterpret_cast<char*>(&escape_whitespaces_) -
 1985|  47.4k|    reinterpret_cast<char*>(&add_dummy_prefix_)) + sizeof(escape_whitespaces_));
 1986|       |  // @@protoc_insertion_point(copy_constructor:sentencepiece.NormalizerSpec)
 1987|  47.4k|}
_ZN13sentencepiece14NormalizerSpecD2Ev:
 1999|  87.7k|NormalizerSpec::~NormalizerSpec() {
 2000|       |  // @@protoc_insertion_point(destructor:sentencepiece.NormalizerSpec)
 2001|  87.7k|  SharedDtor();
 2002|  87.7k|  _internal_metadata_.Delete<std::string>();
 2003|  87.7k|}
_ZNK13sentencepiece14NormalizerSpec13SetCachedSizeEi:
 2018|  4.89k|void NormalizerSpec::SetCachedSize(int size) const {
 2019|  4.89k|  _cached_size_.Set(size);
 2020|  4.89k|}
_ZN13sentencepiece14NormalizerSpec5ClearEv:
 2027|  9.97k|void NormalizerSpec::Clear() {
 2028|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.NormalizerSpec)
 2029|  9.97k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2030|       |  // Prevent compiler warnings about cached_has_bits being unused
 2031|  9.97k|  (void) cached_has_bits;
 2032|       |
 2033|  9.97k|  _extensions_.Clear();
 2034|  9.97k|  cached_has_bits = _has_bits_[0];
 2035|  9.97k|  if (cached_has_bits & 0x0000003fu) {
  ------------------
  |  Branch (2035:7): [True: 0, False: 9.97k]
  ------------------
 2036|      0|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2036:9): [True: 0, False: 0]
  ------------------
 2037|      0|      name_.ClearNonDefaultToEmpty();
 2038|      0|    }
 2039|      0|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2039:9): [True: 0, False: 0]
  ------------------
 2040|      0|      precompiled_charsmap_.ClearNonDefaultToEmpty();
 2041|      0|    }
 2042|      0|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2042:9): [True: 0, False: 0]
  ------------------
 2043|      0|      normalization_rule_tsv_.ClearNonDefaultToEmpty();
 2044|      0|    }
 2045|      0|    add_dummy_prefix_ = true;
 2046|      0|    remove_extra_whitespaces_ = true;
 2047|      0|    escape_whitespaces_ = true;
 2048|      0|  }
 2049|  9.97k|  _has_bits_.Clear();
 2050|  9.97k|  _internal_metadata_.Clear<std::string>();
 2051|  9.97k|}
_ZNK13sentencepiece14NormalizerSpec18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 2139|  4.89k|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 2140|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.NormalizerSpec)
 2141|  4.89k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2142|  4.89k|  (void) cached_has_bits;
 2143|       |
 2144|  4.89k|  cached_has_bits = _has_bits_[0];
 2145|       |  // optional string name = 1;
 2146|  4.89k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2146:7): [True: 4.89k, False: 0]
  ------------------
 2147|  4.89k|    target = stream->WriteStringMaybeAliased(
 2148|  4.89k|        1, this->_internal_name(), target);
 2149|  4.89k|  }
 2150|       |
 2151|       |  // optional bytes precompiled_charsmap = 2;
 2152|  4.89k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2152:7): [True: 4.89k, False: 0]
  ------------------
 2153|  4.89k|    target = stream->WriteBytesMaybeAliased(
 2154|  4.89k|        2, this->_internal_precompiled_charsmap(), target);
 2155|  4.89k|  }
 2156|       |
 2157|       |  // optional bool add_dummy_prefix = 3 [default = true];
 2158|  4.89k|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (2158:7): [True: 0, False: 4.89k]
  ------------------
 2159|      0|    target = stream->EnsureSpace(target);
 2160|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(3, this->_internal_add_dummy_prefix(), target);
 2161|      0|  }
 2162|       |
 2163|       |  // optional bool remove_extra_whitespaces = 4 [default = true];
 2164|  4.89k|  if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (2164:7): [True: 0, False: 4.89k]
  ------------------
 2165|      0|    target = stream->EnsureSpace(target);
 2166|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(4, this->_internal_remove_extra_whitespaces(), target);
 2167|      0|  }
 2168|       |
 2169|       |  // optional bool escape_whitespaces = 5 [default = true];
 2170|  4.89k|  if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (2170:7): [True: 0, False: 4.89k]
  ------------------
 2171|      0|    target = stream->EnsureSpace(target);
 2172|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(5, this->_internal_escape_whitespaces(), target);
 2173|      0|  }
 2174|       |
 2175|       |  // optional string normalization_rule_tsv = 6;
 2176|  4.89k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2176:7): [True: 0, False: 4.89k]
  ------------------
 2177|      0|    target = stream->WriteStringMaybeAliased(
 2178|      0|        6, this->_internal_normalization_rule_tsv(), target);
 2179|      0|  }
 2180|       |
 2181|       |  // Extension range [200, 536870912)
 2182|  4.89k|  target = _extensions_._InternalSerialize(
 2183|  4.89k|      200, 536870912, target, stream);
 2184|       |
 2185|  4.89k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.89k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.89k]
  |  |  ------------------
  ------------------
 2186|      0|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
 2187|      0|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
 2188|      0|  }
 2189|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.NormalizerSpec)
 2190|  4.89k|  return target;
 2191|  4.89k|}
_ZNK13sentencepiece14NormalizerSpec12ByteSizeLongEv:
 2193|  4.89k|size_t NormalizerSpec::ByteSizeLong() const {
 2194|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.NormalizerSpec)
 2195|  4.89k|  size_t total_size = 0;
 2196|       |
 2197|  4.89k|  total_size += _extensions_.ByteSize();
 2198|       |
 2199|  4.89k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2200|       |  // Prevent compiler warnings about cached_has_bits being unused
 2201|  4.89k|  (void) cached_has_bits;
 2202|       |
 2203|  4.89k|  cached_has_bits = _has_bits_[0];
 2204|  4.89k|  if (cached_has_bits & 0x0000003fu) {
  ------------------
  |  Branch (2204:7): [True: 4.89k, False: 0]
  ------------------
 2205|       |    // optional string name = 1;
 2206|  4.89k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2206:9): [True: 4.89k, False: 0]
  ------------------
 2207|  4.89k|      total_size += 1 +
 2208|  4.89k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 2209|  4.89k|          this->_internal_name());
 2210|  4.89k|    }
 2211|       |
 2212|       |    // optional bytes precompiled_charsmap = 2;
 2213|  4.89k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2213:9): [True: 4.89k, False: 0]
  ------------------
 2214|  4.89k|      total_size += 1 +
 2215|  4.89k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
 2216|  4.89k|          this->_internal_precompiled_charsmap());
 2217|  4.89k|    }
 2218|       |
 2219|       |    // optional string normalization_rule_tsv = 6;
 2220|  4.89k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2220:9): [True: 0, False: 4.89k]
  ------------------
 2221|      0|      total_size += 1 +
 2222|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 2223|      0|          this->_internal_normalization_rule_tsv());
 2224|      0|    }
 2225|       |
 2226|       |    // optional bool add_dummy_prefix = 3 [default = true];
 2227|  4.89k|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (2227:9): [True: 0, False: 4.89k]
  ------------------
 2228|      0|      total_size += 1 + 1;
 2229|      0|    }
 2230|       |
 2231|       |    // optional bool remove_extra_whitespaces = 4 [default = true];
 2232|  4.89k|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (2232:9): [True: 0, False: 4.89k]
  ------------------
 2233|      0|      total_size += 1 + 1;
 2234|      0|    }
 2235|       |
 2236|       |    // optional bool escape_whitespaces = 5 [default = true];
 2237|  4.89k|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (2237:9): [True: 0, False: 4.89k]
  ------------------
 2238|      0|      total_size += 1 + 1;
 2239|      0|    }
 2240|       |
 2241|  4.89k|  }
 2242|  4.89k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.89k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.89k]
  |  |  ------------------
  ------------------
 2243|      0|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 2244|      0|  }
 2245|  4.89k|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 2246|  4.89k|  SetCachedSize(cached_size);
 2247|  4.89k|  return total_size;
 2248|  4.89k|}
_ZN13sentencepiece14NormalizerSpec9MergeFromERKS0_:
 2256|  9.97k|void NormalizerSpec::MergeFrom(const NormalizerSpec& from) {
 2257|       |// @@protoc_insertion_point(class_specific_merge_from_start:sentencepiece.NormalizerSpec)
 2258|  9.97k|  GOOGLE_DCHECK_NE(&from, this);
  ------------------
  |  |  184|  9.97k|#define GOOGLE_DCHECK_NE(A, B) GOOGLE_DCHECK((A) != (B))
  |  |  ------------------
  |  |  |  |  181|  9.97k|#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: 9.97k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2259|  9.97k|  _extensions_.MergeFrom(from._extensions_);
 2260|  9.97k|  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
 2261|  9.97k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2262|  9.97k|  (void) cached_has_bits;
 2263|       |
 2264|  9.97k|  cached_has_bits = from._has_bits_[0];
 2265|  9.97k|  if (cached_has_bits & 0x0000003fu) {
  ------------------
  |  Branch (2265:7): [True: 9.97k, False: 0]
  ------------------
 2266|  9.97k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2266:9): [True: 9.97k, False: 0]
  ------------------
 2267|  9.97k|      _internal_set_name(from._internal_name());
 2268|  9.97k|    }
 2269|  9.97k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2269:9): [True: 9.97k, False: 0]
  ------------------
 2270|  9.97k|      _internal_set_precompiled_charsmap(from._internal_precompiled_charsmap());
 2271|  9.97k|    }
 2272|  9.97k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2272:9): [True: 0, False: 9.97k]
  ------------------
 2273|      0|      _internal_set_normalization_rule_tsv(from._internal_normalization_rule_tsv());
 2274|      0|    }
 2275|  9.97k|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (2275:9): [True: 0, False: 9.97k]
  ------------------
 2276|      0|      add_dummy_prefix_ = from.add_dummy_prefix_;
 2277|      0|    }
 2278|  9.97k|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (2278:9): [True: 0, False: 9.97k]
  ------------------
 2279|      0|      remove_extra_whitespaces_ = from.remove_extra_whitespaces_;
 2280|      0|    }
 2281|  9.97k|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (2281:9): [True: 0, False: 9.97k]
  ------------------
 2282|      0|      escape_whitespaces_ = from.escape_whitespaces_;
 2283|      0|    }
 2284|  9.97k|    _has_bits_[0] |= cached_has_bits;
 2285|  9.97k|  }
 2286|  9.97k|}
_ZN13sentencepiece14NormalizerSpec8CopyFromERKS0_:
 2288|  9.97k|void NormalizerSpec::CopyFrom(const NormalizerSpec& from) {
 2289|       |// @@protoc_insertion_point(class_specific_copy_from_start:sentencepiece.NormalizerSpec)
 2290|  9.97k|  if (&from == this) return;
  ------------------
  |  Branch (2290:7): [True: 0, False: 9.97k]
  ------------------
 2291|  9.97k|  Clear();
 2292|  9.97k|  MergeFrom(from);
 2293|  9.97k|}
_ZN13sentencepiece19SelfTestData_SampleC2EPN6google8protobuf5ArenaE:
 2335|      1|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) {
 2336|      1|  SharedCtor();
 2337|      1|  RegisterArenaDtor(arena);
 2338|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.SelfTestData.Sample)
 2339|      1|}
_ZN13sentencepiece12SelfTestDataC2EPN6google8protobuf5ArenaE:
 2571|      1|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 2572|      1|  _extensions_(arena),
 2573|      1|  samples_(arena) {
 2574|      1|  SharedCtor();
 2575|      1|  RegisterArenaDtor(arena);
 2576|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.SelfTestData)
 2577|      1|}
_ZN13sentencepiece24ModelProto_SentencePieceC2EPN6google8protobuf5ArenaE:
 2785|  2.35M|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 2786|  2.35M|  _extensions_(arena) {
 2787|  2.35M|  SharedCtor();
 2788|  2.35M|  RegisterArenaDtor(arena);
 2789|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.ModelProto.SentencePiece)
 2790|  2.35M|}
_ZN13sentencepiece24ModelProto_SentencePieceD2Ev:
 2814|  2.35M|ModelProto_SentencePiece::~ModelProto_SentencePiece() {
 2815|       |  // @@protoc_insertion_point(destructor:sentencepiece.ModelProto.SentencePiece)
 2816|  2.35M|  SharedDtor();
 2817|  2.35M|  _internal_metadata_.Delete<std::string>();
 2818|  2.35M|}
_ZNK13sentencepiece24ModelProto_SentencePiece13SetCachedSizeEi:
 2831|   287k|void ModelProto_SentencePiece::SetCachedSize(int size) const {
 2832|   287k|  _cached_size_.Set(size);
 2833|   287k|}
_ZN13sentencepiece24ModelProto_SentencePiece5ClearEv:
 2840|  7.58M|void ModelProto_SentencePiece::Clear() {
 2841|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.ModelProto.SentencePiece)
 2842|  7.58M|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2843|       |  // Prevent compiler warnings about cached_has_bits being unused
 2844|  7.58M|  (void) cached_has_bits;
 2845|       |
 2846|  7.58M|  _extensions_.Clear();
 2847|  7.58M|  cached_has_bits = _has_bits_[0];
 2848|  7.58M|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2848:7): [True: 7.58M, False: 0]
  ------------------
 2849|  7.58M|    piece_.ClearNonDefaultToEmpty();
 2850|  7.58M|  }
 2851|  7.58M|  if (cached_has_bits & 0x00000006u) {
  ------------------
  |  Branch (2851:7): [True: 7.58M, False: 0]
  ------------------
 2852|  7.58M|    score_ = 0;
 2853|  7.58M|    type_ = 1;
 2854|  7.58M|  }
 2855|  7.58M|  _has_bits_.Clear();
 2856|  7.58M|  _internal_metadata_.Clear<std::string>();
 2857|  7.58M|}
_ZNK13sentencepiece24ModelProto_SentencePiece18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 2925|   287k|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 2926|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.ModelProto.SentencePiece)
 2927|   287k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2928|   287k|  (void) cached_has_bits;
 2929|       |
 2930|   287k|  cached_has_bits = _has_bits_[0];
 2931|       |  // optional string piece = 1;
 2932|   287k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2932:7): [True: 287k, False: 0]
  ------------------
 2933|   287k|    target = stream->WriteStringMaybeAliased(
 2934|   287k|        1, this->_internal_piece(), target);
 2935|   287k|  }
 2936|       |
 2937|       |  // optional float score = 2;
 2938|   287k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2938:7): [True: 287k, False: 0]
  ------------------
 2939|   287k|    target = stream->EnsureSpace(target);
 2940|   287k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_score(), target);
 2941|   287k|  }
 2942|       |
 2943|       |  // optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
 2944|   287k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2944:7): [True: 14.6k, False: 273k]
  ------------------
 2945|  14.6k|    target = stream->EnsureSpace(target);
 2946|  14.6k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
 2947|  14.6k|      3, this->_internal_type(), target);
 2948|  14.6k|  }
 2949|       |
 2950|       |  // Extension range [200, 536870912)
 2951|   287k|  target = _extensions_._InternalSerialize(
 2952|   287k|      200, 536870912, target, stream);
 2953|       |
 2954|   287k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|   287k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 287k]
  |  |  ------------------
  ------------------
 2955|      0|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
 2956|      0|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
 2957|      0|  }
 2958|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.ModelProto.SentencePiece)
 2959|   287k|  return target;
 2960|   287k|}
_ZNK13sentencepiece24ModelProto_SentencePiece12ByteSizeLongEv:
 2962|   287k|size_t ModelProto_SentencePiece::ByteSizeLong() const {
 2963|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.ModelProto.SentencePiece)
 2964|   287k|  size_t total_size = 0;
 2965|       |
 2966|   287k|  total_size += _extensions_.ByteSize();
 2967|       |
 2968|   287k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2969|       |  // Prevent compiler warnings about cached_has_bits being unused
 2970|   287k|  (void) cached_has_bits;
 2971|       |
 2972|   287k|  cached_has_bits = _has_bits_[0];
 2973|   287k|  if (cached_has_bits & 0x00000007u) {
  ------------------
  |  Branch (2973:7): [True: 287k, False: 0]
  ------------------
 2974|       |    // optional string piece = 1;
 2975|   287k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2975:9): [True: 287k, False: 0]
  ------------------
 2976|   287k|      total_size += 1 +
 2977|   287k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 2978|   287k|          this->_internal_piece());
 2979|   287k|    }
 2980|       |
 2981|       |    // optional float score = 2;
 2982|   287k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2982:9): [True: 287k, False: 0]
  ------------------
 2983|   287k|      total_size += 1 + 4;
 2984|   287k|    }
 2985|       |
 2986|       |    // optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
 2987|   287k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2987:9): [True: 14.6k, False: 273k]
  ------------------
 2988|  14.6k|      total_size += 1 +
 2989|  14.6k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
 2990|  14.6k|    }
 2991|       |
 2992|   287k|  }
 2993|   287k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|   287k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 287k]
  |  |  ------------------
  ------------------
 2994|      0|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 2995|      0|  }
 2996|   287k|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 2997|   287k|  SetCachedSize(cached_size);
 2998|   287k|  return total_size;
 2999|   287k|}
_ZN13sentencepiece10ModelProto9_Internal12trainer_specEPKS0_:
 3084|  4.89k|ModelProto::_Internal::trainer_spec(const ModelProto* msg) {
 3085|  4.89k|  return *msg->trainer_spec_;
 3086|  4.89k|}
_ZN13sentencepiece10ModelProto9_Internal15normalizer_specEPKS0_:
 3088|  4.89k|ModelProto::_Internal::normalizer_spec(const ModelProto* msg) {
 3089|  4.89k|  return *msg->normalizer_spec_;
 3090|  4.89k|}
_ZN13sentencepiece10ModelProtoC2EPN6google8protobuf5ArenaE:
 3100|  17.0k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 3101|  17.0k|  _extensions_(arena),
 3102|  17.0k|  pieces_(arena) {
 3103|  17.0k|  SharedCtor();
 3104|  17.0k|  RegisterArenaDtor(arena);
 3105|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.ModelProto)
 3106|  17.0k|}
_ZN13sentencepiece10ModelProtoD2Ev:
 3144|  17.0k|ModelProto::~ModelProto() {
 3145|       |  // @@protoc_insertion_point(destructor:sentencepiece.ModelProto)
 3146|  17.0k|  SharedDtor();
 3147|  17.0k|  _internal_metadata_.Delete<std::string>();
 3148|  17.0k|}
_ZNK13sentencepiece10ModelProto13SetCachedSizeEi:
 3164|  4.89k|void ModelProto::SetCachedSize(int size) const {
 3165|  4.89k|  _cached_size_.Set(size);
 3166|  4.89k|}
_ZN13sentencepiece10ModelProto5ClearEv:
 3173|  62.3k|void ModelProto::Clear() {
 3174|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.ModelProto)
 3175|  62.3k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 3176|       |  // Prevent compiler warnings about cached_has_bits being unused
 3177|  62.3k|  (void) cached_has_bits;
 3178|       |
 3179|  62.3k|  _extensions_.Clear();
 3180|  62.3k|  pieces_.Clear();
 3181|  62.3k|  cached_has_bits = _has_bits_[0];
 3182|  62.3k|  if (cached_has_bits & 0x0000000fu) {
  ------------------
  |  Branch (3182:7): [True: 0, False: 62.3k]
  ------------------
 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|  62.3k|  _has_bits_.Clear();
 3201|  62.3k|  _internal_metadata_.Clear<std::string>();
 3202|  62.3k|}
_ZNK13sentencepiece10ModelProto18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 3282|  4.89k|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 3283|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.ModelProto)
 3284|  4.89k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 3285|  4.89k|  (void) cached_has_bits;
 3286|       |
 3287|       |  // repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
 3288|  4.89k|  for (unsigned int i = 0,
 3289|   292k|      n = static_cast<unsigned int>(this->_internal_pieces_size()); i < n; i++) {
  ------------------
  |  Branch (3289:69): [True: 287k, False: 4.89k]
  ------------------
 3290|   287k|    target = stream->EnsureSpace(target);
 3291|   287k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3292|   287k|      InternalWriteMessage(1, this->_internal_pieces(i), target, stream);
 3293|   287k|  }
 3294|       |
 3295|  4.89k|  cached_has_bits = _has_bits_[0];
 3296|       |  // optional .sentencepiece.TrainerSpec trainer_spec = 2;
 3297|  4.89k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (3297:7): [True: 4.89k, False: 0]
  ------------------
 3298|  4.89k|    target = stream->EnsureSpace(target);
 3299|  4.89k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3300|  4.89k|      InternalWriteMessage(
 3301|  4.89k|        2, _Internal::trainer_spec(this), target, stream);
 3302|  4.89k|  }
 3303|       |
 3304|       |  // optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
 3305|  4.89k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (3305:7): [True: 4.89k, False: 0]
  ------------------
 3306|  4.89k|    target = stream->EnsureSpace(target);
 3307|  4.89k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3308|  4.89k|      InternalWriteMessage(
 3309|  4.89k|        3, _Internal::normalizer_spec(this), target, stream);
 3310|  4.89k|  }
 3311|       |
 3312|       |  // optional .sentencepiece.SelfTestData self_test_data = 4;
 3313|  4.89k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (3313:7): [True: 0, False: 4.89k]
  ------------------
 3314|      0|    target = stream->EnsureSpace(target);
 3315|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3316|      0|      InternalWriteMessage(
 3317|      0|        4, _Internal::self_test_data(this), target, stream);
 3318|      0|  }
 3319|       |
 3320|       |  // optional .sentencepiece.NormalizerSpec denormalizer_spec = 5;
 3321|  4.89k|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (3321:7): [True: 0, False: 4.89k]
  ------------------
 3322|      0|    target = stream->EnsureSpace(target);
 3323|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3324|      0|      InternalWriteMessage(
 3325|      0|        5, _Internal::denormalizer_spec(this), target, stream);
 3326|      0|  }
 3327|       |
 3328|       |  // Extension range [200, 536870912)
 3329|  4.89k|  target = _extensions_._InternalSerialize(
 3330|  4.89k|      200, 536870912, target, stream);
 3331|       |
 3332|  4.89k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.89k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.89k]
  |  |  ------------------
  ------------------
 3333|      0|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
 3334|      0|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
 3335|      0|  }
 3336|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.ModelProto)
 3337|  4.89k|  return target;
 3338|  4.89k|}
_ZNK13sentencepiece10ModelProto12ByteSizeLongEv:
 3340|  4.89k|size_t ModelProto::ByteSizeLong() const {
 3341|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.ModelProto)
 3342|  4.89k|  size_t total_size = 0;
 3343|       |
 3344|  4.89k|  total_size += _extensions_.ByteSize();
 3345|       |
 3346|  4.89k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 3347|       |  // Prevent compiler warnings about cached_has_bits being unused
 3348|  4.89k|  (void) cached_has_bits;
 3349|       |
 3350|       |  // repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
 3351|  4.89k|  total_size += 1UL * this->_internal_pieces_size();
 3352|   287k|  for (const auto& msg : this->pieces_) {
  ------------------
  |  Branch (3352:24): [True: 287k, False: 4.89k]
  ------------------
 3353|   287k|    total_size +=
 3354|   287k|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
 3355|   287k|  }
 3356|       |
 3357|  4.89k|  cached_has_bits = _has_bits_[0];
 3358|  4.89k|  if (cached_has_bits & 0x0000000fu) {
  ------------------
  |  Branch (3358:7): [True: 4.89k, False: 0]
  ------------------
 3359|       |    // optional .sentencepiece.TrainerSpec trainer_spec = 2;
 3360|  4.89k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (3360:9): [True: 4.89k, False: 0]
  ------------------
 3361|  4.89k|      total_size += 1 +
 3362|  4.89k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 3363|  4.89k|          *trainer_spec_);
 3364|  4.89k|    }
 3365|       |
 3366|       |    // optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
 3367|  4.89k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (3367:9): [True: 4.89k, False: 0]
  ------------------
 3368|  4.89k|      total_size += 1 +
 3369|  4.89k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 3370|  4.89k|          *normalizer_spec_);
 3371|  4.89k|    }
 3372|       |
 3373|       |    // optional .sentencepiece.SelfTestData self_test_data = 4;
 3374|  4.89k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (3374:9): [True: 0, False: 4.89k]
  ------------------
 3375|      0|      total_size += 1 +
 3376|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 3377|      0|          *self_test_data_);
 3378|      0|    }
 3379|       |
 3380|       |    // optional .sentencepiece.NormalizerSpec denormalizer_spec = 5;
 3381|  4.89k|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (3381:9): [True: 0, False: 4.89k]
  ------------------
 3382|      0|      total_size += 1 +
 3383|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 3384|      0|          *denormalizer_spec_);
 3385|      0|    }
 3386|       |
 3387|  4.89k|  }
 3388|  4.89k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.89k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.89k]
  |  |  ------------------
  ------------------
 3389|      0|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 3390|      0|  }
 3391|  4.89k|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 3392|  4.89k|  SetCachedSize(cached_size);
 3393|  4.89k|  return total_size;
 3394|  4.89k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece11TrainerSpecEJEEEPT_PS1_DpOT0_:
 3478|  9.97k|template<> PROTOBUF_NOINLINE ::sentencepiece::TrainerSpec* Arena::CreateMaybeMessage< ::sentencepiece::TrainerSpec >(Arena* arena) {
 3479|  9.97k|  return Arena::CreateMessageInternal< ::sentencepiece::TrainerSpec >(arena);
 3480|  9.97k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece14NormalizerSpecEJEEEPT_PS1_DpOT0_:
 3481|  9.97k|template<> PROTOBUF_NOINLINE ::sentencepiece::NormalizerSpec* Arena::CreateMaybeMessage< ::sentencepiece::NormalizerSpec >(Arena* arena) {
 3482|  9.97k|  return Arena::CreateMessageInternal< ::sentencepiece::NormalizerSpec >(arena);
 3483|  9.97k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece24ModelProto_SentencePieceEJEEEPT_PS1_DpOT0_:
 3490|  2.35M|template<> PROTOBUF_NOINLINE ::sentencepiece::ModelProto_SentencePiece* Arena::CreateMaybeMessage< ::sentencepiece::ModelProto_SentencePiece >(Arena* arena) {
 3491|  2.35M|  return Arena::CreateMessageInternal< ::sentencepiece::ModelProto_SentencePiece >(arena);
 3492|  2.35M|}
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|  20.1k|void TrainerSpec::SharedCtor() {
  491|  20.1k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TrainerSpec_sentencepiece_5fmodel_2eproto.base);
  492|  20.1k|  model_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  493|  20.1k|  input_format_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  494|  20.1k|  required_chars_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  495|  20.1k|  unk_surface_.UnsafeSetDefault(nullptr);
  496|  20.1k|  unk_piece_.UnsafeSetDefault(nullptr);
  497|  20.1k|  bos_piece_.UnsafeSetDefault(nullptr);
  498|  20.1k|  eos_piece_.UnsafeSetDefault(nullptr);
  499|  20.1k|  pad_piece_.UnsafeSetDefault(nullptr);
  500|  20.1k|  pretokenization_delimiter_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  501|  20.1k|  seed_sentencepieces_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  502|  20.1k|  ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
  503|  20.1k|      reinterpret_cast<char*>(&self_test_sample_size_) - reinterpret_cast<char*>(this)),
  504|  20.1k|      0, static_cast<size_t>(reinterpret_cast<char*>(&differential_privacy_clipping_threshold_) -
  505|  20.1k|      reinterpret_cast<char*>(&self_test_sample_size_)) + sizeof(differential_privacy_clipping_threshold_));
  506|  20.1k|  model_type_ = 1;
  507|  20.1k|  vocab_size_ = 8000;
  508|  20.1k|  character_coverage_ = 0.9995f;
  509|  20.1k|  seed_sentencepiece_size_ = 1000000;
  510|  20.1k|  shrinking_factor_ = 0.75f;
  511|  20.1k|  num_threads_ = 16;
  512|  20.1k|  num_sub_iterations_ = 2;
  513|  20.1k|  max_sentence_length_ = 4192;
  514|  20.1k|  max_sentencepiece_length_ = 16;
  515|  20.1k|  shuffle_input_sentence_ = true;
  516|  20.1k|  split_by_unicode_script_ = true;
  517|  20.1k|  split_by_number_ = true;
  518|  20.1k|  split_by_whitespace_ = true;
  519|  20.1k|  vocabulary_output_piece_score_ = true;
  520|  20.1k|  hard_vocab_limit_ = true;
  521|  20.1k|  bos_id_ = 1;
  522|  20.1k|  eos_id_ = 2;
  523|  20.1k|  pad_id_ = -1;
  524|  20.1k|}
_ZN13sentencepiece11TrainerSpec10SharedDtorEv:
  532|  37.1k|void TrainerSpec::SharedDtor() {
  533|  37.1k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  37.1k|#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: 37.1k]
  |  |  ------------------
  ------------------
  534|  37.1k|  model_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  535|  37.1k|  input_format_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  536|  37.1k|  required_chars_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  537|  37.1k|  unk_surface_.DestroyNoArena(nullptr);
  538|  37.1k|  unk_piece_.DestroyNoArena(nullptr);
  539|  37.1k|  bos_piece_.DestroyNoArena(nullptr);
  540|  37.1k|  eos_piece_.DestroyNoArena(nullptr);
  541|  37.1k|  pad_piece_.DestroyNoArena(nullptr);
  542|  37.1k|  pretokenization_delimiter_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  543|  37.1k|  seed_sentencepieces_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  544|  37.1k|}
_ZN13sentencepiece11TrainerSpec17RegisterArenaDtorEPN6google8protobuf5ArenaE:
  550|  20.1k|void TrainerSpec::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  551|  20.1k|}
_ZN13sentencepiece14NormalizerSpec10SharedCtorEv:
 1989|  40.3k|void NormalizerSpec::SharedCtor() {
 1990|  40.3k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NormalizerSpec_sentencepiece_5fmodel_2eproto.base);
 1991|  40.3k|  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1992|  40.3k|  precompiled_charsmap_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1993|  40.3k|  normalization_rule_tsv_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1994|  40.3k|  add_dummy_prefix_ = true;
 1995|  40.3k|  remove_extra_whitespaces_ = true;
 1996|  40.3k|  escape_whitespaces_ = true;
 1997|  40.3k|}
_ZN13sentencepiece14NormalizerSpec10SharedDtorEv:
 2005|  87.7k|void NormalizerSpec::SharedDtor() {
 2006|  87.7k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  87.7k|#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: 87.7k]
  |  |  ------------------
  ------------------
 2007|  87.7k|  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2008|  87.7k|  precompiled_charsmap_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2009|  87.7k|  normalization_rule_tsv_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2010|  87.7k|}
_ZN13sentencepiece14NormalizerSpec17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2016|  40.3k|void NormalizerSpec::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2017|  40.3k|}
_ZN13sentencepiece19SelfTestData_Sample10SharedCtorEv:
 2357|      1|void SelfTestData_Sample::SharedCtor() {
 2358|      1|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SelfTestData_Sample_sentencepiece_5fmodel_2eproto.base);
 2359|      1|  input_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2360|      1|  expected_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2361|      1|}
_ZN13sentencepiece19SelfTestData_Sample17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2379|      1|void SelfTestData_Sample::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2380|      1|}
_ZN13sentencepiece12SelfTestData10SharedCtorEv:
 2586|      1|void SelfTestData::SharedCtor() {
 2587|      1|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SelfTestData_sentencepiece_5fmodel_2eproto.base);
 2588|      1|}
_ZN13sentencepiece12SelfTestData17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2604|      1|void SelfTestData::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2605|      1|}
_ZN13sentencepiece24ModelProto_SentencePiece10SharedCtorEv:
 2807|  2.35M|void ModelProto_SentencePiece::SharedCtor() {
 2808|  2.35M|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ModelProto_SentencePiece_sentencepiece_5fmodel_2eproto.base);
 2809|  2.35M|  piece_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2810|  2.35M|  score_ = 0;
 2811|  2.35M|  type_ = 1;
 2812|  2.35M|}
_ZN13sentencepiece24ModelProto_SentencePiece10SharedDtorEv:
 2820|  2.35M|void ModelProto_SentencePiece::SharedDtor() {
 2821|  2.35M|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  2.35M|#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.35M]
  |  |  ------------------
  ------------------
 2822|  2.35M|  piece_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2823|  2.35M|}
_ZN13sentencepiece24ModelProto_SentencePiece17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2829|  2.35M|void ModelProto_SentencePiece::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2830|  2.35M|}
_ZN13sentencepiece10ModelProto10SharedCtorEv:
 3136|  17.0k|void ModelProto::SharedCtor() {
 3137|  17.0k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ModelProto_sentencepiece_5fmodel_2eproto.base);
 3138|  17.0k|  ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 3139|  17.0k|      reinterpret_cast<char*>(&trainer_spec_) - reinterpret_cast<char*>(this)),
 3140|  17.0k|      0, static_cast<size_t>(reinterpret_cast<char*>(&denormalizer_spec_) -
 3141|  17.0k|      reinterpret_cast<char*>(&trainer_spec_)) + sizeof(denormalizer_spec_));
 3142|  17.0k|}
_ZN13sentencepiece10ModelProto10SharedDtorEv:
 3150|  17.0k|void ModelProto::SharedDtor() {
 3151|  17.0k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  17.0k|#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: 17.0k]
  |  |  ------------------
  ------------------
 3152|  17.0k|  if (this != internal_default_instance()) delete trainer_spec_;
  ------------------
  |  Branch (3152:7): [True: 17.0k, False: 0]
  ------------------
 3153|  17.0k|  if (this != internal_default_instance()) delete normalizer_spec_;
  ------------------
  |  Branch (3153:7): [True: 17.0k, False: 0]
  ------------------
 3154|  17.0k|  if (this != internal_default_instance()) delete self_test_data_;
  ------------------
  |  Branch (3154:7): [True: 17.0k, False: 0]
  ------------------
 3155|  17.0k|  if (this != internal_default_instance()) delete denormalizer_spec_;
  ------------------
  |  Branch (3155:7): [True: 17.0k, False: 0]
  ------------------
 3156|  17.0k|}
_ZN13sentencepiece10ModelProto17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 3162|  17.0k|void ModelProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 3163|  17.0k|}

_ZN13sentencepiece11TrainerSpec14set_model_typeENS_21TrainerSpec_ModelTypeE:
 2309|  10.1k|inline void TrainerSpec::set_model_type(::sentencepiece::TrainerSpec_ModelType value) {
 2310|  10.1k|  _internal_set_model_type(value);
 2311|       |  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.model_type)
 2312|  10.1k|}
_ZN13sentencepiece11TrainerSpec24_internal_set_model_typeENS_21TrainerSpec_ModelTypeE:
 2304|  10.1k|inline void TrainerSpec::_internal_set_model_type(::sentencepiece::TrainerSpec_ModelType value) {
 2305|       |  assert(::sentencepiece::TrainerSpec_ModelType_IsValid(value));
 2306|  10.1k|  _has_bits_[0] |= 0x01000000u;
 2307|  10.1k|  model_type_ = value;
 2308|  10.1k|}
_ZN13sentencepiece11TrainerSpec14set_vocab_sizeEi:
 2337|  10.3k|inline void TrainerSpec::set_vocab_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
 2338|  10.3k|  _internal_set_vocab_size(value);
 2339|       |  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.vocab_size)
 2340|  10.3k|}
_ZN13sentencepiece11TrainerSpec24_internal_set_vocab_sizeEi:
 2333|  10.3k|inline void TrainerSpec::_internal_set_vocab_size(::PROTOBUF_NAMESPACE_ID::int32 value) {
 2334|  10.3k|  _has_bits_[0] |= 0x02000000u;
 2335|  10.3k|  vocab_size_ = value;
 2336|  10.3k|}
_ZN13sentencepiece11TrainerSpec22set_character_coverageEf:
 2551|  2.54k|inline void TrainerSpec::set_character_coverage(float value) {
 2552|  2.54k|  _internal_set_character_coverage(value);
 2553|       |  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.character_coverage)
 2554|  2.54k|}
_ZN13sentencepiece11TrainerSpec32_internal_set_character_coverageEf:
 2547|  2.54k|inline void TrainerSpec::_internal_set_character_coverage(float value) {
 2548|  2.54k|  _has_bits_[0] |= 0x04000000u;
 2549|  2.54k|  character_coverage_ = value;
 2550|  2.54k|}
_ZN13sentencepiece11TrainerSpec23set_input_sentence_sizeEm:
 2579|  2.04k|inline void TrainerSpec::set_input_sentence_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
 2580|  2.04k|  _internal_set_input_sentence_size(value);
 2581|       |  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.input_sentence_size)
 2582|  2.04k|}
_ZN13sentencepiece11TrainerSpec33_internal_set_input_sentence_sizeEm:
 2575|  2.04k|inline void TrainerSpec::_internal_set_input_sentence_size(::PROTOBUF_NAMESPACE_ID::uint64 value) {
 2576|  2.04k|  _has_bits_[0] |= 0x00001000u;
 2577|  2.04k|  input_sentence_size_ = value;
 2578|  2.04k|}
_ZN13sentencepiece11TrainerSpec26set_shuffle_input_sentenceEb:
 2607|  2.53k|inline void TrainerSpec::set_shuffle_input_sentence(bool value) {
 2608|  2.53k|  _internal_set_shuffle_input_sentence(value);
 2609|       |  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.shuffle_input_sentence)
 2610|  2.53k|}
_ZN13sentencepiece11TrainerSpec36_internal_set_shuffle_input_sentenceEb:
 2603|  2.53k|inline void TrainerSpec::_internal_set_shuffle_input_sentence(bool value) {
 2604|  2.53k|  _has_bits_[1] |= 0x00000002u;
 2605|  2.53k|  shuffle_input_sentence_ = value;
 2606|  2.53k|}
_ZN13sentencepiece11TrainerSpec15set_num_threadsEi:
 2775|  10.1k|inline void TrainerSpec::set_num_threads(::PROTOBUF_NAMESPACE_ID::int32 value) {
 2776|  10.1k|  _internal_set_num_threads(value);
 2777|       |  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.num_threads)
 2778|  10.1k|}
_ZN13sentencepiece11TrainerSpec25_internal_set_num_threadsEi:
 2771|  10.1k|inline void TrainerSpec::_internal_set_num_threads(::PROTOBUF_NAMESPACE_ID::int32 value) {
 2772|  10.1k|  _has_bits_[0] |= 0x20000000u;
 2773|  10.1k|  num_threads_ = value;
 2774|  10.1k|}
_ZN13sentencepiece11TrainerSpec27set_split_by_unicode_scriptEb:
 2859|  3.55k|inline void TrainerSpec::set_split_by_unicode_script(bool value) {
 2860|  3.55k|  _internal_set_split_by_unicode_script(value);
 2861|       |  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.split_by_unicode_script)
 2862|  3.55k|}
_ZN13sentencepiece11TrainerSpec37_internal_set_split_by_unicode_scriptEb:
 2855|  3.55k|inline void TrainerSpec::_internal_set_split_by_unicode_script(bool value) {
 2856|  3.55k|  _has_bits_[1] |= 0x00000004u;
 2857|  3.55k|  split_by_unicode_script_ = value;
 2858|  3.55k|}
_ZN13sentencepiece11TrainerSpec19set_split_by_numberEb:
 2887|  2.75k|inline void TrainerSpec::set_split_by_number(bool value) {
 2888|  2.75k|  _internal_set_split_by_number(value);
 2889|       |  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.split_by_number)
 2890|  2.75k|}
_ZN13sentencepiece11TrainerSpec29_internal_set_split_by_numberEb:
 2883|  2.75k|inline void TrainerSpec::_internal_set_split_by_number(bool value) {
 2884|  2.75k|  _has_bits_[1] |= 0x00000008u;
 2885|  2.75k|  split_by_number_ = value;
 2886|  2.75k|}
_ZN13sentencepiece11TrainerSpec23set_split_by_whitespaceEb:
 2915|  2.64k|inline void TrainerSpec::set_split_by_whitespace(bool value) {
 2916|  2.64k|  _internal_set_split_by_whitespace(value);
 2917|       |  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.split_by_whitespace)
 2918|  2.64k|}
_ZN13sentencepiece11TrainerSpec33_internal_set_split_by_whitespaceEb:
 2911|  2.64k|inline void TrainerSpec::_internal_set_split_by_whitespace(bool value) {
 2912|  2.64k|  _has_bits_[1] |= 0x00000010u;
 2913|  2.64k|  split_by_whitespace_ = value;
 2914|  2.64k|}
_ZN13sentencepiece11TrainerSpec17set_byte_fallbackEb:
 3321|  1.65k|inline void TrainerSpec::set_byte_fallback(bool value) {
 3322|  1.65k|  _internal_set_byte_fallback(value);
 3323|       |  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.byte_fallback)
 3324|  1.65k|}
_ZN13sentencepiece11TrainerSpec27_internal_set_byte_fallbackEb:
 3317|  1.65k|inline void TrainerSpec::_internal_set_byte_fallback(bool value) {
 3318|  1.65k|  _has_bits_[0] |= 0x00040000u;
 3319|  1.65k|  byte_fallback_ = value;
 3320|  1.65k|}
_ZN13sentencepiece14NormalizerSpec24set_precompiled_charsmapEPKvm:
 4114|  10.1k|    size_t size) {
 4115|  10.1k|  _has_bits_[0] |= 0x00000002u;
 4116|  10.1k|  precompiled_charsmap_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
 4117|  10.1k|      reinterpret_cast<const char*>(value), size), GetArena());
 4118|       |  // @@protoc_insertion_point(field_set_pointer:sentencepiece.NormalizerSpec.precompiled_charsmap)
 4119|  10.1k|}
_ZN13sentencepiece14NormalizerSpecC2Ev:
 1093|  40.3k|  inline NormalizerSpec() : NormalizerSpec(nullptr) {}
_ZNK13sentencepiece11TrainerSpec5inputEv:
 2129|  20.2k|TrainerSpec::input() const {
 2130|       |  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.input)
 2131|  20.2k|  return input_;
 2132|  20.2k|}
_ZNK13sentencepiece11TrainerSpec12input_formatEv:
 2151|  37.1k|inline const std::string& TrainerSpec::input_format() const {
 2152|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.input_format)
 2153|  37.1k|  return _internal_input_format();
 2154|  37.1k|}
_ZNK13sentencepiece11TrainerSpec22_internal_input_formatEv:
 2163|  37.1k|inline const std::string& TrainerSpec::_internal_input_format() const {
 2164|  37.1k|  return input_format_.Get();
 2165|  37.1k|}
_ZNK13sentencepiece11TrainerSpec12model_prefixEv:
 2224|  20.2k|inline const std::string& TrainerSpec::model_prefix() const {
 2225|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.model_prefix)
 2226|  20.2k|  return _internal_model_prefix();
 2227|  20.2k|}
_ZNK13sentencepiece11TrainerSpec22_internal_model_prefixEv:
 2236|  20.2k|inline const std::string& TrainerSpec::_internal_model_prefix() const {
 2237|  20.2k|  return model_prefix_.Get();
 2238|  20.2k|}
_ZNK13sentencepiece11TrainerSpec10model_typeEv:
 2300|  72.7k|inline ::sentencepiece::TrainerSpec_ModelType TrainerSpec::model_type() const {
 2301|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.model_type)
 2302|  72.7k|  return _internal_model_type();
 2303|  72.7k|}
_ZNK13sentencepiece11TrainerSpec20_internal_model_typeEv:
 2297|  82.5k|inline ::sentencepiece::TrainerSpec_ModelType TrainerSpec::_internal_model_type() const {
 2298|  82.5k|  return static_cast< ::sentencepiece::TrainerSpec_ModelType >(model_type_);
 2299|  82.5k|}
_ZNK13sentencepiece11TrainerSpec10vocab_sizeEv:
 2329|   676k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::vocab_size() const {
 2330|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.vocab_size)
 2331|   676k|  return _internal_vocab_size();
 2332|   676k|}
_ZNK13sentencepiece11TrainerSpec20_internal_vocab_sizeEv:
 2326|   686k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_vocab_size() const {
 2327|   686k|  return vocab_size_;
 2328|   686k|}
_ZNK13sentencepiece11TrainerSpec15accept_languageEv:
 2406|  10.1k|TrainerSpec::accept_language() const {
 2407|       |  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.accept_language)
 2408|  10.1k|  return accept_language_;
 2409|  10.1k|}
_ZNK13sentencepiece11TrainerSpec21self_test_sample_sizeEv:
 2431|  40.5k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::self_test_sample_size() const {
 2432|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.self_test_sample_size)
 2433|  40.5k|  return _internal_self_test_sample_size();
 2434|  40.5k|}
_ZNK13sentencepiece11TrainerSpec31_internal_self_test_sample_sizeEv:
 2428|  40.5k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_self_test_sample_size() const {
 2429|  40.5k|  return self_test_sample_size_;
 2430|  40.5k|}
_ZNK13sentencepiece11TrainerSpec18character_coverageEv:
 2543|   331k|inline float TrainerSpec::character_coverage() const {
 2544|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.character_coverage)
 2545|   331k|  return _internal_character_coverage();
 2546|   331k|}
_ZNK13sentencepiece11TrainerSpec28_internal_character_coverageEv:
 2540|   333k|inline float TrainerSpec::_internal_character_coverage() const {
 2541|   333k|  return character_coverage_;
 2542|   333k|}
_ZNK13sentencepiece11TrainerSpec19input_sentence_sizeEv:
 2571|   108k|inline ::PROTOBUF_NAMESPACE_ID::uint64 TrainerSpec::input_sentence_size() const {
 2572|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.input_sentence_size)
 2573|   108k|  return _internal_input_sentence_size();
 2574|   108k|}
_ZNK13sentencepiece11TrainerSpec29_internal_input_sentence_sizeEv:
 2568|   110k|inline ::PROTOBUF_NAMESPACE_ID::uint64 TrainerSpec::_internal_input_sentence_size() const {
 2569|   110k|  return input_sentence_size_;
 2570|   110k|}
_ZNK13sentencepiece11TrainerSpec22shuffle_input_sentenceEv:
 2599|  31.0k|inline bool TrainerSpec::shuffle_input_sentence() const {
 2600|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.shuffle_input_sentence)
 2601|  31.0k|  return _internal_shuffle_input_sentence();
 2602|  31.0k|}
_ZNK13sentencepiece11TrainerSpec32_internal_shuffle_input_sentenceEv:
 2596|  32.4k|inline bool TrainerSpec::_internal_shuffle_input_sentence() const {
 2597|  32.4k|  return shuffle_input_sentence_;
 2598|  32.4k|}
_ZNK13sentencepiece11TrainerSpec23seed_sentencepiece_sizeEv:
 2683|  16.9k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::seed_sentencepiece_size() const {
 2684|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.seed_sentencepiece_size)
 2685|  16.9k|  return _internal_seed_sentencepiece_size();
 2686|  16.9k|}
_ZNK13sentencepiece11TrainerSpec33_internal_seed_sentencepiece_sizeEv:
 2680|  16.9k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_seed_sentencepiece_size() const {
 2681|  16.9k|  return seed_sentencepiece_size_;
 2682|  16.9k|}
_ZNK13sentencepiece11TrainerSpec16shrinking_factorEv:
 2711|  41.0k|inline float TrainerSpec::shrinking_factor() const {
 2712|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.shrinking_factor)
 2713|  41.0k|  return _internal_shrinking_factor();
 2714|  41.0k|}
_ZNK13sentencepiece11TrainerSpec26_internal_shrinking_factorEv:
 2708|  41.0k|inline float TrainerSpec::_internal_shrinking_factor() const {
 2709|  41.0k|  return shrinking_factor_;
 2710|  41.0k|}
_ZNK13sentencepiece11TrainerSpec19max_sentence_lengthEv:
 2739|  96.1k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::max_sentence_length() const {
 2740|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.max_sentence_length)
 2741|  96.1k|  return _internal_max_sentence_length();
 2742|  96.1k|}
_ZNK13sentencepiece11TrainerSpec29_internal_max_sentence_lengthEv:
 2736|  96.1k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_max_sentence_length() const {
 2737|  96.1k|  return max_sentence_length_;
 2738|  96.1k|}
_ZNK13sentencepiece11TrainerSpec11num_threadsEv:
 2767|  2.81M|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::num_threads() const {
 2768|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.num_threads)
 2769|  2.81M|  return _internal_num_threads();
 2770|  2.81M|}
_ZNK13sentencepiece11TrainerSpec21_internal_num_threadsEv:
 2764|  2.82M|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_num_threads() const {
 2765|  2.82M|  return num_threads_;
 2766|  2.82M|}
_ZNK13sentencepiece11TrainerSpec18num_sub_iterationsEv:
 2795|  82.7k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::num_sub_iterations() const {
 2796|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.num_sub_iterations)
 2797|  82.7k|  return _internal_num_sub_iterations();
 2798|  82.7k|}
_ZNK13sentencepiece11TrainerSpec28_internal_num_sub_iterationsEv:
 2792|  82.7k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_num_sub_iterations() const {
 2793|  82.7k|  return num_sub_iterations_;
 2794|  82.7k|}
_ZNK13sentencepiece11TrainerSpec24max_sentencepiece_lengthEv:
 2823|  11.4M|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::max_sentencepiece_length() const {
 2824|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.max_sentencepiece_length)
 2825|  11.4M|  return _internal_max_sentencepiece_length();
 2826|  11.4M|}
_ZNK13sentencepiece11TrainerSpec34_internal_max_sentencepiece_lengthEv:
 2820|  11.4M|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_max_sentencepiece_length() const {
 2821|  11.4M|  return max_sentencepiece_length_;
 2822|  11.4M|}
_ZNK13sentencepiece11TrainerSpec23split_by_unicode_scriptEv:
 2851|  32.6M|inline bool TrainerSpec::split_by_unicode_script() const {
 2852|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.split_by_unicode_script)
 2853|  32.6M|  return _internal_split_by_unicode_script();
 2854|  32.6M|}
_ZNK13sentencepiece11TrainerSpec33_internal_split_by_unicode_scriptEv:
 2848|  32.6M|inline bool TrainerSpec::_internal_split_by_unicode_script() const {
 2849|  32.6M|  return split_by_unicode_script_;
 2850|  32.6M|}
_ZNK13sentencepiece11TrainerSpec15split_by_numberEv:
 2879|  32.6M|inline bool TrainerSpec::split_by_number() const {
 2880|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.split_by_number)
 2881|  32.6M|  return _internal_split_by_number();
 2882|  32.6M|}
_ZNK13sentencepiece11TrainerSpec25_internal_split_by_numberEv:
 2876|  32.6M|inline bool TrainerSpec::_internal_split_by_number() const {
 2877|  32.6M|  return split_by_number_;
 2878|  32.6M|}
_ZNK13sentencepiece11TrainerSpec19split_by_whitespaceEv:
 2907|  16.5M|inline bool TrainerSpec::split_by_whitespace() const {
 2908|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.split_by_whitespace)
 2909|  16.5M|  return _internal_split_by_whitespace();
 2910|  16.5M|}
_ZNK13sentencepiece11TrainerSpec29_internal_split_by_whitespaceEv:
 2904|  16.5M|inline bool TrainerSpec::_internal_split_by_whitespace() const {
 2905|  16.5M|  return split_by_whitespace_;
 2906|  16.5M|}
_ZNK13sentencepiece11TrainerSpec12split_digitsEv:
 2991|  32.6M|inline bool TrainerSpec::split_digits() const {
 2992|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.split_digits)
 2993|  32.6M|  return _internal_split_digits();
 2994|  32.6M|}
_ZNK13sentencepiece11TrainerSpec22_internal_split_digitsEv:
 2988|  32.6M|inline bool TrainerSpec::_internal_split_digits() const {
 2989|  32.6M|  return split_digits_;
 2990|  32.6M|}
_ZNK13sentencepiece11TrainerSpec25pretokenization_delimiterEv:
 3016|  63.4k|inline const std::string& TrainerSpec::pretokenization_delimiter() const {
 3017|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.pretokenization_delimiter)
 3018|  63.4k|  return _internal_pretokenization_delimiter();
 3019|  63.4k|}
_ZNK13sentencepiece11TrainerSpec35_internal_pretokenization_delimiterEv:
 3028|  63.4k|inline const std::string& TrainerSpec::_internal_pretokenization_delimiter() const {
 3029|  63.4k|  return pretokenization_delimiter_.Get();
 3030|  63.4k|}
_ZNK13sentencepiece11TrainerSpec26treat_whitespace_as_suffixEv:
 2935|  10.6M|inline bool TrainerSpec::treat_whitespace_as_suffix() const {
 2936|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.treat_whitespace_as_suffix)
 2937|  10.6M|  return _internal_treat_whitespace_as_suffix();
 2938|  10.6M|}
_ZNK13sentencepiece11TrainerSpec36_internal_treat_whitespace_as_suffixEv:
 2932|  10.6M|inline bool TrainerSpec::_internal_treat_whitespace_as_suffix() const {
 2933|  10.6M|  return treat_whitespace_as_suffix_;
 2934|  10.6M|}
_ZNK13sentencepiece11TrainerSpec28allow_whitespace_only_piecesEv:
 2963|  10.5M|inline bool TrainerSpec::allow_whitespace_only_pieces() const {
 2964|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.allow_whitespace_only_pieces)
 2965|  10.5M|  return _internal_allow_whitespace_only_pieces();
 2966|  10.5M|}
_ZNK13sentencepiece11TrainerSpec38_internal_allow_whitespace_only_piecesEv:
 2960|  10.5M|inline bool TrainerSpec::_internal_allow_whitespace_only_pieces() const {
 2961|  10.5M|  return allow_whitespace_only_pieces_;
 2962|  10.5M|}
_ZNK13sentencepiece11TrainerSpec15control_symbolsEv:
 3141|  20.2k|TrainerSpec::control_symbols() const {
 3142|       |  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.control_symbols)
 3143|  20.2k|  return control_symbols_;
 3144|  20.2k|}
_ZNK13sentencepiece11TrainerSpec20user_defined_symbolsEv:
 3215|  20.2k|TrainerSpec::user_defined_symbols() const {
 3216|       |  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.user_defined_symbols)
 3217|  20.2k|  return user_defined_symbols_;
 3218|  20.2k|}
_ZNK13sentencepiece11TrainerSpec14required_charsEv:
 3237|  20.2k|inline const std::string& TrainerSpec::required_chars() const {
 3238|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.required_chars)
 3239|  20.2k|  return _internal_required_chars();
 3240|  20.2k|}
_ZNK13sentencepiece11TrainerSpec24_internal_required_charsEv:
 3249|  20.2k|inline const std::string& TrainerSpec::_internal_required_chars() const {
 3250|  20.2k|  return required_chars_.Get();
 3251|  20.2k|}
_ZNK13sentencepiece11TrainerSpec13byte_fallbackEv:
 3313|  20.2k|inline bool TrainerSpec::byte_fallback() const {
 3314|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.byte_fallback)
 3315|  20.2k|  return _internal_byte_fallback();
 3316|  20.2k|}
_ZNK13sentencepiece11TrainerSpec23_internal_byte_fallbackEv:
 3310|  21.1k|inline bool TrainerSpec::_internal_byte_fallback() const {
 3311|  21.1k|  return byte_fallback_;
 3312|  21.1k|}
_ZNK13sentencepiece11TrainerSpec29vocabulary_output_piece_scoreEv:
 3341|  10.1k|inline bool TrainerSpec::vocabulary_output_piece_score() const {
 3342|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.vocabulary_output_piece_score)
 3343|  10.1k|  return _internal_vocabulary_output_piece_score();
 3344|  10.1k|}
_ZNK13sentencepiece11TrainerSpec39_internal_vocabulary_output_piece_scoreEv:
 3338|  10.1k|inline bool TrainerSpec::_internal_vocabulary_output_piece_score() const {
 3339|  10.1k|  return vocabulary_output_piece_score_;
 3340|  10.1k|}
_ZNK13sentencepiece11TrainerSpec28train_extremely_large_corpusEv:
 3907|  16.9k|inline bool TrainerSpec::train_extremely_large_corpus() const {
 3908|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.train_extremely_large_corpus)
 3909|  16.9k|  return _internal_train_extremely_large_corpus();
 3910|  16.9k|}
_ZNK13sentencepiece11TrainerSpec38_internal_train_extremely_large_corpusEv:
 3904|  16.9k|inline bool TrainerSpec::_internal_train_extremely_large_corpus() const {
 3905|  16.9k|  return train_extremely_large_corpus_;
 3906|  16.9k|}
_ZNK13sentencepiece11TrainerSpec24seed_sentencepieces_fileEv:
 3932|  27.0k|inline const std::string& TrainerSpec::seed_sentencepieces_file() const {
 3933|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.seed_sentencepieces_file)
 3934|  27.0k|  return _internal_seed_sentencepieces_file();
 3935|  27.0k|}
_ZNK13sentencepiece11TrainerSpec34_internal_seed_sentencepieces_fileEv:
 3944|  27.0k|inline const std::string& TrainerSpec::_internal_seed_sentencepieces_file() const {
 3945|  27.0k|  return seed_sentencepieces_file_.Get();
 3946|  27.0k|}
_ZNK13sentencepiece11TrainerSpec16hard_vocab_limitEv:
 3369|  20.1k|inline bool TrainerSpec::hard_vocab_limit() const {
 3370|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.hard_vocab_limit)
 3371|  20.1k|  return _internal_hard_vocab_limit();
 3372|  20.1k|}
_ZNK13sentencepiece11TrainerSpec26_internal_hard_vocab_limitEv:
 3366|  20.1k|inline bool TrainerSpec::_internal_hard_vocab_limit() const {
 3367|  20.1k|  return hard_vocab_limit_;
 3368|  20.1k|}
_ZNK13sentencepiece11TrainerSpec13use_all_vocabEv:
 3397|   357k|inline bool TrainerSpec::use_all_vocab() const {
 3398|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.use_all_vocab)
 3399|   357k|  return _internal_use_all_vocab();
 3400|   357k|}
_ZNK13sentencepiece11TrainerSpec23_internal_use_all_vocabEv:
 3394|   357k|inline bool TrainerSpec::_internal_use_all_vocab() const {
 3395|   357k|  return use_all_vocab_;
 3396|   357k|}
_ZNK13sentencepiece11TrainerSpec6unk_idEv:
 3425|  20.2k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::unk_id() const {
 3426|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_id)
 3427|  20.2k|  return _internal_unk_id();
 3428|  20.2k|}
_ZNK13sentencepiece11TrainerSpec16_internal_unk_idEv:
 3422|  20.2k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_unk_id() const {
 3423|  20.2k|  return unk_id_;
 3424|  20.2k|}
_ZNK13sentencepiece11TrainerSpec6bos_idEv:
 3453|  20.2k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::bos_id() const {
 3454|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.bos_id)
 3455|  20.2k|  return _internal_bos_id();
 3456|  20.2k|}
_ZNK13sentencepiece11TrainerSpec16_internal_bos_idEv:
 3450|  20.2k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_bos_id() const {
 3451|  20.2k|  return bos_id_;
 3452|  20.2k|}
_ZNK13sentencepiece11TrainerSpec6eos_idEv:
 3481|  20.2k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::eos_id() const {
 3482|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.eos_id)
 3483|  20.2k|  return _internal_eos_id();
 3484|  20.2k|}
_ZNK13sentencepiece11TrainerSpec16_internal_eos_idEv:
 3478|  20.2k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_eos_id() const {
 3479|  20.2k|  return eos_id_;
 3480|  20.2k|}
_ZNK13sentencepiece11TrainerSpec6pad_idEv:
 3509|  20.2k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::pad_id() const {
 3510|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.pad_id)
 3511|  20.2k|  return _internal_pad_id();
 3512|  20.2k|}
_ZNK13sentencepiece11TrainerSpec16_internal_pad_idEv:
 3506|  20.2k|inline ::PROTOBUF_NAMESPACE_ID::int32 TrainerSpec::_internal_pad_id() const {
 3507|  20.2k|  return pad_id_;
 3508|  20.2k|}
_ZNK13sentencepiece11TrainerSpec9unk_pieceEv:
 3534|   133k|inline const std::string& TrainerSpec::unk_piece() const {
 3535|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_piece)
 3536|   133k|  if (unk_piece_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_unk_piece_.get();
  ------------------
  |  Branch (3536:7): [True: 133k, False: 0]
  ------------------
 3537|      0|  return _internal_unk_piece();
 3538|   133k|}
_ZNK13sentencepiece11TrainerSpec9bos_pieceEv:
 3608|  52.3k|inline const std::string& TrainerSpec::bos_piece() const {
 3609|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.bos_piece)
 3610|  52.3k|  if (bos_piece_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_bos_piece_.get();
  ------------------
  |  Branch (3610:7): [True: 52.3k, False: 0]
  ------------------
 3611|      0|  return _internal_bos_piece();
 3612|  52.3k|}
_ZNK13sentencepiece11TrainerSpec9eos_pieceEv:
 3682|  52.3k|inline const std::string& TrainerSpec::eos_piece() const {
 3683|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.eos_piece)
 3684|  52.3k|  if (eos_piece_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_eos_piece_.get();
  ------------------
  |  Branch (3684:7): [True: 52.3k, False: 0]
  ------------------
 3685|      0|  return _internal_eos_piece();
 3686|  52.3k|}
_ZNK13sentencepiece11TrainerSpec9pad_pieceEv:
 3756|  52.3k|inline const std::string& TrainerSpec::pad_piece() const {
 3757|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.pad_piece)
 3758|  52.3k|  if (pad_piece_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_pad_piece_.get();
  ------------------
  |  Branch (3758:7): [True: 52.3k, False: 0]
  ------------------
 3759|      0|  return _internal_pad_piece();
 3760|  52.3k|}
_ZNK13sentencepiece11TrainerSpec11unk_surfaceEv:
 3830|  10.1k|inline const std::string& TrainerSpec::unk_surface() const {
 3831|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_surface)
 3832|  10.1k|  if (unk_surface_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_unk_surface_.get();
  ------------------
  |  Branch (3832:7): [True: 10.1k, False: 0]
  ------------------
 3833|      0|  return _internal_unk_surface();
 3834|  10.1k|}
_ZNK13sentencepiece11TrainerSpec27enable_differential_privacyEv:
 2459|  20.2k|inline bool TrainerSpec::enable_differential_privacy() const {
 2460|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.enable_differential_privacy)
 2461|  20.2k|  return _internal_enable_differential_privacy();
 2462|  20.2k|}
_ZNK13sentencepiece11TrainerSpec37_internal_enable_differential_privacyEv:
 2456|  20.2k|inline bool TrainerSpec::_internal_enable_differential_privacy() const {
 2457|  20.2k|  return enable_differential_privacy_;
 2458|  20.2k|}
_ZNK13sentencepiece11TrainerSpec32differential_privacy_noise_levelEv:
 2487|  10.1k|inline float TrainerSpec::differential_privacy_noise_level() const {
 2488|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.differential_privacy_noise_level)
 2489|  10.1k|  return _internal_differential_privacy_noise_level();
 2490|  10.1k|}
_ZNK13sentencepiece11TrainerSpec42_internal_differential_privacy_noise_levelEv:
 2484|  10.1k|inline float TrainerSpec::_internal_differential_privacy_noise_level() const {
 2485|  10.1k|  return differential_privacy_noise_level_;
 2486|  10.1k|}
_ZNK13sentencepiece11TrainerSpec39differential_privacy_clipping_thresholdEv:
 2515|  10.1k|inline ::PROTOBUF_NAMESPACE_ID::uint64 TrainerSpec::differential_privacy_clipping_threshold() const {
 2516|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.differential_privacy_clipping_threshold)
 2517|  10.1k|  return _internal_differential_privacy_clipping_threshold();
 2518|  10.1k|}
_ZNK13sentencepiece11TrainerSpec49_internal_differential_privacy_clipping_thresholdEv:
 2512|  10.1k|inline ::PROTOBUF_NAMESPACE_ID::uint64 TrainerSpec::_internal_differential_privacy_clipping_threshold() const {
 2513|  10.1k|  return differential_privacy_clipping_threshold_;
 2514|  10.1k|}
_ZNK13sentencepiece14NormalizerSpec16add_dummy_prefixEv:
 4158|  74.7k|inline bool NormalizerSpec::add_dummy_prefix() const {
 4159|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.add_dummy_prefix)
 4160|  74.7k|  return _internal_add_dummy_prefix();
 4161|  74.7k|}
_ZNK13sentencepiece14NormalizerSpec26_internal_add_dummy_prefixEv:
 4155|  74.7k|inline bool NormalizerSpec::_internal_add_dummy_prefix() const {
 4156|  74.7k|  return add_dummy_prefix_;
 4157|  74.7k|}
_ZNK13sentencepiece14NormalizerSpec24remove_extra_whitespacesEv:
 4186|  10.1M|inline bool NormalizerSpec::remove_extra_whitespaces() const {
 4187|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.remove_extra_whitespaces)
 4188|  10.1M|  return _internal_remove_extra_whitespaces();
 4189|  10.1M|}
_ZNK13sentencepiece14NormalizerSpec34_internal_remove_extra_whitespacesEv:
 4183|  10.1M|inline bool NormalizerSpec::_internal_remove_extra_whitespaces() const {
 4184|  10.1M|  return remove_extra_whitespaces_;
 4185|  10.1M|}
_ZNK13sentencepiece14NormalizerSpec18escape_whitespacesEv:
 4214|  84.8k|inline bool NormalizerSpec::escape_whitespaces() const {
 4215|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.escape_whitespaces)
 4216|  84.8k|  return _internal_escape_whitespaces();
 4217|  84.8k|}
_ZNK13sentencepiece14NormalizerSpec28_internal_escape_whitespacesEv:
 4211|  84.8k|inline bool NormalizerSpec::_internal_escape_whitespaces() const {
 4212|  84.8k|  return escape_whitespaces_;
 4213|  84.8k|}
_ZNK13sentencepiece14NormalizerSpec20precompiled_charsmapEv:
 4082|  40.5k|inline const std::string& NormalizerSpec::precompiled_charsmap() const {
 4083|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.precompiled_charsmap)
 4084|  40.5k|  return _internal_precompiled_charsmap();
 4085|  40.5k|}
_ZNK13sentencepiece14NormalizerSpec30_internal_precompiled_charsmapEv:
 4094|  77.3k|inline const std::string& NormalizerSpec::_internal_precompiled_charsmap() const {
 4095|  77.3k|  return precompiled_charsmap_.Get();
 4096|  77.3k|}
_ZN13sentencepiece10ModelProtoC2Ev:
 1836|  17.0k|  inline ModelProto() : ModelProto(nullptr) {}
_ZNK13sentencepiece14NormalizerSpec4nameEv:
 4009|  30.3k|inline const std::string& NormalizerSpec::name() const {
 4010|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.name)
 4011|  30.3k|  return _internal_name();
 4012|  30.3k|}
_ZNK13sentencepiece14NormalizerSpec14_internal_nameEv:
 4021|  67.1k|inline const std::string& NormalizerSpec::_internal_name() const {
 4022|  67.1k|  return name_.Get();
 4023|  67.1k|}
_ZN13sentencepiece14NormalizerSpec28mutable_precompiled_charsmapEv:
 4090|  10.1k|inline std::string* NormalizerSpec::mutable_precompiled_charsmap() {
 4091|       |  // @@protoc_insertion_point(field_mutable:sentencepiece.NormalizerSpec.precompiled_charsmap)
 4092|  10.1k|  return _internal_mutable_precompiled_charsmap();
 4093|  10.1k|}
_ZN13sentencepiece14NormalizerSpec38_internal_mutable_precompiled_charsmapEv:
 4120|  10.1k|inline std::string* NormalizerSpec::_internal_mutable_precompiled_charsmap() {
 4121|  10.1k|  _has_bits_[0] |= 0x00000002u;
 4122|  10.1k|  return precompiled_charsmap_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 4123|  10.1k|}
_ZN13sentencepiece14NormalizerSpec18_internal_set_nameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 4024|  9.97k|inline void NormalizerSpec::_internal_set_name(const std::string& value) {
 4025|  9.97k|  _has_bits_[0] |= 0x00000001u;
 4026|  9.97k|  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 4027|  9.97k|}
_ZN13sentencepiece11TrainerSpecC2Ev:
  133|  20.1k|  inline TrainerSpec() : TrainerSpec(nullptr) {}
_ZNK13sentencepiece14NormalizerSpec22normalization_rule_tsvEv:
 4239|  40.3k|inline const std::string& NormalizerSpec::normalization_rule_tsv() const {
 4240|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.normalization_rule_tsv)
 4241|  40.3k|  return _internal_normalization_rule_tsv();
 4242|  40.3k|}
_ZNK13sentencepiece14NormalizerSpec32_internal_normalization_rule_tsvEv:
 4251|  40.3k|inline const std::string& NormalizerSpec::_internal_normalization_rule_tsv() const {
 4252|  40.3k|  return normalization_rule_tsv_.Get();
 4253|  40.3k|}
_ZN13sentencepiece14NormalizerSpec8set_nameEPKc:
 4034|  10.1k|inline void NormalizerSpec::set_name(const char* value) {
 4035|  10.1k|  GOOGLE_DCHECK(value != nullptr);
  ------------------
  |  |  181|  10.1k|#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.1k]
  |  |  ------------------
  ------------------
 4036|  10.1k|  _has_bits_[0] |= 0x00000001u;
 4037|  10.1k|  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
 4038|       |  // @@protoc_insertion_point(field_set_char:sentencepiece.NormalizerSpec.name)
 4039|  10.1k|}
_ZN13sentencepiece10ModelProto23mutable_normalizer_specEv:
 4812|  9.97k|inline ::sentencepiece::NormalizerSpec* ModelProto::mutable_normalizer_spec() {
 4813|       |  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.normalizer_spec)
 4814|  9.97k|  return _internal_mutable_normalizer_spec();
 4815|  9.97k|}
_ZN13sentencepiece10ModelProto33_internal_mutable_normalizer_specEv:
 4804|  9.97k|inline ::sentencepiece::NormalizerSpec* ModelProto::_internal_mutable_normalizer_spec() {
 4805|  9.97k|  _has_bits_[0] |= 0x00000002u;
 4806|  9.97k|  if (normalizer_spec_ == nullptr) {
  ------------------
  |  Branch (4806:7): [True: 9.97k, False: 0]
  ------------------
 4807|  9.97k|    auto* p = CreateMaybeMessage<::sentencepiece::NormalizerSpec>(GetArena());
 4808|  9.97k|    normalizer_spec_ = p;
 4809|  9.97k|  }
 4810|  9.97k|  return normalizer_spec_;
 4811|  9.97k|}
_ZN13sentencepiece11TrainerSpecaSERKS0_:
  142|  9.97k|  inline TrainerSpec& operator=(const TrainerSpec& from) {
  143|  9.97k|    CopyFrom(from);
  144|  9.97k|    return *this;
  145|  9.97k|  }
_ZNK13sentencepiece11TrainerSpec13GetCachedSizeEv:
  209|  4.89k|  int GetCachedSize() const final { return _cached_size_.Get(); }
_ZN13sentencepiece14NormalizerSpecaSERKS0_:
 1102|  9.97k|  inline NormalizerSpec& operator=(const NormalizerSpec& from) {
 1103|  9.97k|    CopyFrom(from);
 1104|  9.97k|    return *this;
 1105|  9.97k|  }
_ZNK13sentencepiece14NormalizerSpec13GetCachedSizeEv:
 1169|  4.89k|  int GetCachedSize() const final { return _cached_size_.Get(); }
_ZN13sentencepiece19SelfTestData_SampleC2Ev:
 1325|      1|  inline SelfTestData_Sample() : SelfTestData_Sample(nullptr) {}
_ZN13sentencepiece12SelfTestDataC2Ev:
 1487|      1|  inline SelfTestData() : SelfTestData(nullptr) {}
_ZN13sentencepiece24ModelProto_SentencePieceC2Ev:
 1629|  2.35M|  inline ModelProto_SentencePiece() : ModelProto_SentencePiece(nullptr) {}
_ZNK13sentencepiece24ModelProto_SentencePiece13GetCachedSizeEv:
 1705|   287k|  int GetCachedSize() const final { return _cached_size_.Get(); }
_ZN13sentencepiece10ModelProto25internal_default_instanceEv:
 1867|  68.1k|  static inline const ModelProto* internal_default_instance() {
 1868|  68.1k|    return reinterpret_cast<const ModelProto*>(
 1869|  68.1k|               &_ModelProto_default_instance_);
 1870|  68.1k|  }
_ZNK13sentencepiece11TrainerSpec20_internal_input_sizeEv:
 2066|  4.89k|inline int TrainerSpec::_internal_input_size() const {
 2067|  4.89k|  return input_.size();
 2068|  4.89k|}
_ZNK13sentencepiece11TrainerSpec26_internal_has_input_formatEv:
 2140|  17.0k|inline bool TrainerSpec::_internal_has_input_format() const {
 2141|  17.0k|  bool value = (_has_bits_[0] & 0x00000002u) != 0;
 2142|  17.0k|  return value;
 2143|  17.0k|}
_ZNK13sentencepiece11TrainerSpec26_internal_has_model_prefixEv:
 2213|  17.0k|inline bool TrainerSpec::_internal_has_model_prefix() const {
 2214|  17.0k|  bool value = (_has_bits_[0] & 0x00000001u) != 0;
 2215|  17.0k|  return value;
 2216|  17.0k|}
_ZNK13sentencepiece11TrainerSpec30_internal_accept_language_sizeEv:
 2343|  4.89k|inline int TrainerSpec::_internal_accept_language_size() const {
 2344|  4.89k|  return accept_language_.size();
 2345|  4.89k|}
_ZNK13sentencepiece11TrainerSpec39_internal_has_pretokenization_delimiterEv:
 3005|  17.0k|inline bool TrainerSpec::_internal_has_pretokenization_delimiter() const {
 3006|  17.0k|  bool value = (_has_bits_[0] & 0x00000100u) != 0;
 3007|  17.0k|  return value;
 3008|  17.0k|}
_ZNK13sentencepiece11TrainerSpec30_internal_control_symbols_sizeEv:
 3078|  4.89k|inline int TrainerSpec::_internal_control_symbols_size() const {
 3079|  4.89k|  return control_symbols_.size();
 3080|  4.89k|}
_ZNK13sentencepiece11TrainerSpec35_internal_user_defined_symbols_sizeEv:
 3152|  4.89k|inline int TrainerSpec::_internal_user_defined_symbols_size() const {
 3153|  4.89k|  return user_defined_symbols_.size();
 3154|  4.89k|}
_ZNK13sentencepiece11TrainerSpec28_internal_has_required_charsEv:
 3226|  17.0k|inline bool TrainerSpec::_internal_has_required_chars() const {
 3227|  17.0k|  bool value = (_has_bits_[0] & 0x00000004u) != 0;
 3228|  17.0k|  return value;
 3229|  17.0k|}
_ZNK13sentencepiece11TrainerSpec23_internal_has_unk_pieceEv:
 3523|  17.0k|inline bool TrainerSpec::_internal_has_unk_piece() const {
 3524|  17.0k|  bool value = (_has_bits_[0] & 0x00000010u) != 0;
 3525|  17.0k|  return value;
 3526|  17.0k|}
_ZNK13sentencepiece11TrainerSpec23_internal_has_bos_pieceEv:
 3597|  17.0k|inline bool TrainerSpec::_internal_has_bos_piece() const {
 3598|  17.0k|  bool value = (_has_bits_[0] & 0x00000020u) != 0;
 3599|  17.0k|  return value;
 3600|  17.0k|}
_ZNK13sentencepiece11TrainerSpec23_internal_has_eos_pieceEv:
 3671|  17.0k|inline bool TrainerSpec::_internal_has_eos_piece() const {
 3672|  17.0k|  bool value = (_has_bits_[0] & 0x00000040u) != 0;
 3673|  17.0k|  return value;
 3674|  17.0k|}
_ZNK13sentencepiece11TrainerSpec23_internal_has_pad_pieceEv:
 3745|  17.0k|inline bool TrainerSpec::_internal_has_pad_piece() const {
 3746|  17.0k|  bool value = (_has_bits_[0] & 0x00000080u) != 0;
 3747|  17.0k|  return value;
 3748|  17.0k|}
_ZNK13sentencepiece11TrainerSpec25_internal_has_unk_surfaceEv:
 3819|  17.0k|inline bool TrainerSpec::_internal_has_unk_surface() const {
 3820|  17.0k|  bool value = (_has_bits_[0] & 0x00000008u) != 0;
 3821|  17.0k|  return value;
 3822|  17.0k|}
_ZNK13sentencepiece11TrainerSpec38_internal_has_seed_sentencepieces_fileEv:
 3921|  17.0k|inline bool TrainerSpec::_internal_has_seed_sentencepieces_file() const {
 3922|  17.0k|  bool value = (_has_bits_[0] & 0x00000200u) != 0;
 3923|  17.0k|  return value;
 3924|  17.0k|}
_ZNK13sentencepiece14NormalizerSpec18_internal_has_nameEv:
 3998|  47.4k|inline bool NormalizerSpec::_internal_has_name() const {
 3999|  47.4k|  bool value = (_has_bits_[0] & 0x00000001u) != 0;
 4000|  47.4k|  return value;
 4001|  47.4k|}
_ZNK13sentencepiece14NormalizerSpec34_internal_has_precompiled_charsmapEv:
 4071|  47.4k|inline bool NormalizerSpec::_internal_has_precompiled_charsmap() const {
 4072|  47.4k|  bool value = (_has_bits_[0] & 0x00000002u) != 0;
 4073|  47.4k|  return value;
 4074|  47.4k|}
_ZN13sentencepiece14NormalizerSpec34_internal_set_precompiled_charsmapERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 4097|  9.97k|inline void NormalizerSpec::_internal_set_precompiled_charsmap(const std::string& value) {
 4098|  9.97k|  _has_bits_[0] |= 0x00000002u;
 4099|  9.97k|  precompiled_charsmap_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 4100|  9.97k|}
_ZNK13sentencepiece14NormalizerSpec36_internal_has_normalization_rule_tsvEv:
 4228|  47.4k|inline bool NormalizerSpec::_internal_has_normalization_rule_tsv() const {
 4229|  47.4k|  bool value = (_has_bits_[0] & 0x00000004u) != 0;
 4230|  47.4k|  return value;
 4231|  47.4k|}
_ZNK13sentencepiece24ModelProto_SentencePiece5pieceEv:
 4509|  1.21M|inline const std::string& ModelProto_SentencePiece::piece() const {
 4510|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.piece)
 4511|  1.21M|  return _internal_piece();
 4512|  1.21M|}
_ZN13sentencepiece24ModelProto_SentencePiece9set_pieceERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 4513|   405k|inline void ModelProto_SentencePiece::set_piece(const std::string& value) {
 4514|   405k|  _internal_set_piece(value);
 4515|       |  // @@protoc_insertion_point(field_set:sentencepiece.ModelProto.SentencePiece.piece)
 4516|   405k|}
_ZNK13sentencepiece24ModelProto_SentencePiece15_internal_pieceEv:
 4521|  1.79M|inline const std::string& ModelProto_SentencePiece::_internal_piece() const {
 4522|  1.79M|  return piece_.Get();
 4523|  1.79M|}
_ZN13sentencepiece24ModelProto_SentencePiece19_internal_set_pieceERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 4524|   405k|inline void ModelProto_SentencePiece::_internal_set_piece(const std::string& value) {
 4525|   405k|  _has_bits_[0] |= 0x00000001u;
 4526|   405k|  piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
 4527|   405k|}
_ZN13sentencepiece24ModelProto_SentencePiece9set_pieceEPKcm:
 4541|  7.83M|    size_t size) {
 4542|  7.83M|  _has_bits_[0] |= 0x00000001u;
 4543|  7.83M|  piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
 4544|  7.83M|      reinterpret_cast<const char*>(value), size), GetArena());
 4545|       |  // @@protoc_insertion_point(field_set_pointer:sentencepiece.ModelProto.SentencePiece.piece)
 4546|  7.83M|}
_ZNK13sentencepiece24ModelProto_SentencePiece15_internal_scoreEv:
 4582|   216M|inline float ModelProto_SentencePiece::_internal_score() const {
 4583|   216M|  return score_;
 4584|   216M|}
_ZNK13sentencepiece24ModelProto_SentencePiece5scoreEv:
 4585|   215M|inline float ModelProto_SentencePiece::score() const {
 4586|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.score)
 4587|   215M|  return _internal_score();
 4588|   215M|}
_ZN13sentencepiece24ModelProto_SentencePiece19_internal_set_scoreEf:
 4589|  8.24M|inline void ModelProto_SentencePiece::_internal_set_score(float value) {
 4590|  8.24M|  _has_bits_[0] |= 0x00000002u;
 4591|  8.24M|  score_ = value;
 4592|  8.24M|}
_ZN13sentencepiece24ModelProto_SentencePiece9set_scoreEf:
 4593|  8.24M|inline void ModelProto_SentencePiece::set_score(float value) {
 4594|  8.24M|  _internal_set_score(value);
 4595|       |  // @@protoc_insertion_point(field_set:sentencepiece.ModelProto.SentencePiece.score)
 4596|  8.24M|}
_ZNK13sentencepiece24ModelProto_SentencePiece14_internal_typeEv:
 4610|   431M|inline ::sentencepiece::ModelProto_SentencePiece_Type ModelProto_SentencePiece::_internal_type() const {
 4611|   431M|  return static_cast< ::sentencepiece::ModelProto_SentencePiece_Type >(type_);
 4612|   431M|}
_ZNK13sentencepiece24ModelProto_SentencePiece4typeEv:
 4613|   431M|inline ::sentencepiece::ModelProto_SentencePiece_Type ModelProto_SentencePiece::type() const {
 4614|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.type)
 4615|   431M|  return _internal_type();
 4616|   431M|}
_ZN13sentencepiece24ModelProto_SentencePiece18_internal_set_typeENS_29ModelProto_SentencePiece_TypeE:
 4617|  29.9k|inline void ModelProto_SentencePiece::_internal_set_type(::sentencepiece::ModelProto_SentencePiece_Type value) {
 4618|       |  assert(::sentencepiece::ModelProto_SentencePiece_Type_IsValid(value));
 4619|  29.9k|  _has_bits_[0] |= 0x00000004u;
 4620|  29.9k|  type_ = value;
 4621|  29.9k|}
_ZN13sentencepiece24ModelProto_SentencePiece8set_typeENS_29ModelProto_SentencePiece_TypeE:
 4622|  29.9k|inline void ModelProto_SentencePiece::set_type(::sentencepiece::ModelProto_SentencePiece_Type value) {
 4623|  29.9k|  _internal_set_type(value);
 4624|       |  // @@protoc_insertion_point(field_set:sentencepiece.ModelProto.SentencePiece.type)
 4625|  29.9k|}
_ZNK13sentencepiece10ModelProto21_internal_pieces_sizeEv:
 4632|   177k|inline int ModelProto::_internal_pieces_size() const {
 4633|   177k|  return pieces_.size();
 4634|   177k|}
_ZNK13sentencepiece10ModelProto11pieces_sizeEv:
 4635|   167k|inline int ModelProto::pieces_size() const {
 4636|   167k|  return _internal_pieces_size();
 4637|   167k|}
_ZNK13sentencepiece10ModelProto16_internal_piecesEi:
 4650|   647M|inline const ::sentencepiece::ModelProto_SentencePiece& ModelProto::_internal_pieces(int index) const {
 4651|   647M|  return pieces_.Get(index);
 4652|   647M|}
_ZNK13sentencepiece10ModelProto6piecesEi:
 4653|   647M|inline const ::sentencepiece::ModelProto_SentencePiece& ModelProto::pieces(int index) const {
 4654|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.pieces)
 4655|   647M|  return _internal_pieces(index);
 4656|   647M|}
_ZN13sentencepiece10ModelProto20_internal_add_piecesEv:
 4657|  8.24M|inline ::sentencepiece::ModelProto_SentencePiece* ModelProto::_internal_add_pieces() {
 4658|  8.24M|  return pieces_.Add();
 4659|  8.24M|}
_ZN13sentencepiece10ModelProto10add_piecesEv:
 4660|  8.24M|inline ::sentencepiece::ModelProto_SentencePiece* ModelProto::add_pieces() {
 4661|       |  // @@protoc_insertion_point(field_add:sentencepiece.ModelProto.pieces)
 4662|  8.24M|  return _internal_add_pieces();
 4663|  8.24M|}
_ZN13sentencepiece10ModelProto30_internal_mutable_trainer_specEv:
 4721|  10.2k|inline ::sentencepiece::TrainerSpec* ModelProto::_internal_mutable_trainer_spec() {
 4722|  10.2k|  _has_bits_[0] |= 0x00000001u;
 4723|  10.2k|  if (trainer_spec_ == nullptr) {
  ------------------
  |  Branch (4723:7): [True: 9.97k, False: 230]
  ------------------
 4724|  9.97k|    auto* p = CreateMaybeMessage<::sentencepiece::TrainerSpec>(GetArena());
 4725|  9.97k|    trainer_spec_ = p;
 4726|  9.97k|  }
 4727|  10.2k|  return trainer_spec_;
 4728|  10.2k|}
_ZN13sentencepiece10ModelProto20mutable_trainer_specEv:
 4729|  10.2k|inline ::sentencepiece::TrainerSpec* ModelProto::mutable_trainer_spec() {
 4730|       |  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.trainer_spec)
 4731|  10.2k|  return _internal_mutable_trainer_spec();
 4732|  10.2k|}

_ZN13sentencepiece9character7Trainer5TrainEv:
   25|    246|util::Status Trainer::Train() {
   26|    246|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|    246|  do {                                 \
  |  |   45|    246|    const auto _status = expr;         \
  |  |   46|    246|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 2, False: 244]
  |  |  ------------------
  |  |   47|    246|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 244]
  |  |  ------------------
  ------------------
   27|       |
   28|    244|  RET_CHECK(normalizer_spec_.escape_whitespaces());
  ------------------
  |  |  321|    244|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 244, False: 0]
  |  |  ------------------
  |  |  322|    244|  } else /* NOLINT */                                        \
  |  |  323|    244|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   29|    244|  RET_CHECK_EQ(TrainerSpec::CHAR, trainer_spec_.model_type());
  ------------------
  |  |  327|    244|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|    244|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 244, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|    244|  } else /* NOLINT */                                        \
  |  |  |  |  323|    244|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   30|       |
   31|    244|  RETURN_IF_ERROR(LoadSentences());
  ------------------
  |  |   44|    244|  do {                                 \
  |  |   45|    244|    const auto _status = expr;         \
  |  |   46|    244|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 2, False: 242]
  |  |  ------------------
  |  |   47|    244|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 242]
  |  |  ------------------
  ------------------
   32|       |
   33|    242|  const int vocab_size = trainer_spec_.vocab_size() - meta_pieces_.size();
   34|    242|  RET_CHECK_GE(vocab_size, 0);
  ------------------
  |  |  329|    242|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  321|    242|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 230, False: 12]
  |  |  |  |  ------------------
  |  |  |  |  322|    230|  } else /* NOLINT */                                        \
  |  |  |  |  323|    242|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|     12|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|     12|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   35|       |
   36|    230|  uint64_t sum = 0;
   37|  30.0k|  for (const auto &it : required_chars_) {
  ------------------
  |  Branch (37:23): [True: 30.0k, False: 230]
  ------------------
   38|  30.0k|    sum += it.second;
   39|  30.0k|  }
   40|       |
   41|    230|  const auto logsum = std::log(static_cast<float>(sum));
   42|       |
   43|    230|  RET_CHECK(final_pieces_.empty());
  ------------------
  |  |  321|    230|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 230, False: 0]
  |  |  ------------------
  |  |  322|    230|  } else /* NOLINT */                                        \
  |  |  323|    230|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   44|  6.22k|  for (const auto &it : Sorted(required_chars_)) {
  ------------------
  |  Branch (44:23): [True: 6.22k, False: 87]
  ------------------
   45|  6.22k|    if (!trainer_spec_.use_all_vocab() &&
  ------------------
  |  Branch (45:9): [True: 6.22k, False: 0]
  ------------------
   46|  6.22k|        final_pieces_.size() == static_cast<size_t>(vocab_size)) {
  ------------------
  |  Branch (46:9): [True: 143, False: 6.08k]
  ------------------
   47|    143|      break;
   48|    143|    }
   49|  6.08k|    final_pieces_.emplace_back(
   50|  6.08k|        string_util::UnicodeCharToUTF8(it.first),
   51|  6.08k|        std::log(static_cast<float>(it.second)) - logsum);
   52|  6.08k|  }
   53|       |
   54|    230|  if (trainer_spec_.use_all_vocab()) {
  ------------------
  |  Branch (54:7): [True: 0, False: 230]
  ------------------
   55|      0|    trainer_spec_.set_vocab_size(final_pieces_.size() + meta_pieces_.size());
   56|      0|  }
   57|       |
   58|    230|  return Save();
   59|    230|}

_ZN13sentencepiece9character7TrainerC2ERKNS_11TrainerSpecERKNS_14NormalizerSpecES7_:
   30|    246|      : TrainerInterface::TrainerInterface(trainer_spec, normalizer_spec,
   31|    246|                                           denormalizer_spec) {}

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

_ZN13sentencepiece5model8FreeListINS_7unigram7Lattice4NodeEED2Ev:
   37|  56.2k|  virtual ~FreeList() = default;
unigram_model.cc:_ZN13sentencepiece5model8FreeListINS_7unigram12_GLOBAL__N_110HypothesisEED2Ev:
   37|  1.91M|  virtual ~FreeList() = default;
_ZN13sentencepiece5model8FreeListINS_7unigram7Lattice4NodeEEC2Em:
   36|  56.2k|  explicit FreeList(size_t chunk_size) : chunk_size_(chunk_size) {}
_ZN13sentencepiece5model8FreeListINS_7unigram7Lattice4NodeEE8AllocateEv:
   57|   232M|  T* Allocate() {
   58|   232M|    if (element_index_ >= chunk_size_) {
  ------------------
  |  Branch (58:9): [True: 27.3k, False: 232M]
  ------------------
   59|  27.3k|      ++chunk_index_;
   60|  27.3k|      element_index_ = 0;
   61|  27.3k|    }
   62|       |
   63|   232M|    if (chunk_index_ == freelist_.size()) {
  ------------------
  |  Branch (63:9): [True: 62.3k, False: 232M]
  ------------------
   64|  62.3k|      auto chunk = std::make_unique<T[]>(chunk_size_);
   65|  62.3k|      memset(static_cast<void*>(chunk.get()), 0, sizeof(T) * chunk_size_);
   66|  62.3k|      freelist_.push_back(std::move(chunk));
   67|  62.3k|    }
   68|       |
   69|   232M|    T* result = freelist_[chunk_index_].get() + element_index_;
   70|   232M|    ++element_index_;
   71|       |
   72|   232M|    return result;
   73|   232M|  }
_ZNK13sentencepiece5model8FreeListINS_7unigram7Lattice4NodeEE4sizeEv:
   54|   237M|  size_t size() const { return chunk_size_ * chunk_index_ + element_index_; }
_ZN13sentencepiece5model8FreeListINS_7unigram7Lattice4NodeEE4FreeEv:
   45|  4.29M|  void Free() {
   46|  4.38M|    for (auto& chunk : freelist_) {
  ------------------
  |  Branch (46:22): [True: 4.38M, False: 4.29M]
  ------------------
   47|  4.38M|      memset(static_cast<void*>(chunk.get()), 0, sizeof(T) * chunk_size_);
   48|  4.38M|    }
   49|  4.29M|    chunk_index_ = 0;
   50|  4.29M|    element_index_ = 0;
   51|  4.29M|  }
unigram_model.cc:_ZN13sentencepiece5model8FreeListINS_7unigram12_GLOBAL__N_110HypothesisEE8AllocateEv:
   57|  15.5M|  T* Allocate() {
   58|  15.5M|    if (element_index_ >= chunk_size_) {
  ------------------
  |  Branch (58:9): [True: 1, False: 15.5M]
  ------------------
   59|      1|      ++chunk_index_;
   60|      1|      element_index_ = 0;
   61|      1|    }
   62|       |
   63|  15.5M|    if (chunk_index_ == freelist_.size()) {
  ------------------
  |  Branch (63:9): [True: 1.91M, False: 13.5M]
  ------------------
   64|  1.91M|      auto chunk = std::make_unique<T[]>(chunk_size_);
   65|  1.91M|      memset(static_cast<void*>(chunk.get()), 0, sizeof(T) * chunk_size_);
   66|  1.91M|      freelist_.push_back(std::move(chunk));
   67|  1.91M|    }
   68|       |
   69|  15.5M|    T* result = freelist_[chunk_index_].get() + element_index_;
   70|  15.5M|    ++element_index_;
   71|       |
   72|  15.5M|    return result;
   73|  15.5M|  }
unigram_model.cc:_ZN13sentencepiece5model8FreeListINS_7unigram12_GLOBAL__N_110HypothesisEEC2Em:
   36|  1.91M|  explicit FreeList(size_t chunk_size) : chunk_size_(chunk_size) {}
unigram_model.cc:_ZNK13sentencepiece5model8FreeListINS_7unigram12_GLOBAL__N_110HypothesisEE4sizeEv:
   54|  9.46M|  size_t size() const { return chunk_size_ * chunk_index_ + element_index_; }

_ZN13sentencepiece14ModelInterfaceD2Ev:
   27|  6.89k|ModelInterface::~ModelInterface() {}
_ZN13sentencepiece14SplitIntoWordsENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEbb:
  156|  4.77M|                                              bool allow_ws_only_pieces) {
  157|  4.77M|  const char *begin = text.data();
  158|  4.77M|  const char *end = text.data() + text.size();
  159|       |
  160|       |  // Space symbol (U+2581)
  161|  4.77M|  constexpr absl::string_view kSpaceSymbol = "\xe2\x96\x81";
  162|  4.77M|  bool in_ws_sequence = false;
  163|       |
  164|  4.77M|  std::vector<absl::string_view> result;
  165|  4.77M|  if (treat_ws_as_suffix) {  // put ws tokens at the end of non-ws sequences.
  ------------------
  |  Branch (165:7): [True: 0, False: 4.77M]
  ------------------
  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|  4.77M|  } else {
  188|   323M|    while (begin < end) {
  ------------------
  |  Branch (188:12): [True: 318M, False: 4.77M]
  ------------------
  189|   318M|      const int mblen =
  190|   318M|          std::min<int>(string_util::OneCharLen(begin), end - begin);
  191|   318M|      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|   318M|      if (begin == text.data() ||
  ------------------
  |  Branch (194:11): [True: 4.77M, False: 313M]
  ------------------
  195|   313M|          (is_ws && (!in_ws_sequence || !allow_ws_only_pieces))) {
  ------------------
  |  Branch (195:12): [True: 6.60M, False: 307M]
  |  Branch (195:22): [True: 6.60M, False: 0]
  |  Branch (195:41): [True: 0, False: 0]
  ------------------
  196|  11.3M|        result.emplace_back(begin, 0);  // add empty string piece.
  197|  11.3M|        in_ws_sequence = true;
  198|  11.3M|      }
  199|       |
  200|   318M|      if (in_ws_sequence && !is_ws) in_ws_sequence = false;
  ------------------
  |  Branch (200:11): [True: 19.3M, False: 299M]
  |  Branch (200:29): [True: 11.2M, False: 8.01M]
  ------------------
  201|       |
  202|   318M|      result.back() =
  203|   318M|          absl::string_view(result.back().data(), result.back().size() + mblen);
  204|   318M|      begin += mblen;
  205|   318M|    }
  206|  4.77M|  }
  207|       |
  208|  4.77M|  return result;
  209|  4.77M|}
_ZN13sentencepiece11ByteToPieceEh:
  211|  22.0k|std::string ByteToPiece(unsigned char c) {
  212|  22.0k|  return absl::StrFormat("<0x%02X>", c);
  213|  22.0k|}

_ZN13sentencepiece14ModelInterfaceC2Ev:
   65|  6.89k|  ModelInterface() {}
_ZNK13sentencepiece14ModelInterface6statusEv:
   71|   111k|  virtual util::Status status() const { return status_; }
_ZNK13sentencepiece14ModelInterface12GetPieceSizeEv:
  145|   122k|  virtual int GetPieceSize() const {
  146|   122k|    if (!model_proto_) return 0;
  ------------------
  |  Branch (146:9): [True: 0, False: 122k]
  ------------------
  147|   122k|    return model_proto_->pieces_size();
  148|   122k|  }
_ZNK13sentencepiece14ModelInterface15GetScoreInlinedEi:
  216|   215M|  inline float GetScoreInlined(int id) const {
  217|   215M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|   215M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|   215M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   215M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 215M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   215M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  218|   215M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|   215M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|   215M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   215M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 215M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   215M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  219|   215M|    return model_proto_->pieces(id).score();
  220|   215M|  }
_ZNK13sentencepiece14ModelInterface15IsUnusedInlinedEi:
  236|   215M|  inline bool IsUnusedInlined(int id) const {
  237|   215M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|   215M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|   215M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   215M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 215M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   215M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  238|   215M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|   215M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|   215M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   215M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 215M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   215M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  239|   215M|    return (model_proto_->pieces(id).type() ==
  240|   215M|            ModelProto::SentencePiece::UNUSED);
  241|   215M|  }
_ZNK13sentencepiece14ModelInterface20IsUserDefinedInlinedEi:
  243|   215M|  inline bool IsUserDefinedInlined(int id) const {
  244|   215M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|   215M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|   215M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   215M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 215M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   215M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  245|   215M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|   215M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|   215M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   215M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 215M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   215M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  246|   215M|    return (model_proto_->pieces(id).type() ==
  247|   215M|            ModelProto::SentencePiece::USER_DEFINED);
  248|   215M|  }

_ZN13sentencepiece10normalizer10NormalizerC2ERKNS_14NormalizerSpecERKNS_11TrainerSpecE:
   35|  10.1k|    : spec_(&spec),
   36|  10.1k|      treat_whitespace_as_suffix_(trainer_spec.treat_whitespace_as_suffix()),
   37|  10.1k|      status_(util::OkStatus()) {
   38|  10.1k|  Init();
   39|  10.1k|}
_ZN13sentencepiece10normalizer10NormalizerC2ERKNS_14NormalizerSpecE:
   42|  10.1k|    : spec_(&spec), status_(util::OkStatus()) {
   43|  10.1k|  Init();
   44|  10.1k|}
_ZN13sentencepiece10normalizer10NormalizerD2Ev:
   46|  20.2k|Normalizer::~Normalizer() {}
_ZN13sentencepiece10normalizer10Normalizer4InitEv:
   48|  20.2k|void Normalizer::Init() {
   49|  20.2k|  absl::string_view index = spec_->precompiled_charsmap();
   50|       |
   51|  20.2k|  if (!index.empty()) {
  ------------------
  |  Branch (51:7): [True: 20.2k, False: 0]
  ------------------
   52|  20.2k|    absl::string_view trie_blob;
   53|  20.2k|    status_ = DecodePrecompiledCharsMap(index, &trie_blob, &normalized_,
   54|  20.2k|                                        &precompiled_charsmap_buffer_);
   55|       |
   56|  20.2k|    if (!status_.ok()) return;
  ------------------
  |  Branch (56:9): [True: 0, False: 20.2k]
  ------------------
   57|       |
   58|       |    // Reads the body of double array.
   59|  20.2k|    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|  20.2k|    trie_->set_array(const_cast<char *>(trie_blob.data()),
   64|  20.2k|                     trie_blob.size() / trie_->unit_size());
   65|       |
   66|  20.2k|    if (!trie_->validate()) {
  ------------------
  |  Branch (66:9): [True: 0, False: 20.2k]
  ------------------
   67|      0|      status_ = util::InternalError(
   68|      0|          "Trie data contains out-of-bounds node references.");
   69|      0|      return;
   70|      0|    }
   71|  20.2k|  }
   72|  20.2k|}
_ZNK13sentencepiece10normalizer10Normalizer9NormalizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEEPNS2_6vectorImNS8_ImEEEE:
   76|  65.5k|                                   std::vector<size_t> *norm_to_orig) const {
   77|  65.5k|  if (norm_to_orig) norm_to_orig->clear();
  ------------------
  |  Branch (77:7): [True: 0, False: 65.5k]
  ------------------
   78|  65.5k|  normalized->clear();
   79|       |
   80|  65.5k|  if (input.empty()) {
  ------------------
  |  Branch (80:7): [True: 0, False: 65.5k]
  ------------------
   81|      0|    return util::OkStatus();
   82|      0|  }
   83|       |
   84|  65.5k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  65.5k|  do {                                 \
  |  |   45|  65.5k|    const auto _status = expr;         \
  |  |   46|  65.5k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 65.5k]
  |  |  ------------------
  |  |   47|  65.5k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 65.5k]
  |  |  ------------------
  ------------------
   85|       |
   86|  65.5k|  size_t consumed = 0;
   87|       |
   88|       |  // Ignores heading space.
   89|  65.5k|  if (spec_->remove_extra_whitespaces()) {
  ------------------
  |  Branch (89:7): [True: 65.5k, False: 0]
  ------------------
   90|  74.7k|    while (!input.empty()) {
  ------------------
  |  Branch (90:12): [True: 73.8k, False: 901]
  ------------------
   91|  73.8k|      const auto p = NormalizePrefix(input);
   92|  73.8k|      if (p.first != " ") {
  ------------------
  |  Branch (92:11): [True: 64.6k, False: 9.20k]
  ------------------
   93|  64.6k|        break;
   94|  64.6k|      }
   95|  9.20k|      input.remove_prefix(p.second);
   96|  9.20k|      consumed += p.second;
   97|  9.20k|    }
   98|  65.5k|  }
   99|       |
  100|       |  // all chars are whitespace.
  101|  65.5k|  if (input.empty()) {
  ------------------
  |  Branch (101:7): [True: 901, False: 64.6k]
  ------------------
  102|    901|    return util::OkStatus();
  103|    901|  }
  104|       |
  105|       |  // Reserves the output buffer to avoid re-allocations.
  106|  64.6k|  const size_t kReservedSize = input.size() * 1.5;
  107|  64.6k|  normalized->reserve(kReservedSize);
  108|  64.6k|  if (norm_to_orig) norm_to_orig->reserve(kReservedSize);
  ------------------
  |  Branch (108:7): [True: 0, False: 64.6k]
  ------------------
  109|       |
  110|       |  // Replaces white space with U+2581 (LOWER ONE EIGHT BLOCK)
  111|       |  // if escape_whitespaces() is set (default = true).
  112|  64.6k|  const absl::string_view kSpaceSymbol =
  113|  64.6k|      spec_->escape_whitespaces() ? "\xe2\x96\x81" : " ";
  ------------------
  |  Branch (113:7): [True: 64.6k, False: 0]
  ------------------
  114|       |
  115|       |  // adds kSpaceSymbol to the current context.
  116|  64.6k|  auto add_ws = [&consumed, &normalized, &norm_to_orig, &kSpaceSymbol]() {
  117|  64.6k|    normalized->append(kSpaceSymbol.data(), kSpaceSymbol.size());
  118|  64.6k|    if (norm_to_orig) {
  119|  64.6k|      for (size_t n = 0; n < kSpaceSymbol.size(); ++n) {
  120|  64.6k|        norm_to_orig->push_back(consumed);
  121|  64.6k|      }
  122|  64.6k|    }
  123|  64.6k|  };
  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|  64.6k|  if (!treat_whitespace_as_suffix_ && spec_->add_dummy_prefix()) add_ws();
  ------------------
  |  Branch (129:7): [True: 64.6k, False: 0]
  |  Branch (129:39): [True: 64.6k, False: 0]
  ------------------
  130|       |
  131|  64.6k|  bool is_prev_space = spec_->remove_extra_whitespaces();
  132|  10.0M|  while (!input.empty()) {
  ------------------
  |  Branch (132:10): [True: 9.94M, False: 64.6k]
  ------------------
  133|  9.94M|    auto p = NormalizePrefix(input);
  134|  9.94M|    absl::string_view sp = p.first;
  135|       |
  136|       |    // Removes heading spaces in sentence piece,
  137|       |    // if the previous sentence piece ends with whitespace.
  138|  10.0M|    while (is_prev_space && absl::ConsumePrefix(&sp, " ")) {
  ------------------
  |  Branch (138:12): [True: 744k, False: 9.32M]
  |  Branch (138:29): [True: 126k, False: 617k]
  ------------------
  139|   126k|    }
  140|       |
  141|  9.94M|    if (!sp.empty()) {
  ------------------
  |  Branch (141:9): [True: 9.52M, False: 415k]
  ------------------
  142|  9.52M|      const char *data = sp.data();
  143|  24.0M|      for (size_t n = 0; n < sp.size(); ++n) {
  ------------------
  |  Branch (143:26): [True: 14.5M, False: 9.52M]
  ------------------
  144|  14.5M|        if (data[n] == ' ') {
  ------------------
  |  Branch (144:13): [True: 409k, False: 14.1M]
  ------------------
  145|   409k|          add_ws();
  146|  14.1M|        } else {
  147|  14.1M|          *normalized += data[n];
  148|  14.1M|          if (norm_to_orig) norm_to_orig->push_back(consumed);
  ------------------
  |  Branch (148:15): [True: 0, False: 14.1M]
  ------------------
  149|  14.1M|        }
  150|  14.5M|      }
  151|       |      // Checks whether the last character of sp is whitespace.
  152|  9.52M|      is_prev_space = absl::EndsWith(sp, " ");
  153|  9.52M|    }
  154|       |
  155|  9.94M|    consumed += p.second;
  156|  9.94M|    input.remove_prefix(p.second);
  157|  9.94M|    if (!spec_->remove_extra_whitespaces()) {
  ------------------
  |  Branch (157:9): [True: 0, False: 9.94M]
  ------------------
  158|      0|      is_prev_space = false;
  159|      0|    }
  160|  9.94M|  }
  161|       |
  162|       |  // Ignores trailing space.
  163|  64.6k|  if (spec_->remove_extra_whitespaces()) {
  ------------------
  |  Branch (163:7): [True: 64.6k, False: 0]
  ------------------
  164|  69.3k|    while (absl::EndsWith(*normalized, kSpaceSymbol)) {
  ------------------
  |  Branch (164:12): [True: 4.68k, False: 64.6k]
  ------------------
  165|  4.68k|      const int length = normalized->size() - kSpaceSymbol.size();
  166|  4.68k|      RET_CHECK_GE(length, 0);
  ------------------
  |  |  329|  4.68k|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  321|  4.68k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 4.68k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  4.68k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  4.68k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  167|  4.68k|      normalized->resize(length);
  168|  4.68k|      if (norm_to_orig) {
  ------------------
  |  Branch (168:11): [True: 0, False: 4.68k]
  ------------------
  169|      0|        consumed = (*norm_to_orig)[length];
  170|      0|        norm_to_orig->resize(length);
  171|      0|      }
  172|  4.68k|    }
  173|  64.6k|  }
  174|       |
  175|       |  // Adds a space symbol as a suffix (default is false)
  176|  64.6k|  if (treat_whitespace_as_suffix_ && spec_->add_dummy_prefix()) add_ws();
  ------------------
  |  Branch (176:7): [True: 0, False: 64.6k]
  |  Branch (176:38): [True: 0, False: 0]
  ------------------
  177|       |
  178|  64.6k|  if (norm_to_orig) {
  ------------------
  |  Branch (178:7): [True: 0, False: 64.6k]
  ------------------
  179|      0|    norm_to_orig->push_back(consumed);
  180|      0|    RET_CHECK_EQ(norm_to_orig->size(), normalized->size() + 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 << "] "
  |  |  ------------------
  ------------------
  181|      0|  }
  182|       |
  183|  64.6k|  return util::OkStatus();
  184|  64.6k|}
_ZNK13sentencepiece10normalizer10Normalizer9NormalizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  186|  65.5k|std::string Normalizer::Normalize(absl::string_view input) const {
  187|  65.5k|  std::string normalized;
  188|  65.5k|  Normalize(input, &normalized, nullptr).IgnoreError();
  189|  65.5k|  return normalized;
  190|  65.5k|}
_ZNK13sentencepiece10normalizer10Normalizer15NormalizePrefixENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  193|  10.0M|    absl::string_view input) const {
  194|  10.0M|  if (input.empty()) return {};
  ------------------
  |  Branch (194:7): [True: 0, False: 10.0M]
  ------------------
  195|       |
  196|  10.0M|  if (matcher_ != nullptr) {
  ------------------
  |  Branch (196:7): [True: 0, False: 10.0M]
  ------------------
  197|      0|    bool found = false;
  198|      0|    const int mblen = matcher_->PrefixMatch(input, &found);
  199|      0|    if (found) return {input.substr(0, mblen), mblen};
  ------------------
  |  Branch (199:9): [True: 0, False: 0]
  ------------------
  200|      0|  }
  201|       |
  202|  10.0M|  size_t longest_length = 0;
  203|  10.0M|  size_t longest_value = 0;
  204|       |
  205|  10.0M|  if (trie_ != nullptr) {
  ------------------
  |  Branch (205:7): [True: 10.0M, False: 0]
  ------------------
  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|  10.0M|    Darts::DoubleArray::result_pair_type
  211|  10.0M|        trie_results[Normalizer::kMaxTrieResultsSize];
  212|       |
  213|  10.0M|    const size_t num_nodes = trie_->commonPrefixSearch(
  214|  10.0M|        input.data(), trie_results, Normalizer::kMaxTrieResultsSize,
  215|  10.0M|        input.size());
  216|       |
  217|       |    // Finds the longest rule.
  218|  10.4M|    for (size_t k = 0; k < num_nodes; ++k) {
  ------------------
  |  Branch (218:24): [True: 390k, False: 10.0M]
  ------------------
  219|   390k|      if (longest_length == 0 || trie_results[k].length > longest_length) {
  ------------------
  |  Branch (219:11): [True: 390k, False: 142]
  |  Branch (219:34): [True: 142, False: 0]
  ------------------
  220|   390k|        longest_length = trie_results[k].length;  // length of prefix
  221|   390k|        longest_value = trie_results[k].value;    // pointer to |normalized_|.
  222|   390k|      }
  223|   390k|    }
  224|  10.0M|  }
  225|       |
  226|  10.0M|  std::pair<absl::string_view, int> result;
  227|  10.0M|  if (longest_length == 0 || longest_length > input.size() ||
  ------------------
  |  Branch (227:7): [True: 9.62M, False: 390k]
  |  Branch (227:30): [True: 0, False: 390k]
  ------------------
  228|  9.62M|      longest_value >= normalized_.size()) {
  ------------------
  |  Branch (228:7): [True: 0, False: 390k]
  ------------------
  229|  9.62M|    size_t length = 0;
  230|  9.62M|    if (!string_util::IsValidDecodeUTF8(input, &length)) {
  ------------------
  |  Branch (230:9): [True: 2.33M, False: 7.28M]
  ------------------
  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|  2.33M|      result.second = 1;
  236|  2.33M|      static constexpr absl::string_view kReplacementChar = "\xEF\xBF\xBD";
  237|  2.33M|      result.first = kReplacementChar;
  238|  7.28M|    } else {
  239|  7.28M|      result.second = length;
  240|  7.28M|      result.first = absl::string_view(input.data(), result.second);
  241|  7.28M|    }
  242|  9.62M|  } else {
  243|   390k|    result.second = longest_length;
  244|       |    // No need to pass the size of normalized sentence,
  245|       |    // since |normalized| is delimitered by "\0".
  246|   390k|    result.first = normalized_.data() + longest_value;
  247|   390k|  }
  248|       |
  249|  10.0M|  return result;
  250|  10.0M|}
_ZN13sentencepiece10normalizer10Normalizer25DecodePrecompiledCharsMapENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPS6_S7_PNS2_12basic_stringIcS5_NS2_9allocatorIcEEEE:
  273|  20.2k|    absl::string_view *normalized, std::string *buffer) {
  274|  20.2k|  uint32_t trie_blob_size = 0;
  275|  20.2k|  if (blob.size() <= sizeof(trie_blob_size) ||
  ------------------
  |  Branch (275:7): [True: 0, False: 20.2k]
  ------------------
  276|  20.2k|      !string_util::DecodePOD<uint32_t>(
  ------------------
  |  Branch (276:7): [True: 0, False: 20.2k]
  ------------------
  277|  20.2k|          absl::string_view(blob.data(), sizeof(trie_blob_size)),
  278|  20.2k|          &trie_blob_size)) {
  279|      0|    return util::InternalError("Blob for normalization rule is broken.");
  280|      0|  }
  281|       |
  282|       |  if constexpr (util::is_bigendian()) {
  283|       |    trie_blob_size = util::Swap32(trie_blob_size);
  284|       |  }
  285|       |
  286|  20.2k|  if (trie_blob_size >= blob.size()) {
  ------------------
  |  Branch (286:7): [True: 0, False: 20.2k]
  ------------------
  287|      0|    return util::InternalError("Trie data size exceeds the input blob size.");
  288|      0|  }
  289|       |
  290|       |  // Dart unit_size is 4 and blob size in units must be a multiple of 256.
  291|  20.2k|  if (trie_blob_size < 1024 || (trie_blob_size & 0x3FF) != 0) {
  ------------------
  |  Branch (291:7): [True: 0, False: 20.2k]
  |  Branch (291:32): [True: 0, False: 20.2k]
  ------------------
  292|      0|    return util::InternalError("Trie data size is not divisible by 1024.");
  293|      0|  }
  294|       |
  295|  20.2k|  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|  20.2k|  } else {
  306|  20.2k|    *trie_blob = absl::string_view(blob.data(), trie_blob_size);
  307|  20.2k|  }
  308|       |
  309|  20.2k|  blob.remove_prefix(trie_blob_size);
  310|  20.2k|  *normalized = absl::string_view(blob.data(), blob.size());
  311|       |
  312|  20.2k|  if (normalized->empty() || normalized->back() != '\0') {
  ------------------
  |  Branch (312:7): [True: 0, False: 20.2k]
  |  Branch (312:30): [True: 0, False: 20.2k]
  ------------------
  313|      0|    return util::InternalError("normalized block must be null terminated.");
  314|      0|  }
  315|       |
  316|  20.2k|  return util::OkStatus();
  317|  20.2k|}
_ZN13sentencepiece10normalizer13PrefixMatcherC2ERKNSt3__13setINS2_17basic_string_viewIcNS2_11char_traitsIcEEEENS2_4lessIS7_EENS2_9allocatorIS7_EEEE:
  319|  10.1k|PrefixMatcher::PrefixMatcher(const std::set<absl::string_view> &dic) {
  320|  10.1k|  if (dic.empty()) return;
  ------------------
  |  Branch (320:7): [True: 0, False: 10.1k]
  ------------------
  321|  10.1k|  std::vector<const char *> key;
  322|  10.1k|  std::vector<size_t> lengths;
  323|  10.1k|  key.reserve(dic.size());
  324|  10.1k|  lengths.reserve(dic.size());
  325|  52.3k|  for (const auto &it : dic) {
  ------------------
  |  Branch (325:23): [True: 52.3k, False: 10.1k]
  ------------------
  326|  52.3k|    key.push_back(it.data());
  327|  52.3k|    lengths.push_back(it.size());
  328|  52.3k|  }
  329|  10.1k|  trie_ = std::make_unique<Darts::DoubleArray>();
  330|  10.1k|  if (trie_->build(key.size(), const_cast<char **>(key.data()),
  ------------------
  |  Branch (330:7): [True: 0, False: 10.1k]
  ------------------
  331|  10.1k|                   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|  10.1k|}
_ZNK13sentencepiece10normalizer13PrefixMatcher11PrefixMatchENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPb:
  337|  9.62M|int PrefixMatcher::PrefixMatch(absl::string_view w, bool *found) const {
  338|  9.62M|  if (trie_ == nullptr) {
  ------------------
  |  Branch (338:7): [True: 0, False: 9.62M]
  ------------------
  339|      0|    if (found) *found = false;
  ------------------
  |  Branch (339:9): [True: 0, False: 0]
  ------------------
  340|      0|    return std::min<int>(w.size(), string_util::OneCharLen(w.data()));
  341|      0|  }
  342|       |
  343|  9.62M|  constexpr int kResultSize = 64;
  344|  9.62M|  Darts::DoubleArray::result_pair_type trie_results[kResultSize];
  345|  9.62M|  const int num_nodes =
  346|  9.62M|      trie_->commonPrefixSearch(w.data(), trie_results, kResultSize, w.size());
  347|       |
  348|  9.62M|  if (found) *found = (num_nodes > 0);
  ------------------
  |  Branch (348:7): [True: 9.62M, False: 0]
  ------------------
  349|  9.62M|  if (num_nodes == 0) {
  ------------------
  |  Branch (349:7): [True: 9.62M, False: 4.05k]
  ------------------
  350|  9.62M|    return std::min<int>(w.size(), string_util::OneCharLen(w.data()));
  351|  9.62M|  }
  352|       |
  353|  4.05k|  int mblen = 0;
  354|  8.10k|  for (int i = 0; i < num_nodes; ++i) {
  ------------------
  |  Branch (354:19): [True: 4.05k, False: 4.05k]
  ------------------
  355|  4.05k|    mblen = std::max<int>(trie_results[i].length, mblen);
  356|  4.05k|  }
  357|       |
  358|  4.05k|  return mblen;
  359|  9.62M|}
_ZNK13sentencepiece10normalizer13PrefixMatcher13GlobalReplaceENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_:
  362|  65.5k|                                         absl::string_view out) const {
  363|  65.5k|  std::string result;
  364|  9.69M|  while (!w.empty()) {
  ------------------
  |  Branch (364:10): [True: 9.62M, False: 65.5k]
  ------------------
  365|  9.62M|    bool found = false;
  366|  9.62M|    const int mblen = PrefixMatch(w, &found);
  367|  9.62M|    if (found) {
  ------------------
  |  Branch (367:9): [True: 4.05k, False: 9.62M]
  ------------------
  368|  4.05k|      result.append(out.data(), out.size());
  369|  9.62M|    } else {
  370|  9.62M|      result.append(w.data(), mblen);
  371|  9.62M|    }
  372|  9.62M|    w.remove_prefix(mblen);
  373|  9.62M|  }
  374|  65.5k|  return result;
  375|  65.5k|}
normalizer.cc:_ZZNK13sentencepiece10normalizer10Normalizer9NormalizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEEPNS2_6vectorImNS8_ImEEEEENK3$_0clEv:
  116|   473k|  auto add_ws = [&consumed, &normalized, &norm_to_orig, &kSpaceSymbol]() {
  117|   473k|    normalized->append(kSpaceSymbol.data(), kSpaceSymbol.size());
  118|   473k|    if (norm_to_orig) {
  ------------------
  |  Branch (118:9): [True: 0, False: 473k]
  ------------------
  119|      0|      for (size_t n = 0; n < kSpaceSymbol.size(); ++n) {
  ------------------
  |  Branch (119:26): [True: 0, False: 0]
  ------------------
  120|      0|        norm_to_orig->push_back(consumed);
  121|      0|      }
  122|      0|    }
  123|   473k|  };

_ZNK13sentencepiece10normalizer10Normalizer6statusEv:
   77|  75.6k|  virtual util::Status status() const { return status_; }

_ZNK13sentencepiece4util6Status2okEv:
   64|   445k|  inline bool ok() const { return rep_ == nullptr; }

_ZN13sentencepiece20SentencePieceTrainer5TrainERKNS_11TrainerSpecERKNS_14NormalizerSpecES6_PNS_16SentenceIteratorEPNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEE:
   62|  10.1k|    SentenceIterator *sentence_iterator, std::string *serialized_model_proto) {
   63|  10.1k|  auto copied_normalizer_spec = normalizer_spec;
   64|  10.1k|  RETURN_IF_ERROR(PopulateNormalizerSpec(&copied_normalizer_spec, false));
  ------------------
  |  |   44|  10.1k|  do {                                 \
  |  |   45|  10.1k|    const auto _status = expr;         \
  |  |   46|  10.1k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |   47|  10.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 10.1k]
  |  |  ------------------
  ------------------
   65|  10.1k|  auto copied_denormalizer_spec = denormalizer_spec;
   66|  10.1k|  RETURN_IF_ERROR(PopulateNormalizerSpec(&copied_denormalizer_spec, true));
  ------------------
  |  |   44|  10.1k|  do {                                 \
  |  |   45|  10.1k|    const auto _status = expr;         \
  |  |   46|  10.1k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |   47|  10.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 10.1k]
  |  |  ------------------
  ------------------
   67|  10.1k|  auto trainer = TrainerFactory::Create(trainer_spec, copied_normalizer_spec,
   68|  10.1k|                                        copied_denormalizer_spec);
   69|  10.1k|  std::string info =
   70|  10.1k|      absl::StrCat(PrintProto(trainer_spec, "trainer_spec"),
   71|  10.1k|                   PrintProto(copied_normalizer_spec, "normalizer_spec"));
   72|  10.1k|  if (!copied_denormalizer_spec.precompiled_charsmap().empty()) {
  ------------------
  |  Branch (72:7): [True: 0, False: 10.1k]
  ------------------
   73|      0|    info += PrintProto(copied_denormalizer_spec, "denormalizer_spec");
   74|  10.1k|  } else {
   75|  10.1k|    info += "denormalizer_spec {}";
   76|  10.1k|  }
   77|       |
   78|  30.3k|  LOG(INFO) << "Starts training with : \n" << info;
  ------------------
  |  |  218|  10.1k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  10.1k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  10.1k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  20.2k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  20.2k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 10.1k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  10.1k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  10.1k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  10.1k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  30.3k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  30.3k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   79|       |
   80|  10.1k|  if (serialized_model_proto) {
  ------------------
  |  Branch (80:7): [True: 10.1k, False: 0]
  ------------------
   81|  10.1k|    ModelProto model_proto;
   82|  10.1k|    RETURN_IF_ERROR(trainer->Train(sentence_iterator, &model_proto));
  ------------------
  |  |   44|  10.1k|  do {                                 \
  |  |   45|  10.1k|    const auto _status = expr;         \
  |  |   46|  10.1k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 5.24k, False: 4.89k]
  |  |  ------------------
  |  |   47|  10.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 4.89k]
  |  |  ------------------
  ------------------
   83|  4.89k|    *serialized_model_proto = model_proto.SerializeAsString();
   84|  4.89k|  } else {
   85|      0|    RETURN_IF_ERROR(trainer->Train(sentence_iterator, nullptr));
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
   86|      0|  }
   87|       |
   88|  4.89k|  return util::OkStatus();
   89|  10.1k|}
_ZN13sentencepiece20SentencePieceTrainer18MergeSpecsFromArgsENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPNS_11TrainerSpecEPNS_14NormalizerSpecES9_:
  103|  10.1k|    NormalizerSpec *normalizer_spec, NormalizerSpec *denormalizer_spec) {
  104|  10.1k|  RET_CHECK(trainer_spec) << "`trainer_spec` must not be null.";
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  105|  10.1k|  RET_CHECK(normalizer_spec) << "`normalizer_spec` must not be null.";
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  106|  10.1k|  RET_CHECK(denormalizer_spec) << "`denormalizer_spec` must not be null.";
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  107|       |
  108|  10.1k|  if (args.empty()) return util::OkStatus();
  ------------------
  |  Branch (108:7): [True: 0, False: 10.1k]
  ------------------
  109|       |
  110|  10.1k|  std::unordered_map<std::string, std::string> kwargs;
  111|  48.1k|  for (auto arg : absl::StrSplit(args, " ")) {
  ------------------
  |  Branch (111:17): [True: 48.1k, False: 10.1k]
  ------------------
  112|  48.1k|    absl::ConsumePrefix(&arg, "--");
  113|  48.1k|    std::string key, value;
  114|  48.1k|    const auto pos = arg.find('=');
  115|  48.1k|    if (pos == absl::string_view::npos) {
  ------------------
  |  Branch (115:9): [True: 0, False: 48.1k]
  ------------------
  116|      0|      key = std::string(arg);
  117|  48.1k|    } else {
  118|  48.1k|      key = std::string(arg.substr(0, pos));
  119|  48.1k|      value = std::string(arg.substr(pos + 1));
  120|  48.1k|    }
  121|  48.1k|    kwargs.emplace(key, value);
  122|  48.1k|  }
  123|       |
  124|  10.1k|  return MergeSpecsFromArgs(kwargs, trainer_spec, normalizer_spec,
  125|  10.1k|                            denormalizer_spec);
  126|  10.1k|}
_ZN13sentencepiece20SentencePieceTrainer18MergeSpecsFromArgsERKNSt3__113unordered_mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES8_NS1_4hashIS8_EENS1_8equal_toIS8_EENS6_INS1_4pairIKS8_S8_EEEEEEPNS_11TrainerSpecEPNS_14NormalizerSpecESN_:
  132|  10.1k|    NormalizerSpec *denormalizer_spec) {
  133|  10.1k|  RET_CHECK(trainer_spec) << "`trainer_spec` must not be null.";
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  134|  10.1k|  RET_CHECK(normalizer_spec) << "`normalizer_spec` must not be null.";
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  135|  10.1k|  RET_CHECK(denormalizer_spec) << "`denormalizer_spec` must not be null.";
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  136|       |
  137|  48.1k|  for (const auto &[key, value] : kwargs) {
  ------------------
  |  Branch (137:33): [True: 48.1k, False: 10.1k]
  ------------------
  138|       |    // Exceptions.
  139|  48.1k|    if (key == "normalization_rule_name") {
  ------------------
  |  Branch (139:9): [True: 0, False: 48.1k]
  ------------------
  140|      0|      normalizer_spec->set_name(value);
  141|      0|      continue;
  142|  48.1k|    } else if (key == "denormalization_rule_tsv") {
  ------------------
  |  Branch (142:16): [True: 0, False: 48.1k]
  ------------------
  143|      0|      denormalizer_spec->set_normalization_rule_tsv(value);
  144|      0|      denormalizer_spec->set_add_dummy_prefix(false);
  145|      0|      denormalizer_spec->set_remove_extra_whitespaces(false);
  146|      0|      denormalizer_spec->set_escape_whitespaces(false);
  147|      0|      continue;
  148|  48.1k|    } else if (key == "minloglevel") {
  ------------------
  |  Branch (148:16): [True: 0, False: 48.1k]
  ------------------
  149|      0|      int v = 0;
  150|      0|      RET_CHECK(absl::SimpleAtoi(value, &v));
  ------------------
  |  |  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 << "] "
  ------------------
  151|      0|      SetMinLogLevel(v);
  152|      0|      continue;
  153|      0|    }
  154|       |
  155|  48.1k|    const auto status_train = SetProtoField(key, value, trainer_spec);
  156|  48.1k|    if (status_train.ok()) continue;
  ------------------
  |  Branch (156:9): [True: 48.1k, False: 0]
  ------------------
  157|      0|    if (!util::IsNotFound(status_train)) return status_train;
  ------------------
  |  Branch (157:9): [True: 0, False: 0]
  ------------------
  158|       |
  159|      0|    const auto status_norm = SetProtoField(key, value, normalizer_spec);
  160|      0|    if (status_norm.ok()) continue;
  ------------------
  |  Branch (160:9): [True: 0, False: 0]
  ------------------
  161|      0|    if (!util::IsNotFound(status_norm)) return status_norm;
  ------------------
  |  Branch (161:9): [True: 0, False: 0]
  ------------------
  162|       |
  163|       |    // Not found both in trainer_spec and normalizer_spec.
  164|      0|    if (util::IsNotFound(status_train) && util::IsNotFound(status_norm)) {
  ------------------
  |  Branch (164:9): [True: 0, False: 0]
  |  Branch (164:43): [True: 0, False: 0]
  ------------------
  165|      0|      return status_train;
  166|      0|    }
  167|      0|  }
  168|       |
  169|  10.1k|  return util::OkStatus();
  170|  10.1k|}
_ZN13sentencepiece20SentencePieceTrainer5TrainENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPNS_16SentenceIteratorEPNS1_12basic_stringIcS4_NS1_9allocatorIcEEEE:
  175|  10.1k|                                         std::string *serialized_model_proto) {
  176|  30.3k|  LOG(INFO) << "Running command: " << args.data();
  ------------------
  |  |  218|  10.1k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  10.1k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  10.1k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  20.2k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  20.2k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 10.1k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  10.1k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  10.1k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  10.1k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  30.3k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  30.3k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  177|  10.1k|  TrainerSpec trainer_spec;
  178|  10.1k|  NormalizerSpec normalizer_spec;
  179|  10.1k|  NormalizerSpec denormalizer_spec;
  180|  10.1k|  RETURN_IF_ERROR(MergeSpecsFromArgs(args, &trainer_spec, &normalizer_spec,
  ------------------
  |  |   44|  10.1k|  do {                                 \
  |  |   45|  10.1k|    const auto _status = expr;         \
  |  |   46|  10.1k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |   47|  10.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 10.1k]
  |  |  ------------------
  ------------------
  181|  10.1k|                                     &denormalizer_spec));
  182|  10.1k|  return Train(trainer_spec, normalizer_spec, denormalizer_spec,
  183|  10.1k|               sentence_iterator, serialized_model_proto);
  184|  10.1k|}
_ZN13sentencepiece20SentencePieceTrainer5TrainENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKNS1_6vectorINS1_12basic_stringIcS4_NS1_9allocatorIcEEEENS8_ISA_EEEEPSA_:
  219|  10.1k|    std::string *serialized_model_proto) {
  220|  10.1k|  VectorSentenceIterator iter(sentences);
  221|  10.1k|  return Train(args, &iter, serialized_model_proto);
  222|  10.1k|}
_ZN13sentencepiece20SentencePieceTrainer22PopulateNormalizerSpecEPNS_14NormalizerSpecEb:
  235|  20.2k|    NormalizerSpec *normalizer_spec, bool is_denormalizer) {
  236|  20.2k|  RET_CHECK(normalizer_spec);
  ------------------
  |  |  321|  20.2k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 20.2k, False: 0]
  |  |  ------------------
  |  |  322|  20.2k|  } else /* NOLINT */                                        \
  |  |  323|  20.2k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  237|       |
  238|  20.2k|  if (!normalizer_spec->normalization_rule_tsv().empty()) {
  ------------------
  |  Branch (238:7): [True: 0, False: 20.2k]
  ------------------
  239|      0|    RET_CHECK(normalizer_spec->precompiled_charsmap().empty())
  ------------------
  |  |  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 << "] "
  ------------------
  240|      0|        << "precompiled_charsmap is already defined.";
  241|      0|    normalizer::Builder::CharsMap chars_map;
  242|      0|    RETURN_IF_ERROR(normalizer::Builder::LoadCharsMap(
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  243|      0|        normalizer_spec->normalization_rule_tsv(), &chars_map));
  244|      0|    RETURN_IF_ERROR(normalizer::Builder::CompileCharsMap(
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  245|      0|        chars_map, normalizer_spec->mutable_precompiled_charsmap()));
  246|      0|    normalizer_spec->set_name("user_defined");
  247|  20.2k|  } else if (!is_denormalizer) {
  ------------------
  |  Branch (247:14): [True: 10.1k, False: 10.1k]
  ------------------
  248|  10.1k|    if (normalizer_spec->name().empty()) {
  ------------------
  |  Branch (248:9): [True: 10.1k, False: 0]
  ------------------
  249|  10.1k|      normalizer_spec->set_name(kDefaultNormalizerName);
  250|  10.1k|    }
  251|  10.1k|    if (normalizer_spec->precompiled_charsmap().empty()) {
  ------------------
  |  Branch (251:9): [True: 10.1k, False: 0]
  ------------------
  252|  10.1k|      RETURN_IF_ERROR(normalizer::Builder::GetPrecompiledCharsMap(
  ------------------
  |  |   44|  10.1k|  do {                                 \
  |  |   45|  10.1k|    const auto _status = expr;         \
  |  |   46|  10.1k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |   47|  10.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 10.1k]
  |  |  ------------------
  ------------------
  253|  10.1k|          normalizer_spec->name(),
  254|  10.1k|          normalizer_spec->mutable_precompiled_charsmap()));
  255|  10.1k|    }
  256|  10.1k|  }
  257|       |
  258|  20.2k|  return util::OkStatus();
  259|  20.2k|}
_ZN13sentencepiece20SentencePieceTrainer26GetPretokenizerForTrainingEv:
  292|  18.7k|SentencePieceTrainer::GetPretokenizerForTraining() {
  293|  18.7k|  return g_pretokenizer;
  294|  18.7k|}
sentencepiece_trainer.cc:_ZN13sentencepiece12_GLOBAL__N_122VectorSentenceIteratorC2ERKNSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEE:
  203|  10.1k|      : iter_(values.begin()), end_(values.end()) {}
sentencepiece_trainer.cc:_ZNK13sentencepiece12_GLOBAL__N_122VectorSentenceIterator4doneEv:
  205|  75.9k|  virtual bool done() const { return iter_ == end_; }
sentencepiece_trainer.cc:_ZN13sentencepiece12_GLOBAL__N_122VectorSentenceIterator4NextEv:
  206|  65.7k|  void Next() override { ++iter_; }
sentencepiece_trainer.cc:_ZNK13sentencepiece12_GLOBAL__N_122VectorSentenceIterator5valueEv:
  207|  65.7k|  const std::string &value() const override { return *iter_; }
sentencepiece_trainer.cc:_ZNK13sentencepiece12_GLOBAL__N_122VectorSentenceIterator6statusEv:
  208|  10.1k|  util::Status status() const override { return util::OkStatus(); }

_ZN13sentencepiece16SentenceIteratorD2Ev:
   48|  10.1k|  virtual ~SentenceIterator() {}

_ZN13sentencepiece20SentencePieceTrainer13SetProtoFieldENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_PNS_11TrainerSpecE:
  197|  48.1k|                                                 TrainerSpec *message) {
  198|  48.1k|  RET_CHECK(message);
  ------------------
  |  |  321|  48.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 48.1k, False: 0]
  |  |  ------------------
  |  |  322|  48.1k|  } else /* NOLINT */                                        \
  |  |  323|  48.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  199|       |
  200|  48.1k|  PARSE_REPEATED_STRING(input);
  ------------------
  |  |   36|  48.1k|  if (name == #param_name) {                             \
  |  |  ------------------
  |  |  |  Branch (36:7): [True: 0, False: 48.1k]
  |  |  ------------------
  |  |   37|      0|    for (const auto &val : util::StrSplitAsCSV(value)) { \
  |  |  ------------------
  |  |  |  Branch (37:26): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      message->add_##param_name(val);                    \
  |  |   39|      0|    }                                                    \
  |  |   40|      0|    return util::OkStatus();                             \
  |  |   41|      0|  }
  ------------------
  201|  48.1k|  PARSE_STRING(input_format);
  ------------------
  |  |   30|  48.1k|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 48.1k]
  |  |  ------------------
  |  |   31|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   32|      0|    return util::OkStatus();                               \
  |  |   33|      0|  }
  ------------------
  202|  48.1k|  PARSE_STRING(model_prefix);
  ------------------
  |  |   30|  48.1k|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 48.1k]
  |  |  ------------------
  |  |   31|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   32|      0|    return util::OkStatus();                               \
  |  |   33|      0|  }
  ------------------
  203|       |
  204|  48.1k|  static const std::map<std::string, TrainerSpec::ModelType> kModelType_Map = {
  205|  48.1k|      {"UNIGRAM", TrainerSpec::UNIGRAM},
  206|  48.1k|      {"BPE", TrainerSpec::BPE},
  207|  48.1k|      {"WORD", TrainerSpec::WORD},
  208|  48.1k|      {"CHAR", TrainerSpec::CHAR},
  209|  48.1k|  };
  210|       |
  211|  48.1k|  PARSE_ENUM(model_type, kModelType_Map);
  ------------------
  |  |   90|  48.1k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (90:7): [True: 10.1k, False: 38.0k]
  |  |  ------------------
  |  |   91|  10.1k|    const auto it = map_name.find(absl::AsciiStrToUpper(value));              \
  |  |   92|  10.1k|    if (it == map_name.end())                                                 \
  |  |  ------------------
  |  |  |  Branch (92:9): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |   93|  10.1k|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   94|      0|             << "unknown enumeration value of \"" << value << "\" as "        \
  |  |   95|      0|             << #map_name;                                                    \
  |  |   96|  10.1k|    message->set_##param_name(it->second);                                    \
  |  |   97|  10.1k|    return util::OkStatus();                                                  \
  |  |   98|  10.1k|  }
  ------------------
  212|  38.0k|  PARSE_INT32(vocab_size);
  ------------------
  |  |   50|  38.0k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 10.1k, False: 27.8k]
  |  |  ------------------
  |  |   51|  10.1k|    int32_t v;                                                                \
  |  |   52|  10.1k|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (52:9): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |   53|  10.1k|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   54|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   55|  10.1k|    message->set_##param_name(v);                                             \
  |  |   56|  10.1k|    return util::OkStatus();                                                  \
  |  |   57|  10.1k|  }
  ------------------
  213|  27.8k|  PARSE_REPEATED_STRING(accept_language);
  ------------------
  |  |   36|  27.8k|  if (name == #param_name) {                             \
  |  |  ------------------
  |  |  |  Branch (36:7): [True: 0, False: 27.8k]
  |  |  ------------------
  |  |   37|      0|    for (const auto &val : util::StrSplitAsCSV(value)) { \
  |  |  ------------------
  |  |  |  Branch (37:26): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      message->add_##param_name(val);                    \
  |  |   39|      0|    }                                                    \
  |  |   40|      0|    return util::OkStatus();                             \
  |  |   41|      0|  }
  ------------------
  214|  27.8k|  PARSE_INT32(self_test_sample_size);
  ------------------
  |  |   50|  27.8k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 27.8k]
  |  |  ------------------
  |  |   51|      0|    int32_t v;                                                                \
  |  |   52|      0|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (52:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   53|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   54|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   55|      0|    message->set_##param_name(v);                                             \
  |  |   56|      0|    return util::OkStatus();                                                  \
  |  |   57|      0|  }
  ------------------
  215|  27.8k|  PARSE_DOUBLE(character_coverage);
  ------------------
  |  |   70|  27.8k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (70:7): [True: 2.54k, False: 25.3k]
  |  |  ------------------
  |  |   71|  2.54k|    double v;                                                                 \
  |  |   72|  2.54k|    if (!absl::SimpleAtod(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (72:9): [True: 0, False: 2.54k]
  |  |  ------------------
  |  |   73|  2.54k|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   74|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   75|  2.54k|    message->set_##param_name(v);                                             \
  |  |   76|  2.54k|    return util::OkStatus();                                                  \
  |  |   77|  2.54k|  }
  ------------------
  216|  25.3k|  PARSE_UINT64(input_sentence_size);
  ------------------
  |  |   60|  25.3k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (60:7): [True: 2.04k, False: 23.2k]
  |  |  ------------------
  |  |   61|  2.04k|    uint64_t v;                                                               \
  |  |   62|  2.04k|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 2.04k]
  |  |  ------------------
  |  |   63|  2.04k|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   64|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   65|  2.04k|    message->set_##param_name(v);                                             \
  |  |   66|  2.04k|    return util::OkStatus();                                                  \
  |  |   67|  2.04k|  }
  ------------------
  217|  23.2k|  PARSE_BOOL(shuffle_input_sentence);
  ------------------
  |  |   80|  23.2k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 2.53k, False: 20.7k]
  |  |  ------------------
  |  |   81|  2.53k|    bool v;                                                                   \
  |  |   82|  2.53k|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 2.53k]
  |  |  |  Branch (82:27): [True: 0, False: 2.53k]
  |  |  ------------------
  |  |   83|  2.53k|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|  2.53k|    message->set_##param_name(v);                                             \
  |  |   86|  2.53k|    return util::OkStatus();                                                  \
  |  |   87|  2.53k|  }
  ------------------
  218|  20.7k|  PARSE_INT32(seed_sentencepiece_size);
  ------------------
  |  |   50|  20.7k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 20.7k]
  |  |  ------------------
  |  |   51|      0|    int32_t v;                                                                \
  |  |   52|      0|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (52:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   53|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   54|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   55|      0|    message->set_##param_name(v);                                             \
  |  |   56|      0|    return util::OkStatus();                                                  \
  |  |   57|      0|  }
  ------------------
  219|  20.7k|  PARSE_DOUBLE(shrinking_factor);
  ------------------
  |  |   70|  20.7k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (70:7): [True: 0, False: 20.7k]
  |  |  ------------------
  |  |   71|      0|    double v;                                                                 \
  |  |   72|      0|    if (!absl::SimpleAtod(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (72:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   73|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   74|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   75|      0|    message->set_##param_name(v);                                             \
  |  |   76|      0|    return util::OkStatus();                                                  \
  |  |   77|      0|  }
  ------------------
  220|  20.7k|  PARSE_INT32(max_sentence_length);
  ------------------
  |  |   50|  20.7k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 20.7k]
  |  |  ------------------
  |  |   51|      0|    int32_t v;                                                                \
  |  |   52|      0|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (52:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   53|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   54|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   55|      0|    message->set_##param_name(v);                                             \
  |  |   56|      0|    return util::OkStatus();                                                  \
  |  |   57|      0|  }
  ------------------
  221|  20.7k|  PARSE_INT32(num_threads);
  ------------------
  |  |   50|  20.7k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 10.1k, False: 10.6k]
  |  |  ------------------
  |  |   51|  10.1k|    int32_t v;                                                                \
  |  |   52|  10.1k|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (52:9): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |   53|  10.1k|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   54|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   55|  10.1k|    message->set_##param_name(v);                                             \
  |  |   56|  10.1k|    return util::OkStatus();                                                  \
  |  |   57|  10.1k|  }
  ------------------
  222|  10.6k|  PARSE_INT32(num_sub_iterations);
  ------------------
  |  |   50|  10.6k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 10.6k]
  |  |  ------------------
  |  |   51|      0|    int32_t v;                                                                \
  |  |   52|      0|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (52:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   53|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   54|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   55|      0|    message->set_##param_name(v);                                             \
  |  |   56|      0|    return util::OkStatus();                                                  \
  |  |   57|      0|  }
  ------------------
  223|  10.6k|  PARSE_INT32(max_sentencepiece_length);
  ------------------
  |  |   50|  10.6k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 10.6k]
  |  |  ------------------
  |  |   51|      0|    int32_t v;                                                                \
  |  |   52|      0|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (52:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   53|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   54|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   55|      0|    message->set_##param_name(v);                                             \
  |  |   56|      0|    return util::OkStatus();                                                  \
  |  |   57|      0|  }
  ------------------
  224|  10.6k|  PARSE_BOOL(split_by_unicode_script);
  ------------------
  |  |   80|  10.6k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 3.55k, False: 7.05k]
  |  |  ------------------
  |  |   81|  3.55k|    bool v;                                                                   \
  |  |   82|  3.55k|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 3.55k]
  |  |  |  Branch (82:27): [True: 0, False: 3.55k]
  |  |  ------------------
  |  |   83|  3.55k|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|  3.55k|    message->set_##param_name(v);                                             \
  |  |   86|  3.55k|    return util::OkStatus();                                                  \
  |  |   87|  3.55k|  }
  ------------------
  225|  7.05k|  PARSE_BOOL(split_by_number);
  ------------------
  |  |   80|  7.05k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 2.75k, False: 4.30k]
  |  |  ------------------
  |  |   81|  2.75k|    bool v;                                                                   \
  |  |   82|  2.75k|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 2.75k]
  |  |  |  Branch (82:27): [True: 0, False: 2.75k]
  |  |  ------------------
  |  |   83|  2.75k|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|  2.75k|    message->set_##param_name(v);                                             \
  |  |   86|  2.75k|    return util::OkStatus();                                                  \
  |  |   87|  2.75k|  }
  ------------------
  226|  4.30k|  PARSE_BOOL(split_by_whitespace);
  ------------------
  |  |   80|  4.30k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 2.64k, False: 1.65k]
  |  |  ------------------
  |  |   81|  2.64k|    bool v;                                                                   \
  |  |   82|  2.64k|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 2.64k]
  |  |  |  Branch (82:27): [True: 0, False: 2.64k]
  |  |  ------------------
  |  |   83|  2.64k|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|  2.64k|    message->set_##param_name(v);                                             \
  |  |   86|  2.64k|    return util::OkStatus();                                                  \
  |  |   87|  2.64k|  }
  ------------------
  227|  1.65k|  PARSE_BOOL(split_digits);
  ------------------
  |  |   80|  1.65k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 0, False: 1.65k]
  |  |  ------------------
  |  |   81|      0|    bool v;                                                                   \
  |  |   82|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 0]
  |  |  |  Branch (82:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   83|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|      0|    message->set_##param_name(v);                                             \
  |  |   86|      0|    return util::OkStatus();                                                  \
  |  |   87|      0|  }
  ------------------
  228|  1.65k|  PARSE_STRING(pretokenization_delimiter);
  ------------------
  |  |   30|  1.65k|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 1.65k]
  |  |  ------------------
  |  |   31|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   32|      0|    return util::OkStatus();                               \
  |  |   33|      0|  }
  ------------------
  229|  1.65k|  PARSE_BOOL(treat_whitespace_as_suffix);
  ------------------
  |  |   80|  1.65k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 0, False: 1.65k]
  |  |  ------------------
  |  |   81|      0|    bool v;                                                                   \
  |  |   82|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 0]
  |  |  |  Branch (82:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   83|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|      0|    message->set_##param_name(v);                                             \
  |  |   86|      0|    return util::OkStatus();                                                  \
  |  |   87|      0|  }
  ------------------
  230|  1.65k|  PARSE_BOOL(allow_whitespace_only_pieces);
  ------------------
  |  |   80|  1.65k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 0, False: 1.65k]
  |  |  ------------------
  |  |   81|      0|    bool v;                                                                   \
  |  |   82|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 0]
  |  |  |  Branch (82:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   83|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|      0|    message->set_##param_name(v);                                             \
  |  |   86|      0|    return util::OkStatus();                                                  \
  |  |   87|      0|  }
  ------------------
  231|  1.65k|  PARSE_REPEATED_STRING(control_symbols);
  ------------------
  |  |   36|  1.65k|  if (name == #param_name) {                             \
  |  |  ------------------
  |  |  |  Branch (36:7): [True: 0, False: 1.65k]
  |  |  ------------------
  |  |   37|      0|    for (const auto &val : util::StrSplitAsCSV(value)) { \
  |  |  ------------------
  |  |  |  Branch (37:26): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      message->add_##param_name(val);                    \
  |  |   39|      0|    }                                                    \
  |  |   40|      0|    return util::OkStatus();                             \
  |  |   41|      0|  }
  ------------------
  232|  1.65k|  PARSE_REPEATED_STRING(user_defined_symbols);
  ------------------
  |  |   36|  1.65k|  if (name == #param_name) {                             \
  |  |  ------------------
  |  |  |  Branch (36:7): [True: 0, False: 1.65k]
  |  |  ------------------
  |  |   37|      0|    for (const auto &val : util::StrSplitAsCSV(value)) { \
  |  |  ------------------
  |  |  |  Branch (37:26): [True: 0, False: 0]
  |  |  ------------------
  |  |   38|      0|      message->add_##param_name(val);                    \
  |  |   39|      0|    }                                                    \
  |  |   40|      0|    return util::OkStatus();                             \
  |  |   41|      0|  }
  ------------------
  233|  1.65k|  PARSE_STRING(required_chars);
  ------------------
  |  |   30|  1.65k|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 1.65k]
  |  |  ------------------
  |  |   31|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   32|      0|    return util::OkStatus();                               \
  |  |   33|      0|  }
  ------------------
  234|  1.65k|  PARSE_BOOL(byte_fallback);
  ------------------
  |  |   80|  1.65k|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 1.65k, False: 0]
  |  |  ------------------
  |  |   81|  1.65k|    bool v;                                                                   \
  |  |   82|  1.65k|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 1.65k]
  |  |  |  Branch (82:27): [True: 0, False: 1.65k]
  |  |  ------------------
  |  |   83|  1.65k|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|  1.65k|    message->set_##param_name(v);                                             \
  |  |   86|  1.65k|    return util::OkStatus();                                                  \
  |  |   87|  1.65k|  }
  ------------------
  235|      0|  PARSE_BOOL(hard_vocab_limit);
  ------------------
  |  |   80|      0|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   81|      0|    bool v;                                                                   \
  |  |   82|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 0]
  |  |  |  Branch (82:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   83|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|      0|    message->set_##param_name(v);                                             \
  |  |   86|      0|    return util::OkStatus();                                                  \
  |  |   87|      0|  }
  ------------------
  236|      0|  PARSE_BOOL(vocabulary_output_piece_score);
  ------------------
  |  |   80|      0|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   81|      0|    bool v;                                                                   \
  |  |   82|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 0]
  |  |  |  Branch (82:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   83|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|      0|    message->set_##param_name(v);                                             \
  |  |   86|      0|    return util::OkStatus();                                                  \
  |  |   87|      0|  }
  ------------------
  237|      0|  PARSE_BOOL(train_extremely_large_corpus);
  ------------------
  |  |   80|      0|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   81|      0|    bool v;                                                                   \
  |  |   82|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 0]
  |  |  |  Branch (82:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   83|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|      0|    message->set_##param_name(v);                                             \
  |  |   86|      0|    return util::OkStatus();                                                  \
  |  |   87|      0|  }
  ------------------
  238|      0|  PARSE_STRING(seed_sentencepieces_file);
  ------------------
  |  |   30|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   31|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   32|      0|    return util::OkStatus();                               \
  |  |   33|      0|  }
  ------------------
  239|      0|  PARSE_BOOL(use_all_vocab);
  ------------------
  |  |   80|      0|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   81|      0|    bool v;                                                                   \
  |  |   82|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 0]
  |  |  |  Branch (82:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   83|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|      0|    message->set_##param_name(v);                                             \
  |  |   86|      0|    return util::OkStatus();                                                  \
  |  |   87|      0|  }
  ------------------
  240|      0|  PARSE_INT32(unk_id);
  ------------------
  |  |   50|      0|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   51|      0|    int32_t v;                                                                \
  |  |   52|      0|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (52:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   53|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   54|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   55|      0|    message->set_##param_name(v);                                             \
  |  |   56|      0|    return util::OkStatus();                                                  \
  |  |   57|      0|  }
  ------------------
  241|      0|  PARSE_INT32(bos_id);
  ------------------
  |  |   50|      0|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   51|      0|    int32_t v;                                                                \
  |  |   52|      0|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (52:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   53|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   54|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   55|      0|    message->set_##param_name(v);                                             \
  |  |   56|      0|    return util::OkStatus();                                                  \
  |  |   57|      0|  }
  ------------------
  242|      0|  PARSE_INT32(eos_id);
  ------------------
  |  |   50|      0|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   51|      0|    int32_t v;                                                                \
  |  |   52|      0|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (52:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   53|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   54|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   55|      0|    message->set_##param_name(v);                                             \
  |  |   56|      0|    return util::OkStatus();                                                  \
  |  |   57|      0|  }
  ------------------
  243|      0|  PARSE_INT32(pad_id);
  ------------------
  |  |   50|      0|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (50:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   51|      0|    int32_t v;                                                                \
  |  |   52|      0|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (52:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   53|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   54|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   55|      0|    message->set_##param_name(v);                                             \
  |  |   56|      0|    return util::OkStatus();                                                  \
  |  |   57|      0|  }
  ------------------
  244|      0|  PARSE_STRING(unk_piece);
  ------------------
  |  |   30|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   31|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   32|      0|    return util::OkStatus();                               \
  |  |   33|      0|  }
  ------------------
  245|      0|  PARSE_STRING(bos_piece);
  ------------------
  |  |   30|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   31|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   32|      0|    return util::OkStatus();                               \
  |  |   33|      0|  }
  ------------------
  246|      0|  PARSE_STRING(eos_piece);
  ------------------
  |  |   30|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   31|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   32|      0|    return util::OkStatus();                               \
  |  |   33|      0|  }
  ------------------
  247|      0|  PARSE_STRING(pad_piece);
  ------------------
  |  |   30|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   31|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   32|      0|    return util::OkStatus();                               \
  |  |   33|      0|  }
  ------------------
  248|      0|  PARSE_STRING(unk_surface);
  ------------------
  |  |   30|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (30:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   31|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   32|      0|    return util::OkStatus();                               \
  |  |   33|      0|  }
  ------------------
  249|      0|  PARSE_BOOL(enable_differential_privacy);
  ------------------
  |  |   80|      0|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (80:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   81|      0|    bool v;                                                                   \
  |  |   82|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))                \
  |  |  ------------------
  |  |  |  Branch (82:9): [True: 0, False: 0]
  |  |  |  Branch (82:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   83|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   84|      0|             << "cannot parse \"" << value << "\" as bool.";                  \
  |  |   85|      0|    message->set_##param_name(v);                                             \
  |  |   86|      0|    return util::OkStatus();                                                  \
  |  |   87|      0|  }
  ------------------
  250|      0|  PARSE_DOUBLE(differential_privacy_noise_level);
  ------------------
  |  |   70|      0|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (70:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   71|      0|    double v;                                                                 \
  |  |   72|      0|    if (!absl::SimpleAtod(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (72:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   73|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   74|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   75|      0|    message->set_##param_name(v);                                             \
  |  |   76|      0|    return util::OkStatus();                                                  \
  |  |   77|      0|  }
  ------------------
  251|      0|  PARSE_UINT64(differential_privacy_clipping_threshold);
  ------------------
  |  |   60|      0|  if (name == #param_name) {                                                  \
  |  |  ------------------
  |  |  |  Branch (60:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   61|      0|    uint64_t v;                                                               \
  |  |   62|      0|    if (!absl::SimpleAtoi(value, &v))                                         \
  |  |  ------------------
  |  |  |  Branch (62:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   63|      0|      return util::StatusBuilder(util::StatusCode::kInvalidArgument, GTL_LOC) \
  |  |  ------------------
  |  |  |  |  300|      0|#define GTL_LOC (0)
  |  |  ------------------
  |  |   64|      0|             << "cannot parse \"" << value << "\" as int.";                   \
  |  |   65|      0|    message->set_##param_name(v);                                             \
  |  |   66|      0|    return util::OkStatus();                                                  \
  |  |   67|      0|  }
  ------------------
  252|       |
  253|      0|  return util::StatusBuilder(util::StatusCode::kNotFound, GTL_LOC)
  ------------------
  |  |  300|      0|#define GTL_LOC (0)
  ------------------
  254|      0|         << "unknown field name \"" << name << "\" in TrainerSpec.";
  255|      0|}
_ZN13sentencepiece10PrintProtoERKNS_11TrainerSpecENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  115|  10.1k|                              absl::string_view name) {
  116|  10.1k|  std::ostringstream os;
  117|       |
  118|  10.1k|  os << name << " {\n";
  119|       |
  120|  10.1k|  PRINT_REPEATED_STRING(input);
  ------------------
  |  |  104|  10.1k|  for (const auto &v : message.param_name()) \
  |  |  ------------------
  |  |  |  Branch (104:22): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |  105|  10.1k|    os << "  " << #param_name << ": " << v << "\n";
  ------------------
  121|  10.1k|  PRINT_PARAM(input_format);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  122|  10.1k|  PRINT_PARAM(model_prefix);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  123|       |
  124|  10.1k|  static const std::map<TrainerSpec::ModelType, std::string> kModelType_Map = {
  125|  10.1k|      {TrainerSpec::UNIGRAM, "UNIGRAM"},
  126|  10.1k|      {TrainerSpec::BPE, "BPE"},
  127|  10.1k|      {TrainerSpec::WORD, "WORD"},
  128|  10.1k|      {TrainerSpec::CHAR, "CHAR"},
  129|  10.1k|  };
  130|       |
  131|  10.1k|  PRINT_ENUM(model_type, kModelType_Map);
  ------------------
  |  |  108|  10.1k|  const auto it = map_name.find(message.param_name()); \
  |  |  109|  10.1k|  if (it == map_name.end())                            \
  |  |  ------------------
  |  |  |  Branch (109:7): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |  110|  10.1k|    os << "  " << #param_name << ": unknown\n";        \
  |  |  111|  10.1k|  else                                                 \
  |  |  112|  10.1k|    os << "  " << #param_name << ": " << it->second << "\n";
  ------------------
  132|  10.1k|  PRINT_PARAM(vocab_size);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  133|  10.1k|  PRINT_REPEATED_STRING(accept_language);
  ------------------
  |  |  104|  10.1k|  for (const auto &v : message.param_name()) \
  |  |  ------------------
  |  |  |  Branch (104:22): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |  105|  10.1k|    os << "  " << #param_name << ": " << v << "\n";
  ------------------
  134|  10.1k|  PRINT_PARAM(self_test_sample_size);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  135|  10.1k|  PRINT_PARAM(character_coverage);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  136|  10.1k|  PRINT_PARAM(input_sentence_size);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  137|  10.1k|  PRINT_PARAM(shuffle_input_sentence);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  138|  10.1k|  PRINT_PARAM(seed_sentencepiece_size);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  139|  10.1k|  PRINT_PARAM(shrinking_factor);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  140|  10.1k|  PRINT_PARAM(max_sentence_length);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  141|  10.1k|  PRINT_PARAM(num_threads);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  142|  10.1k|  PRINT_PARAM(num_sub_iterations);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  143|  10.1k|  PRINT_PARAM(max_sentencepiece_length);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  144|  10.1k|  PRINT_PARAM(split_by_unicode_script);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  145|  10.1k|  PRINT_PARAM(split_by_number);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  146|  10.1k|  PRINT_PARAM(split_by_whitespace);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  147|  10.1k|  PRINT_PARAM(split_digits);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  148|  10.1k|  PRINT_PARAM(pretokenization_delimiter);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  149|  10.1k|  PRINT_PARAM(treat_whitespace_as_suffix);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  150|  10.1k|  PRINT_PARAM(allow_whitespace_only_pieces);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  151|  10.1k|  PRINT_REPEATED_STRING(control_symbols);
  ------------------
  |  |  104|  10.1k|  for (const auto &v : message.param_name()) \
  |  |  ------------------
  |  |  |  Branch (104:22): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |  105|  10.1k|    os << "  " << #param_name << ": " << v << "\n";
  ------------------
  152|  10.1k|  PRINT_REPEATED_STRING(user_defined_symbols);
  ------------------
  |  |  104|  10.1k|  for (const auto &v : message.param_name()) \
  |  |  ------------------
  |  |  |  Branch (104:22): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |  105|  10.1k|    os << "  " << #param_name << ": " << v << "\n";
  ------------------
  153|  10.1k|  PRINT_PARAM(required_chars);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  154|  10.1k|  PRINT_PARAM(byte_fallback);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  155|  10.1k|  PRINT_PARAM(vocabulary_output_piece_score);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  156|  10.1k|  PRINT_PARAM(train_extremely_large_corpus);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  157|  10.1k|  PRINT_PARAM(seed_sentencepieces_file);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  158|  10.1k|  PRINT_PARAM(hard_vocab_limit);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  159|  10.1k|  PRINT_PARAM(use_all_vocab);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  160|  10.1k|  PRINT_PARAM(unk_id);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  161|  10.1k|  PRINT_PARAM(bos_id);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  162|  10.1k|  PRINT_PARAM(eos_id);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  163|  10.1k|  PRINT_PARAM(pad_id);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  164|  10.1k|  PRINT_PARAM(unk_piece);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  165|  10.1k|  PRINT_PARAM(bos_piece);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  166|  10.1k|  PRINT_PARAM(eos_piece);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  167|  10.1k|  PRINT_PARAM(pad_piece);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  168|  10.1k|  PRINT_PARAM(unk_surface);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  169|  10.1k|  PRINT_PARAM(enable_differential_privacy);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  170|  10.1k|  PRINT_PARAM(differential_privacy_noise_level);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  171|  10.1k|  PRINT_PARAM(differential_privacy_clipping_threshold);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  172|       |
  173|  10.1k|  os << "}\n";
  174|       |
  175|  10.1k|  return os.str();
  176|  10.1k|}
_ZN13sentencepiece10PrintProtoERKNS_14NormalizerSpecENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  179|  10.1k|                              absl::string_view name) {
  180|  10.1k|  std::ostringstream os;
  181|       |
  182|  10.1k|  os << name << " {\n";
  183|       |
  184|  10.1k|  PRINT_PARAM(name);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  185|  10.1k|  PRINT_PARAM(add_dummy_prefix);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  186|  10.1k|  PRINT_PARAM(remove_extra_whitespaces);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  187|  10.1k|  PRINT_PARAM(escape_whitespaces);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  188|  10.1k|  PRINT_PARAM(normalization_rule_tsv);
  ------------------
  |  |  101|  10.1k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  189|       |
  190|  10.1k|  os << "}\n";
  191|       |
  192|  10.1k|  return os.str();
  193|  10.1k|}

_ZN13sentencepiece14TrainerFactory6CreateERKNS_11TrainerSpecERKNS_14NormalizerSpecES6_:
   27|  10.1k|    const NormalizerSpec &denormalizer_spec) {
   28|  10.1k|  switch (trainer_spec.model_type()) {
   29|  6.89k|    case TrainerSpec::UNIGRAM:
  ------------------
  |  Branch (29:5): [True: 6.89k, False: 3.23k]
  ------------------
   30|  6.89k|      return std::make_unique<unigram::Trainer>(trainer_spec, normalizer_spec,
   31|  6.89k|                                                denormalizer_spec);
   32|      0|      break;
   33|  1.81k|    case TrainerSpec::BPE:
  ------------------
  |  Branch (33:5): [True: 1.81k, False: 8.31k]
  ------------------
   34|  1.81k|      return std::make_unique<bpe::Trainer>(trainer_spec, normalizer_spec,
   35|  1.81k|                                            denormalizer_spec);
   36|      0|      break;
   37|  1.17k|    case TrainerSpec::WORD:
  ------------------
  |  Branch (37:5): [True: 1.17k, False: 8.96k]
  ------------------
   38|  1.17k|      return std::make_unique<word::Trainer>(trainer_spec, normalizer_spec,
   39|  1.17k|                                             denormalizer_spec);
   40|      0|      break;
   41|    246|    case TrainerSpec::CHAR:
  ------------------
  |  Branch (41:5): [True: 246, False: 9.88k]
  ------------------
   42|    246|      return std::make_unique<character::Trainer>(trainer_spec, normalizer_spec,
   43|    246|                                                  denormalizer_spec);
   44|      0|      break;
   45|      0|    default:
  ------------------
  |  Branch (45:5): [True: 0, False: 10.1k]
  ------------------
   46|      0|      LOG(FATAL) << "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) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  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]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   66|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   47|      0|      break;
   48|  10.1k|  }
   49|       |
   50|      0|  return std::make_unique<unigram::Trainer>(trainer_spec, normalizer_spec,
   51|      0|                                            denormalizer_spec);
   52|  10.1k|}

_ZN13sentencepiece16TrainerInterfaceC2ERKNS_11TrainerSpecERKNS_14NormalizerSpecES6_:
  205|  10.1k|    : trainer_spec_(trainer_spec),
  206|  10.1k|      normalizer_spec_(normalizer_spec),
  207|  10.1k|      denormalizer_spec_(denormalizer_spec) {
  208|  10.1k|  status_ = VerifySpec(trainer_spec_);
  209|  10.1k|  if (status_.ok()) status_ = InitMetaPieces();
  ------------------
  |  Branch (209:7): [True: 10.1k, False: 7]
  ------------------
  210|  10.1k|}
_ZN13sentencepiece16TrainerInterfaceD2Ev:
  212|  10.1k|TrainerInterface::~TrainerInterface() {}
_ZNK13sentencepiece16TrainerInterface20IsValidSentencePieceERKNSt3__16vectorIjNS1_9allocatorIjEEEE:
  215|  11.4M|    const string_util::UnicodeText &sentencepiece) const {
  216|       |  // Returns false if the length of piece is invalid.
  217|  11.4M|  if (sentencepiece.empty() ||
  ------------------
  |  Branch (217:7): [True: 0, False: 11.4M]
  ------------------
  218|  11.4M|      sentencepiece.size() >
  ------------------
  |  Branch (218:7): [True: 3.09M, False: 8.35M]
  ------------------
  219|  11.4M|          static_cast<size_t>(trainer_spec_.max_sentencepiece_length())) {
  220|  3.09M|    return false;
  221|  3.09M|  }
  222|       |
  223|  8.35M|  constexpr unicode_script::ScriptType kAnyType =
  224|  8.35M|      static_cast<unicode_script::ScriptType>(
  225|  8.35M|          std::numeric_limits<char32>::max());
  226|       |
  227|  8.35M|  unicode_script::ScriptType prev_script = kAnyType;
  228|  8.35M|  bool all_whitespace_piece =
  229|  8.35M|      std::all_of(sentencepiece.begin(), sentencepiece.end(),
  230|  8.35M|                  [](char32 c) { return c == kWSChar; });
  231|       |
  232|  46.4M|  for (size_t pos = 0; pos < sentencepiece.size(); ++pos) {
  ------------------
  |  Branch (232:24): [True: 39.4M, False: 7.05M]
  ------------------
  233|  39.4M|    const char32 c = sentencepiece[pos];
  234|  39.4M|    if (c == kUNKChar) {  // UNK must not be included
  ------------------
  |  Branch (234:9): [True: 958k, False: 38.4M]
  ------------------
  235|   958k|      return false;
  236|   958k|    }
  237|  38.4M|    if (c == 0x0000) {  // NULL is not allowed for Darts (TRIE).
  ------------------
  |  Branch (237:9): [True: 0, False: 38.4M]
  ------------------
  238|      0|      return false;
  239|      0|    }
  240|       |    // kUPPBoundaryChar is included when split_by_upp_for_training is true.
  241|  38.4M|    if (c == kUPPBoundaryChar) {
  ------------------
  |  Branch (241:9): [True: 0, False: 38.4M]
  ------------------
  242|      0|      return false;
  243|      0|    }
  244|  38.4M|    if (c == 0x0020) {
  ------------------
  |  Branch (244:9): [True: 0, False: 38.4M]
  ------------------
  245|      0|      LOG(WARNING) << "space must not be included in normalized string.";
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  246|      0|      return false;
  247|      0|    }
  248|  38.4M|    if (!string_util::IsValidCodepoint(c)) {
  ------------------
  |  Branch (248:9): [True: 0, False: 38.4M]
  ------------------
  249|      0|      return false;
  250|      0|    }
  251|       |
  252|  38.4M|    if (c == kWSChar) {
  ------------------
  |  Branch (252:9): [True: 5.82M, False: 32.6M]
  ------------------
  253|       |      // Only allows whitespace to appear as a prefix of piece unless
  254|       |      // allow_whitespace_only_pieces is True.
  255|       |      // When split_by_whitespace is false, we allow whitespaces to
  256|       |      // appear in the middle, "foo_bar", but do not allow them
  257|       |      // to appear as suffix, "foo_bar_".
  258|       |      // Regardless of the setting of split_by_whitespace,
  259|       |      // whitespace is treated as a prefix/infix of symbol or
  260|       |      // independent symbol, unless allow_whitespace_only_pieces() is true,
  261|       |      // in which case whitespace only pieces can occur.
  262|  5.82M|      if (!trainer_spec_.allow_whitespace_only_pieces() ||
  ------------------
  |  Branch (262:11): [True: 5.82M, False: 0]
  ------------------
  263|  5.82M|          !all_whitespace_piece) {
  ------------------
  |  Branch (263:11): [True: 0, False: 0]
  ------------------
  264|  5.82M|        if (trainer_spec_.treat_whitespace_as_suffix()) {
  ------------------
  |  Branch (264:13): [True: 0, False: 5.82M]
  ------------------
  265|      0|          if ((trainer_spec_.split_by_whitespace() &&
  ------------------
  |  Branch (265:16): [True: 0, False: 0]
  ------------------
  266|      0|               pos < sentencepiece.size() - 1) ||
  ------------------
  |  Branch (266:16): [True: 0, False: 0]
  ------------------
  267|      0|              (!trainer_spec_.split_by_whitespace() &&
  ------------------
  |  Branch (267:16): [True: 0, False: 0]
  ------------------
  268|      0|               pos < sentencepiece.size() - 1 && pos == 0)) {
  ------------------
  |  Branch (268:16): [True: 0, False: 0]
  |  Branch (268:50): [True: 0, False: 0]
  ------------------
  269|      0|            return false;
  270|      0|          }
  271|  5.82M|        } else {
  272|  5.82M|          if ((trainer_spec_.split_by_whitespace() && pos > 0) ||
  ------------------
  |  Branch (272:16): [True: 5.76M, False: 60.6k]
  |  Branch (272:55): [True: 0, False: 5.76M]
  ------------------
  273|  5.82M|              (!trainer_spec_.split_by_whitespace() && pos > 0 &&
  ------------------
  |  Branch (273:16): [True: 60.6k, False: 5.76M]
  |  Branch (273:56): [True: 40.8k, False: 19.8k]
  ------------------
  274|  40.8k|               pos == sentencepiece.size() - 1)) {
  ------------------
  |  Branch (274:16): [True: 34.5k, False: 6.33k]
  ------------------
  275|  34.5k|            return false;
  276|  34.5k|          }
  277|  5.82M|        }
  278|  5.82M|      }
  279|  32.6M|    } else {
  280|  32.6M|      auto s = unicode_script::GetScript(c);
  281|       |
  282|       |      // Merge Hiragana/Katakana into Han.
  283|  32.6M|      if (s == unicode_script::U_Hiragana || s == unicode_script::U_Katakana ||
  ------------------
  |  Branch (283:11): [True: 1.18k, False: 32.6M]
  |  Branch (283:46): [True: 874, False: 32.6M]
  ------------------
  284|  32.6M|          c == 0x30FC) {  // long vowel sound (Katakana) should be Katakana
  ------------------
  |  Branch (284:11): [True: 1.31k, False: 32.6M]
  ------------------
  285|  3.36k|        s = unicode_script::U_Han;
  286|  32.6M|      } else if (s == unicode_script::U_Inherited) {
  ------------------
  |  Branch (286:18): [True: 5.34k, False: 32.6M]
  ------------------
  287|  5.34k|        s = prev_script;
  288|  5.34k|      }
  289|       |
  290|  32.6M|      if (!trainer_spec_.split_by_number() && is_unicode_decimal_number(c)) {
  ------------------
  |  Branch (290:11): [True: 2.60M, False: 30.0M]
  |  Branch (290:47): [True: 979k, False: 1.62M]
  ------------------
  291|   979k|        s = kAnyType;
  292|   979k|      }
  293|       |
  294|  32.6M|      if (trainer_spec_.split_digits() && is_unicode_decimal_number(c)) {
  ------------------
  |  Branch (294:11): [True: 0, False: 32.6M]
  |  Branch (294:43): [True: 0, False: 0]
  ------------------
  295|      0|        if (sentencepiece.size() > 1) return false;
  ------------------
  |  Branch (295:13): [True: 0, False: 0]
  ------------------
  296|      0|      }
  297|       |
  298|       |      // Do not allow a piece to include multiple Unicode scripts
  299|       |      // when split_by_unicode_script() is true (default = true).
  300|  32.6M|      if (trainer_spec_.split_by_unicode_script() && s != kAnyType &&
  ------------------
  |  Branch (300:11): [True: 8.80M, False: 23.8M]
  |  Branch (300:54): [True: 8.40M, False: 391k]
  ------------------
  301|  8.40M|          prev_script != kAnyType && prev_script != s) {
  ------------------
  |  Branch (301:11): [True: 6.20M, False: 2.20M]
  |  Branch (301:38): [True: 300k, False: 5.90M]
  ------------------
  302|   300k|        return false;
  303|   300k|      }
  304|       |
  305|  32.3M|      prev_script = s;
  306|  32.3M|    }
  307|  38.4M|  }
  308|  7.05M|  return true;
  309|  8.35M|}
_ZN13sentencepiece16TrainerInterface13LoadSentencesEv:
  327|  10.1k|util::Status TrainerInterface::LoadSentences() {
  328|  10.1k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  10.1k|  do {                                 \
  |  |   45|  10.1k|    const auto _status = expr;         \
  |  |   46|  10.1k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |   47|  10.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 10.1k]
  |  |  ------------------
  ------------------
  329|  10.1k|  RET_CHECK(sentences_.empty());
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  330|  10.1k|  RET_CHECK(required_chars_.empty());
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  331|  10.1k|  RET_CHECK(trainer_spec_.input_format().empty() ||
  ------------------
  |  |  321|  30.3k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  Branch (321:7): [True: 0, False: 0]
  |  |  |  Branch (321:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  332|      0|            trainer_spec_.input_format() == "text" ||
  333|      0|            trainer_spec_.input_format() == "tsv")
  334|      0|      << "Supported formats are 'text' and 'tsv'.";
  335|       |
  336|  10.1k|  RET_CHECK((sentence_iterator_ != nullptr && trainer_spec_.input().empty()) ||
  ------------------
  |  |  321|  40.5k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  Branch (321:7): [True: 0, False: 0]
  |  |  |  Branch (321:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  337|      0|            (sentence_iterator_ == nullptr && !trainer_spec_.input().empty()))
  338|      0|      << "SentenceIterator and trainer_spec.input() must be exclusive.";
  339|       |
  340|  10.1k|  RET_CHECK(
  ------------------
  |  |  321|  40.5k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  Branch (321:7): [True: 0, False: 0]
  |  |  |  Branch (321:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  341|      0|      (output_model_proto_ != nullptr &&
  342|      0|       trainer_spec_.model_prefix().empty()) ||
  343|      0|      (output_model_proto_ == nullptr && !trainer_spec_.model_prefix().empty()))
  344|      0|      << "ModelProto and trainer_spec.model_prefix() must be exclusive.";
  345|       |
  346|  10.1k|  const bool is_tsv = trainer_spec_.input_format() == "tsv";
  347|       |
  348|  10.1k|  SentenceSelector selector(&sentences_, trainer_spec_);
  349|  10.1k|  random::ReservoirSampler<std::string> test_sentence_sampler(
  350|  10.1k|      &self_test_samples_, trainer_spec_.self_test_sample_size());
  351|       |
  352|  10.1k|  int too_long_lines = 0;
  353|       |
  354|  10.1k|  std::unique_ptr<SentenceIterator> sentence_iterator_impl;
  355|  10.1k|  if (sentence_iterator_ == nullptr) {
  ------------------
  |  Branch (355:7): [True: 0, False: 10.1k]
  ------------------
  356|      0|    LOG(INFO) << "SentenceIterator is not specified. Using "
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  357|      0|                 "MultiFileSentenceIterator.";
  358|      0|    sentence_iterator_impl =
  359|      0|        std::make_unique<MultiFileSentenceIterator>(std::vector<std::string>(
  360|      0|            trainer_spec_.input().begin(), trainer_spec_.input().end()));
  361|      0|    sentence_iterator_ = sentence_iterator_impl.get();
  362|      0|  }
  363|       |
  364|  75.9k|  for (; !sentence_iterator_->done(); sentence_iterator_->Next()) {
  ------------------
  |  Branch (364:10): [True: 65.7k, False: 10.1k]
  ------------------
  365|  65.7k|    int64_t freq = 1;
  366|  65.7k|    std::string sentence = sentence_iterator_->value();
  367|       |
  368|  65.7k|    if (is_tsv) {
  ------------------
  |  Branch (368:9): [True: 0, False: 65.7k]
  ------------------
  369|      0|      const std::vector<std::string> v = absl::StrSplit(sentence, '\t');
  370|      0|      RET_CHECK_EQ(v.size(), 2)
  ------------------
  |  |  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 << "] "
  |  |  ------------------
  ------------------
  371|      0|          << "Input format must be: word <tab> freq. " << sentence;
  372|      0|      sentence = v[0];
  373|      0|      RET_CHECK(absl::SimpleAtoi(v[1], &freq))
  ------------------
  |  |  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 << "] "
  ------------------
  374|      0|          << "Could not parse the frequency";
  375|      0|      RET_CHECK_GE(freq, 1);
  ------------------
  |  |  329|      0|#define RET_CHECK_GE(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 << "] "
  |  |  ------------------
  ------------------
  376|      0|    }
  377|       |
  378|  65.7k|    if (sentence.empty()) continue;
  ------------------
  |  Branch (378:9): [True: 0, False: 65.7k]
  ------------------
  379|       |
  380|  65.7k|    if (static_cast<int>(sentence.size()) >
  ------------------
  |  Branch (380:9): [True: 0, False: 65.7k]
  ------------------
  381|  65.7k|        trainer_spec_.max_sentence_length()) {
  382|      0|      if (too_long_lines == 0) {
  ------------------
  |  Branch (382:11): [True: 0, False: 0]
  ------------------
  383|      0|        LOG(WARNING) << "Found too long line (" << sentence.size() << " > "
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  384|      0|                     << trainer_spec_.max_sentence_length() << ").";
  385|      0|        LOG(WARNING) << "Too long lines are skipped in the training.";
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  386|      0|        LOG(WARNING) << "The maximum length can be changed with "
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  387|      0|                        "--max_sentence_length=<size> flag.";
  388|      0|      }
  389|      0|      ++too_long_lines;
  390|      0|      continue;
  391|      0|    }
  392|       |
  393|  65.7k|    if (sentence.find(kUNKStr) != std::string::npos) {
  ------------------
  |  Branch (393:9): [True: 242, False: 65.5k]
  ------------------
  394|    726|      LOG(INFO) << "Reserved chars are found. Skipped: " << sentence;
  ------------------
  |  |  218|    242|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|    242|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|    242|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|    484|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|    484|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 242, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|    242|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 242]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|    242|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 242]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|    242|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    726|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|    726|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  395|    242|      continue;
  396|    242|    }
  397|       |
  398|  65.5k|    test_sentence_sampler.Add(sentence);
  399|       |
  400|  65.5k|    if (!selector.Add(std::make_pair(sentence, freq))) {
  ------------------
  |  Branch (400:9): [True: 0, False: 65.5k]
  ------------------
  401|      0|      goto END;
  402|      0|    }
  403|  65.5k|  }
  404|       |
  405|  10.1k|  RETURN_IF_ERROR(sentence_iterator_->status());
  ------------------
  |  |   44|  10.1k|  do {                                 \
  |  |   45|  10.1k|    const auto _status = expr;         \
  |  |   46|  10.1k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 10.1k]
  |  |  ------------------
  |  |   47|  10.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 10.1k]
  |  |  ------------------
  ------------------
  406|       |
  407|  10.1k|END:
  408|       |  // Emits error message if any.
  409|  10.1k|  selector.Finish();
  410|       |
  411|  10.1k|  if (sentences_.size() == selector.total_size()) {
  ------------------
  |  Branch (411:7): [True: 10.1k, False: 0]
  ------------------
  412|  30.3k|    LOG(INFO) << "Loaded all " << sentences_.size() << " sentences";
  ------------------
  |  |  218|  10.1k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  10.1k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  10.1k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  20.2k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  20.2k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 10.1k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  10.1k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  10.1k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  10.1k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  40.5k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  40.5k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  413|  10.1k|  } else {
  414|      0|    LOG(INFO) << "Sampled " << sentences_.size() << " sentences from "
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  415|      0|              << selector.total_size() << " sentences.";
  416|      0|  }
  417|       |
  418|  10.1k|  if (too_long_lines > 0)
  ------------------
  |  Branch (418:7): [True: 0, False: 10.1k]
  ------------------
  419|      0|    LOG(INFO) << "Skipped " << too_long_lines << " too long sentences.";
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|      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|  10.1k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  10.1k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  10.1k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  420|  10.1k|  if (self_test_samples_.size() > 0)
  ------------------
  |  Branch (420:7): [True: 0, False: 10.1k]
  ------------------
  421|      0|    LOG(INFO) << "Loaded " << self_test_samples_.size() << " test sentences";
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|      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|  10.1k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  10.1k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  10.1k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  422|       |
  423|       |  // Normalize and removes empty string.
  424|  10.1k|  {
  425|  10.1k|    const normalizer::Normalizer normalizer(normalizer_spec_, trainer_spec_);
  426|  10.1k|    std::set<absl::string_view> meta_pieces_set;
  427|  52.3k|    for (const auto &it : meta_pieces_) {
  ------------------
  |  Branch (427:25): [True: 52.3k, False: 10.1k]
  ------------------
  428|   157k|      LOG(INFO) << "Adding meta_piece: " << it.second.first;
  ------------------
  |  |  218|  52.3k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  52.3k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  52.3k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|   104k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|   104k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 52.3k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  52.3k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 52.3k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  52.3k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 52.3k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  52.3k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|   157k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|   157k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  429|  52.3k|      meta_pieces_set.insert(it.second.first);
  430|  52.3k|    }
  431|  10.1k|    const normalizer::PrefixMatcher meta_pieces_matcher(meta_pieces_set);
  432|       |
  433|  30.3k|    LOG(INFO) << "Normalizing sentences...";
  ------------------
  |  |  218|  10.1k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  10.1k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  10.1k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  20.2k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  20.2k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 10.1k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  10.1k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  10.1k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  10.1k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  20.2k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  20.2k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  434|  10.1k|    RET_CHECK(!sentences_.empty());
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 16]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|     16|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|     16|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  435|  10.1k|    {
  436|  10.1k|      auto pool = std::make_unique<ThreadPool>(trainer_spec_.num_threads());
  437|  20.2k|      for (int n = 0; n < trainer_spec_.num_threads(); ++n) {
  ------------------
  |  Branch (437:23): [True: 10.1k, False: 10.1k]
  ------------------
  438|  10.1k|        pool->Schedule([&, n]() {
  439|  10.1k|          for (size_t i = n; i < sentences_.size();
  440|  10.1k|               i += trainer_spec_.num_threads()) {
  441|  10.1k|            auto *s = &sentences_[i].first;
  442|  10.1k|            *s = meta_pieces_matcher.GlobalReplace(normalizer.Normalize(*s),
  443|  10.1k|                                                   kUPPBoundaryStr);
  444|  10.1k|          }
  445|  10.1k|        });
  446|  10.1k|      }
  447|  10.1k|    }
  448|       |
  449|  74.9k|    for (size_t i = 0; i < sentences_.size(); ++i) {
  ------------------
  |  Branch (449:24): [True: 64.8k, False: 10.1k]
  ------------------
  450|  64.8k|      auto *s = &sentences_[i].first;
  451|  64.8k|      RET_CHECK(s->find(" ") == std::string::npos)
  ------------------
  |  |  321|  64.8k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 64.8k, False: 0]
  |  |  ------------------
  |  |  322|  64.8k|  } else /* NOLINT */                                        \
  |  |  323|  64.8k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  452|      0|          << "Normalized string must not include spaces";
  453|  64.8k|      if (s->empty()) {
  ------------------
  |  Branch (453:11): [True: 791, False: 64.0k]
  ------------------
  454|    791|        std::swap(sentences_[i], sentences_[sentences_.size() - 1]);
  455|    791|        sentences_.resize(sentences_.size() - 1);
  456|    791|      }
  457|  64.8k|    }
  458|  10.1k|  }
  459|       |
  460|       |  // If DP is required, add the noise/clip the input.
  461|  10.1k|  if (trainer_spec_.enable_differential_privacy()) {
  ------------------
  |  Branch (461:7): [True: 0, False: 10.1k]
  ------------------
  462|      0|    LOG(WARNING) << "Differential privacy feature will be deprecated in v0.2.3";
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  463|      0|    if (trainer_spec_.input_format() != "tsv") {
  ------------------
  |  Branch (463:9): [True: 0, False: 0]
  ------------------
  464|      0|      LOG(ERROR)
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  465|      0|          << "Dp version will not work correctly with text input format.";
  466|      0|    }
  467|      0|    if (trainer_spec_.differential_privacy_noise_level() <= 0) {
  ------------------
  |  Branch (467:9): [True: 0, False: 0]
  ------------------
  468|      0|      LOG(WARNING) << "Private version with <=0 noise level will give "
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  469|      0|                      "infinity epsilon guarantees.";
  470|      0|    }
  471|      0|    if (trainer_spec_.differential_privacy_clipping_threshold() <= 0) {
  ------------------
  |  Branch (471:9): [True: 0, False: 0]
  ------------------
  472|      0|      LOG(WARNING) << "Private version with <=0 clipping threshold will give "
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  473|      0|                      "infinity epsilon guarantees.";
  474|      0|    }
  475|       |
  476|       |    // Add noise to all the sentences via threadpool.
  477|       |
  478|       |    // This line is mainly for tests with small num of sentences.
  479|      0|    const auto num_workers =
  480|      0|        std::min<uint64_t>(trainer_spec_.num_threads(), sentences_.size() - 1);
  481|       |
  482|      0|    {
  483|      0|      auto pool = std::make_unique<ThreadPool>(num_workers);
  484|      0|      for (size_t n = 0; n < num_workers; ++n) {
  ------------------
  |  Branch (484:26): [True: 0, False: 0]
  ------------------
  485|      0|        pool->Schedule([&, n]() {
  486|       |          // One per thread generator.
  487|      0|          auto *generator = random::GetRandomGenerator();
  488|      0|          for (size_t i = n; i < sentences_.size(); i += num_workers) {
  489|      0|            AddDPNoise<int64_t>(trainer_spec_, generator,
  490|      0|                                &(sentences_[i].second));
  491|      0|          }
  492|      0|        });
  493|      0|      }
  494|      0|    }
  495|       |
  496|       |    // Remove zero freq elements.
  497|      0|    const auto before_size = sentences_.size();
  498|      0|    auto it = std::remove_if(sentences_.begin(), sentences_.end(),
  499|      0|                             [](const Sentence &s) { return s.second <= 0; });
  500|      0|    const auto new_size = std::distance(sentences_.begin(), it);
  501|      0|    const int num_erased = before_size - new_size;
  502|      0|    sentences_.erase(it, sentences_.end());
  503|       |
  504|      0|    LOG(INFO) << "DP noise resulted in " << 1.0 * num_erased / before_size
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  505|      0|              << " fraction of sentences removed.";
  506|      0|  }
  507|       |
  508|       |  // Count character frequencies.
  509|  10.1k|  int64_t all_chars_count = 0;
  510|       |  // A map from a character to {is_required_char, character count}.
  511|  10.1k|  absl::flat_hash_map<char32, std::pair<bool, int64_t>> chars_count;
  512|  10.1k|  for (const char32 c :
  ------------------
  |  Branch (512:23): [True: 0, False: 10.1k]
  ------------------
  513|  10.1k|       string_util::UTF8ToUnicodeText(trainer_spec_.required_chars())) {
  514|      0|    RET_CHECK(string_util::IsValidCodepoint(c));
  ------------------
  |  |  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 << "] "
  ------------------
  515|      0|    if (c == 0x0000) {
  ------------------
  |  Branch (515:9): [True: 0, False: 0]
  ------------------
  516|      0|      LOG(INFO) << "Found null character. The required_chars field must be "
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  517|      0|                   "encoded in utf-8.";
  518|      0|      continue;
  519|      0|    }
  520|      0|    chars_count[c].first = true;  // is_required_character.
  521|      0|  }
  522|  64.7k|  for (const auto &w : sentences_) {
  ------------------
  |  Branch (522:22): [True: 64.7k, False: 10.1k]
  ------------------
  523|  9.62M|    for (const char32 c : string_util::UTF8ToUnicodeText(w.first)) {
  ------------------
  |  Branch (523:25): [True: 9.62M, False: 64.7k]
  ------------------
  524|  9.62M|      if (!string_util::IsValidCodepoint(c)) continue;
  ------------------
  |  Branch (524:11): [True: 0, False: 9.62M]
  ------------------
  525|  9.62M|      if (c == 0x0000) {
  ------------------
  |  Branch (525:11): [True: 401k, False: 9.22M]
  ------------------
  526|  1.20M|        LOG(INFO)
  ------------------
  |  |  218|   401k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|   401k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|   401k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|   802k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|   802k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 401k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|   401k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 401k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|   401k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 401k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|   401k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|   802k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|   802k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  527|  1.20M|            << "Found null character. The corpus must be encoded in utf-8.";
  528|   401k|        continue;
  529|   401k|      }
  530|  9.22M|      if (c == 0x0020) {
  ------------------
  |  Branch (530:11): [True: 0, False: 9.22M]
  ------------------
  531|       |        // UTF8ToUnicodeText returns a white space if the text
  532|       |        // contains an interchange-invalid character.
  533|      0|        RET_CHECK(w.first.find(" ") == std::string::npos)
  ------------------
  |  |  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 << "] "
  ------------------
  534|      0|            << "space must not be included in normalized string.";
  535|      0|        continue;
  536|      0|      }
  537|  9.22M|      chars_count[c].second += w.second;
  538|  9.22M|      all_chars_count += w.second;
  539|  9.22M|    }
  540|  64.7k|  }
  541|  30.3k|  LOG(INFO) << "all chars count=" << all_chars_count;
  ------------------
  |  |  218|  10.1k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  10.1k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  10.1k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  20.2k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  20.2k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 10.1k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  10.1k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  10.1k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  10.1k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  30.3k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  30.3k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  542|       |
  543|       |  // Determines required_chars which must be included in the vocabulary.
  544|  10.1k|  int64_t accumulated_chars_count = 0;
  545|       |  // Sorted() sorts the chars_count values in the decsending order of pair<>.
  546|       |  // I.e. characters are sorted in the order of required characters and then
  547|       |  // frequent characters.
  548|   301k|  for (const auto &w : Sorted(chars_count)) {
  ------------------
  |  Branch (548:22): [True: 301k, False: 7.59k]
  ------------------
  549|   301k|    const float coverage = 1.0 * accumulated_chars_count / all_chars_count;
  550|   301k|    if (!trainer_spec_.use_all_vocab() &&
  ------------------
  |  Branch (550:9): [True: 301k, False: 0]
  ------------------
  551|   301k|        coverage >= trainer_spec_.character_coverage()) {
  ------------------
  |  Branch (551:9): [True: 2.51k, False: 298k]
  ------------------
  552|  7.54k|      LOG(INFO) << "Done: " << 100.0 * coverage << "% characters are covered.";
  ------------------
  |  |  218|  2.51k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  2.51k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  2.51k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  5.03k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  5.03k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2.51k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  2.51k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2.51k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  2.51k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 2.51k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  2.51k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  10.0k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  10.0k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  553|  2.51k|      break;
  554|  2.51k|    }
  555|   298k|    accumulated_chars_count += w.second.second;
  556|   298k|    RET_CHECK_NE(w.first, 0x0020)
  ------------------
  |  |  328|   298k|#define RET_CHECK_NE(a, b) RET_CHECK((a) != (b))
  |  |  ------------------
  |  |  |  |  321|   298k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 298k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|   298k|  } else /* NOLINT */                                        \
  |  |  |  |  323|   298k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  557|      0|        << "space must not be included in normalized string.";
  558|   298k|    if (w.first == kUPPBoundaryChar) continue;  // Tab is not included.
  ------------------
  |  Branch (558:9): [True: 266, False: 298k]
  ------------------
  559|   298k|    required_chars_.emplace(w.first, w.second.second);
  560|   298k|  }
  561|       |
  562|  30.3k|  LOG(INFO) << "Alphabet size=" << required_chars_.size();
  ------------------
  |  |  218|  10.1k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  10.1k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  10.1k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  20.2k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  20.2k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 10.1k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  10.1k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  10.1k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  10.1k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  30.3k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  30.3k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  563|  30.3k|  LOG(INFO) << "Final character coverage="
  ------------------
  |  |  218|  10.1k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  10.1k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  10.1k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  20.2k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  20.2k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 10.1k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  10.1k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  10.1k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 10.1k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  10.1k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  30.3k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  30.3k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  564|  30.3k|            << 1.0 * accumulated_chars_count / all_chars_count;
  565|       |
  566|  10.1k|  RET_CHECK(!port::ContainsKey(required_chars_, kUNKChar));
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  567|       |
  568|       |  // Replaces rare characters (characters not included in required_chars_)
  569|       |  // with kUNKChar.
  570|  64.7k|  for (auto &w : sentences_) {
  ------------------
  |  Branch (570:16): [True: 64.7k, False: 10.1k]
  ------------------
  571|  64.7k|    string_util::UnicodeText uw2;
  572|  9.62M|    for (const char32 c : string_util::UTF8ToUnicodeText(w.first)) {
  ------------------
  |  Branch (572:25): [True: 9.62M, False: 64.7k]
  ------------------
  573|  9.62M|      if (port::ContainsKey(required_chars_, c)) {
  ------------------
  |  Branch (573:11): [True: 9.16M, False: 460k]
  ------------------
  574|  9.16M|        uw2.push_back(c);
  575|  9.16M|      } else {
  576|   460k|        uw2.push_back(kUNKChar);
  577|   460k|      }
  578|  9.62M|    }
  579|  64.7k|    w.first = string_util::UnicodeTextToUTF8(uw2);
  580|  64.7k|  }
  581|       |
  582|  10.1k|  if (trainer_spec_.model_type() != TrainerSpec::WORD &&
  ------------------
  |  Branch (582:7): [True: 8.94k, False: 1.16k]
  ------------------
  583|  8.94k|      trainer_spec_.model_type() != TrainerSpec::CHAR) {
  ------------------
  |  Branch (583:7): [True: 8.70k, False: 242]
  ------------------
  584|  8.70k|    RET_CHECK_LE(static_cast<int>(required_chars_.size() + meta_pieces_.size()),
  ------------------
  |  |  330|  8.70k|#define RET_CHECK_LE(a, b) RET_CHECK((a) <= (b))
  |  |  ------------------
  |  |  |  |  321|  9.33k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 8.60k, False: 91]
  |  |  |  |  ------------------
  |  |  |  |  322|  8.60k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  9.33k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|     91|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|     91|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  585|     91|                 trainer_spec_.vocab_size())
  586|     91|        << "Vocabulary size is smaller than required_chars. "
  587|     91|        << trainer_spec_.vocab_size() << " vs "
  588|     91|        << required_chars_.size() + meta_pieces_.size() << ". "
  589|     91|        << "Increase vocab_size or decrease character_coverage with "
  590|     91|        << "--character_coverage option.";
  591|  8.70k|  }
  592|       |
  593|  30.0k|  LOG(INFO) << "Done! preprocessed " << sentences_.size() << " sentences.";
  ------------------
  |  |  218|  10.0k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  10.0k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  10.0k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  20.0k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  20.0k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 10.0k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  10.0k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 10.0k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  10.0k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 10.0k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  10.1k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  40.1k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  40.1k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  594|       |
  595|  10.0k|  return util::OkStatus();
  596|  10.0k|}
_ZN13sentencepiece16TrainerInterface26SplitSentencesByWhitespaceEv:
  598|  7.64k|void TrainerInterface::SplitSentencesByWhitespace() {
  599|  22.9k|  LOG(INFO) << "Tokenizing input sentences with whitespace: "
  ------------------
  |  |  218|  7.64k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  7.64k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  7.64k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  15.2k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  15.2k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 7.64k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  7.64k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 7.64k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  7.64k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 7.64k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  7.64k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  22.9k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  22.9k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  600|  22.9k|            << sentences_.size();
  601|  7.64k|  absl::flat_hash_map<std::string, int64_t> tokens;
  602|  47.6k|  for (const auto &s : sentences_) {
  ------------------
  |  Branch (602:22): [True: 47.6k, False: 7.64k]
  ------------------
  603|  47.6k|    for (const auto &w :
  ------------------
  |  Branch (603:24): [True: 275k, False: 47.6k]
  ------------------
  604|  47.6k|         SplitIntoWords(s.first, trainer_spec_.treat_whitespace_as_suffix(),
  605|   275k|                        trainer_spec_.allow_whitespace_only_pieces())) {
  606|   275k|      tokens[w] += s.second;
  607|   275k|    }
  608|  47.6k|  }
  609|  7.64k|  sentences_ = Sorted(tokens);
  610|  22.9k|  LOG(INFO) << "Done! " << sentences_.size();
  ------------------
  |  |  218|  7.64k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  7.64k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  7.64k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  15.2k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  15.2k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 7.64k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  7.64k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 7.64k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  7.64k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 7.64k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  7.64k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  22.9k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  22.9k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  611|  7.64k|}
_ZNK13sentencepiece16TrainerInterface9SerializeEPNS_10ModelProtoE:
  613|  9.97k|util::Status TrainerInterface::Serialize(ModelProto *model_proto) const {
  614|  9.97k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  9.97k|  do {                                 \
  |  |   45|  9.97k|    const auto _status = expr;         \
  |  |   46|  9.97k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 9.97k]
  |  |  ------------------
  |  |   47|  9.97k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 9.97k]
  |  |  ------------------
  ------------------
  615|       |
  616|       |  // Duplicated sentencepiece is not allowed.
  617|  9.97k|  std::set<std::string> dup;
  618|       |
  619|  9.97k|  model_proto->Clear();
  620|       |
  621|  9.97k|#define CHECK_PIECE(piece)                            \
  622|  9.97k|  RET_CHECK(string_util::IsStructurallyValid(piece)); \
  623|  9.97k|  RET_CHECK(!piece.empty());                          \
  624|  9.97k|  RET_CHECK(dup.insert(piece).second) << piece << " is already defined";
  625|       |
  626|  9.97k|  size_t fid = 0;
  627|   580k|  for (int id = 0; id < trainer_spec_.vocab_size(); ++id) {
  ------------------
  |  Branch (627:20): [True: 570k, False: 9.97k]
  ------------------
  628|   570k|    const auto it = meta_pieces_.find(id);
  629|   570k|    if (it != meta_pieces_.end()) {
  ------------------
  |  Branch (629:9): [True: 29.9k, False: 540k]
  ------------------
  630|  29.9k|      auto *sp = model_proto->add_pieces();
  631|  29.9k|      sp->set_piece(it->second.first);
  632|  29.9k|      sp->set_type(it->second.second);
  633|  29.9k|      sp->set_score(0.0);
  634|  29.9k|      RET_CHECK_EQ(model_proto->pieces_size() - 1, it->first);
  ------------------
  |  |  327|  29.9k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|  29.9k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 29.9k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  29.9k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  29.9k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  635|  29.9k|      RET_CHECK_NE(ModelProto::SentencePiece::NORMAL, sp->type());
  ------------------
  |  |  328|  29.9k|#define RET_CHECK_NE(a, b) RET_CHECK((a) != (b))
  |  |  ------------------
  |  |  |  |  321|  29.9k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 29.9k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  29.9k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  29.9k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  636|  89.7k|      CHECK_PIECE(sp->piece());
  ------------------
  |  |  622|  29.9k|  RET_CHECK(string_util::IsStructurallyValid(piece)); \
  |  |  ------------------
  |  |  |  |  321|  29.9k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 29.9k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  29.9k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  29.9k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  623|  29.9k|  RET_CHECK(!piece.empty());                          \
  |  |  ------------------
  |  |  |  |  321|  29.9k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 29.9k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  29.9k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  29.9k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  624|  29.9k|  RET_CHECK(dup.insert(piece).second) << piece << " is already defined";
  |  |  ------------------
  |  |  |  |  321|  29.9k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 29.9k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  29.9k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  29.9k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  637|   540k|    } else if (fid < final_pieces_.size()) {
  ------------------
  |  Branch (637:16): [True: 375k, False: 165k]
  ------------------
  638|   375k|      const auto &w = final_pieces_[fid++];
  639|   375k|      auto *sp = model_proto->add_pieces();
  640|   375k|      sp->set_piece(w.first);
  641|   375k|      sp->set_score(w.second);
  642|   751k|      CHECK_PIECE(sp->piece());
  ------------------
  |  |  622|   375k|  RET_CHECK(string_util::IsStructurallyValid(piece)); \
  |  |  ------------------
  |  |  |  |  321|   375k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 375k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|   375k|  } else /* NOLINT */                                        \
  |  |  |  |  323|   375k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  623|   375k|  RET_CHECK(!piece.empty());                          \
  |  |  ------------------
  |  |  |  |  321|   375k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 375k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|   375k|  } else /* NOLINT */                                        \
  |  |  |  |  323|   375k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  624|   375k|  RET_CHECK(dup.insert(piece).second) << piece << " is already defined";
  |  |  ------------------
  |  |  |  |  321|   375k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 375k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|   375k|  } else /* NOLINT */                                        \
  |  |  |  |  323|   375k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  643|   375k|    }
  644|   570k|  }
  645|       |
  646|  9.97k|  RET_CHECK_EQ(fid, final_pieces_.size());
  ------------------
  |  |  327|  9.97k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|  9.97k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 9.97k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  9.97k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  9.97k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  647|       |
  648|  9.97k|  *(model_proto->mutable_trainer_spec()) = trainer_spec_;
  649|  9.97k|  *(model_proto->mutable_normalizer_spec()) = normalizer_spec_;
  650|       |
  651|  9.97k|  if (!denormalizer_spec_.normalization_rule_tsv().empty()) {
  ------------------
  |  Branch (651:7): [True: 0, False: 9.97k]
  ------------------
  652|      0|    *(model_proto->mutable_denormalizer_spec()) = denormalizer_spec_;
  653|      0|  }
  654|       |
  655|  9.97k|  if (!trainer_spec_.hard_vocab_limit() ||
  ------------------
  |  Branch (655:7): [True: 0, False: 9.97k]
  ------------------
  656|  9.97k|      trainer_spec_.model_type() == TrainerSpec::CHAR) {
  ------------------
  |  Branch (656:7): [True: 230, False: 9.74k]
  ------------------
  657|    230|    RET_CHECK_GE(trainer_spec_.vocab_size(), model_proto->pieces_size());
  ------------------
  |  |  329|    230|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  321|    230|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 230, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|    230|  } else /* NOLINT */                                        \
  |  |  |  |  323|    230|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  658|    230|    RET_CHECK_GE(trainer_spec_.vocab_size(), static_cast<int32_t>(dup.size()));
  ------------------
  |  |  329|    230|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  321|    230|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 230, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|    230|  } else /* NOLINT */                                        \
  |  |  |  |  323|    230|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  659|    230|    model_proto->mutable_trainer_spec()->set_vocab_size(
  660|    230|        model_proto->pieces_size());
  661|  9.74k|  } else {
  662|  9.74k|    RET_CHECK_EQ(trainer_spec_.vocab_size(), model_proto->pieces_size())
  ------------------
  |  |  327|  9.74k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|  14.8k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 4.66k, False: 5.08k]
  |  |  |  |  ------------------
  |  |  |  |  322|  4.66k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  14.8k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|  5.08k|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|  5.08k|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  663|  5.08k|        << absl::StrFormat(
  664|  5.08k|               "Vocabulary size too high (%d). Please set it to a value <= %d.",
  665|  5.08k|               trainer_spec_.vocab_size(), model_proto->pieces_size());
  666|  4.66k|    RET_CHECK_EQ(trainer_spec_.vocab_size(), static_cast<int32_t>(dup.size()));
  ------------------
  |  |  327|  4.66k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|  4.66k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 4.66k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  4.66k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  4.66k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  667|  4.66k|  }
  668|       |
  669|       |  // Saves self-testing data.
  670|  4.89k|  if (!self_test_samples_.empty()) {
  ------------------
  |  Branch (670:7): [True: 0, False: 4.89k]
  ------------------
  671|      0|    SentencePieceProcessor sp;
  672|      0|    RETURN_IF_ERROR(sp.Load(*model_proto));
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  673|      0|    for (const auto &input : self_test_samples_) {
  ------------------
  |  Branch (673:28): [True: 0, False: 0]
  ------------------
  674|      0|      std::vector<std::string> sps;
  675|      0|      RETURN_IF_ERROR(sp.Encode(input, &sps));
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  676|      0|      auto *sample = model_proto->mutable_self_test_data()->add_samples();
  677|      0|      sample->set_input(input);
  678|      0|      sample->set_expected(absl::StrJoin(sps, " "));
  679|      0|    }
  680|      0|  }
  681|       |
  682|  4.89k|  return util::OkStatus();
  683|  4.89k|}
_ZNK13sentencepiece16TrainerInterface4SaveEv:
  727|  9.97k|util::Status TrainerInterface::Save() const {
  728|  9.97k|  if (output_model_proto_) {
  ------------------
  |  Branch (728:7): [True: 9.97k, False: 0]
  ------------------
  729|  9.97k|    RETURN_IF_ERROR(Serialize(output_model_proto_));
  ------------------
  |  |   44|  9.97k|  do {                                 \
  |  |   45|  9.97k|    const auto _status = expr;         \
  |  |   46|  9.97k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 5.08k, False: 4.89k]
  |  |  ------------------
  |  |   47|  9.97k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 4.89k]
  |  |  ------------------
  ------------------
  730|  9.97k|  } else {
  731|      0|    RETURN_IF_ERROR(SaveModel(trainer_spec_.model_prefix() + ".model"));
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  732|      0|    RETURN_IF_ERROR(SaveVocab(trainer_spec_.model_prefix() + ".vocab"));
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  733|      0|  }
  734|  4.89k|  return util::OkStatus();
  735|  9.97k|}
_ZN13sentencepiece16TrainerInterface14InitMetaPiecesEv:
  737|  10.1k|util::Status TrainerInterface::InitMetaPieces() {
  738|  10.1k|  RET_CHECK(meta_pieces_.empty());
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  739|  10.1k|  bool has_unk = false;
  740|       |
  741|  10.1k|  auto insert_id = [&has_unk, this](int id, const std::string &w) -> bool {
  742|  10.1k|    if (id < 0) return true;
  743|  10.1k|    if (id >= trainer_spec_.vocab_size() ||
  744|  10.1k|        meta_pieces_.find(id) != meta_pieces_.end() ||
  745|  10.1k|        (has_unk && w == trainer_spec_.unk_piece()))
  746|  10.1k|      return false;
  747|  10.1k|    if (w == trainer_spec_.unk_piece()) has_unk = true;
  748|  10.1k|    meta_pieces_[id] = std::make_pair(
  749|  10.1k|        w, w == trainer_spec_.unk_piece() ? ModelProto::SentencePiece::UNKNOWN
  750|  10.1k|                                          : ModelProto::SentencePiece::CONTROL);
  751|  10.1k|    return true;
  752|  10.1k|  };
  753|       |
  754|  10.1k|  RET_CHECK(insert_id(trainer_spec_.unk_id(), trainer_spec_.unk_piece()));
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  755|  10.1k|  RET_CHECK(insert_id(trainer_spec_.bos_id(), trainer_spec_.bos_piece()));
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  756|  10.1k|  RET_CHECK(insert_id(trainer_spec_.eos_id(), trainer_spec_.eos_piece()));
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  757|  10.1k|  RET_CHECK(insert_id(trainer_spec_.pad_id(), trainer_spec_.pad_piece()));
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  758|       |
  759|  10.1k|  RET_CHECK(has_unk) << trainer_spec_.unk_piece() << " must be defined.";
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  760|       |
  761|  10.1k|  std::set<std::string> dup;
  762|       |
  763|  10.1k|  int id = 0;
  764|  10.1k|  auto insert_meta_symbol =
  765|  10.1k|      [&id, &dup, this](const std::string &w,
  766|  10.1k|                        ModelProto::SentencePiece::Type type) -> util::Status {
  767|  10.1k|    if (!dup.insert(w).second) {
  768|  10.1k|      return util::InternalError(absl::StrCat(
  769|  10.1k|          w, " is already defined. duplicated symbols are not allowed."));
  770|  10.1k|    }
  771|       |
  772|  10.1k|    if (w == trainer_spec_.unk_piece()) {
  773|  10.1k|      return util::InternalError(
  774|  10.1k|          absl::StrCat(trainer_spec_.unk_piece(),
  775|  10.1k|                       " must not be defined with --control_symbols and "
  776|  10.1k|                       "--user_defined_symbols."));
  777|  10.1k|    }
  778|       |
  779|  10.1k|    if (w == trainer_spec_.bos_piece() && trainer_spec_.bos_id() >= 0) {
  780|  10.1k|      meta_pieces_[trainer_spec_.bos_id()].second = type;
  781|  10.1k|    } else if (w == trainer_spec_.eos_piece() && trainer_spec_.eos_id() >= 0) {
  782|  10.1k|      meta_pieces_[trainer_spec_.eos_id()].second = type;
  783|  10.1k|    } else if (w == trainer_spec_.pad_piece() && trainer_spec_.pad_id() >= 0) {
  784|  10.1k|      meta_pieces_[trainer_spec_.pad_id()].second = type;
  785|  10.1k|    } else {
  786|  10.1k|      while (meta_pieces_.find(id) != meta_pieces_.end()) ++id;
  787|  10.1k|      meta_pieces_[id] = std::make_pair(w, type);
  788|  10.1k|    }
  789|       |
  790|  10.1k|    return util::OkStatus();
  791|  10.1k|  };
  792|       |
  793|  10.1k|  for (const auto &w : trainer_spec_.control_symbols()) {
  ------------------
  |  Branch (793:22): [True: 0, False: 10.1k]
  ------------------
  794|      0|    RETURN_IF_ERROR(insert_meta_symbol(w, ModelProto::SentencePiece::CONTROL));
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  795|      0|  }
  796|       |
  797|  10.1k|  for (const auto &w : trainer_spec_.user_defined_symbols()) {
  ------------------
  |  Branch (797:22): [True: 0, False: 10.1k]
  ------------------
  798|      0|    RETURN_IF_ERROR(
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  799|      0|        insert_meta_symbol(w, ModelProto::SentencePiece::USER_DEFINED));
  800|      0|  }
  801|       |
  802|  10.1k|  if (trainer_spec_.byte_fallback()) {
  ------------------
  |  Branch (802:7): [True: 86, False: 10.0k]
  ------------------
  803|  22.1k|    for (int i = 0; i < 256; ++i) {
  ------------------
  |  Branch (803:21): [True: 22.0k, False: 86]
  ------------------
  804|  22.0k|      RETURN_IF_ERROR(
  ------------------
  |  |   44|  22.0k|  do {                                 \
  |  |   45|  22.0k|    const auto _status = expr;         \
  |  |   46|  22.0k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 22.0k]
  |  |  ------------------
  |  |   47|  22.0k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 22.0k]
  |  |  ------------------
  ------------------
  805|  22.0k|          insert_meta_symbol(ByteToPiece(i), ModelProto::SentencePiece::BYTE));
  806|  22.0k|    }
  807|     86|  }
  808|       |
  809|  10.1k|  return util::OkStatus();
  810|  10.1k|}
trainer_interface.cc:_ZN13sentencepiece12_GLOBAL__N_110VerifySpecERKNS_11TrainerSpecE:
   54|  10.1k|util::Status VerifySpec(const TrainerSpec &trainer_spec) {
   55|  10.1k|  RET_CHECK_GT(trainer_spec.vocab_size(), 0);
  ------------------
  |  |  331|  10.1k|#define RET_CHECK_GT(a, b) RET_CHECK((a) > (b))
  |  |  ------------------
  |  |  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   56|       |
   57|  10.1k|  if (trainer_spec.model_type() == TrainerSpec::UNIGRAM ||
  ------------------
  |  Branch (57:7): [True: 6.89k, False: 3.23k]
  ------------------
   58|  8.71k|      trainer_spec.model_type() == TrainerSpec::BPE) {
  ------------------
  |  Branch (58:7): [True: 1.81k, False: 1.41k]
  ------------------
   59|  8.71k|    RET_CHECK(!trainer_spec.use_all_vocab())
  ------------------
  |  |  321|  8.71k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 8.71k, False: 0]
  |  |  ------------------
  |  |  322|  8.71k|  } else /* NOLINT */                                        \
  |  |  323|  8.71k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   60|      0|        << "--use_all_vocab=true is valid for WORD/CHAR model.";
   61|  8.71k|  }
   62|       |
   63|  10.1k|  if (!trainer_spec.seed_sentencepieces_file().empty()) {
  ------------------
  |  Branch (63:7): [True: 0, False: 10.1k]
  ------------------
   64|      0|    RET_CHECK(trainer_spec.model_type() == TrainerSpec::UNIGRAM)
  ------------------
  |  |  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 << "] "
  ------------------
   65|      0|        << "seed_sentencepieces_file is only supported for UNIGRAM model.";
   66|      0|  }
   67|       |
   68|  10.1k|#define CHECK_RANGE(variable, minval, maxval) \
   69|  10.1k|  RET_CHECK(variable >= minval && variable <= maxval)
   70|       |
   71|  10.1k|  CHECK_RANGE(trainer_spec.character_coverage(), 0.98, 1.0);
  ------------------
  |  |   69|  10.1k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  321|  30.3k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   72|  10.1k|  CHECK_RANGE(trainer_spec.max_sentencepiece_length(), 1, 512);
  ------------------
  |  |   69|  10.1k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  321|  30.3k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   73|  10.1k|  CHECK_RANGE(trainer_spec.num_sub_iterations(), 1, 10);
  ------------------
  |  |   69|  10.1k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  321|  30.3k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   74|  10.1k|  CHECK_RANGE(trainer_spec.num_threads(), 1, 1024);
  ------------------
  |  |   69|  10.1k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  321|  30.3k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   75|  10.1k|  CHECK_RANGE(trainer_spec.self_test_sample_size(), 0, 1000);
  ------------------
  |  |   69|  10.1k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  321|  30.3k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   76|  10.1k|  CHECK_RANGE(trainer_spec.shrinking_factor(), 0.5, 0.95);
  ------------------
  |  |   69|  10.1k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  321|  30.3k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   77|  10.1k|  CHECK_RANGE(trainer_spec.max_sentence_length(), 10, 1073741824);
  ------------------
  |  |   69|  10.1k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  321|  30.3k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   78|  10.1k|#undef CHECK_RANGE
   79|       |
   80|  10.1k|  RET_CHECK(trainer_spec.input_sentence_size() <= 0 ||
  ------------------
  |  |  321|  22.3k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 8.08k, False: 2.04k]
  |  |  |  Branch (321:7): [True: 2.04k, False: 7]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      7|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      7|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   81|  10.1k|            trainer_spec.input_sentence_size() > 100);
   82|       |
   83|  10.1k|  RET_CHECK(!trainer_spec.unk_piece().empty());
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   84|  10.1k|  RET_CHECK(!trainer_spec.bos_piece().empty());
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   85|  10.1k|  RET_CHECK(!trainer_spec.eos_piece().empty());
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   86|  10.1k|  RET_CHECK(!trainer_spec.pad_piece().empty());
  ------------------
  |  |  321|  10.1k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 10.1k, False: 0]
  |  |  ------------------
  |  |  322|  10.1k|  } else /* NOLINT */                                        \
  |  |  323|  10.1k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   87|       |
   88|  10.1k|  if (SentencePieceTrainer::GetPretokenizerForTraining() ||
  ------------------
  |  Branch (88:7): [True: 0, False: 10.1k]
  ------------------
   89|  10.1k|      !trainer_spec.pretokenization_delimiter().empty()) {
  ------------------
  |  Branch (89:7): [True: 0, False: 10.1k]
  ------------------
   90|      0|    RET_CHECK(trainer_spec.model_type() == TrainerSpec::UNIGRAM ||
  ------------------
  |  |  321|      0|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 0, False: 0]
  |  |  |  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 << "] "
  ------------------
   91|      0|              trainer_spec.model_type() == TrainerSpec::BPE)
   92|      0|        << "PretokenizerForTraining is only supported in UNIGRAM or BPE mode.";
   93|      0|  }
   94|       |
   95|  10.1k|  return util::OkStatus();
   96|  10.1k|}
trainer_interface.cc:_ZN13sentencepiece12_GLOBAL__N_125is_unicode_decimal_numberEj:
   98|  2.60M|bool is_unicode_decimal_number(char32 c) {
   99|  2.60M|  return (c >= 0x30 && c <= 0x39) || (c >= 0xff10 && c <= 0xff19);
  ------------------
  |  Branch (99:11): [True: 2.51M, False: 83.5k]
  |  Branch (99:24): [True: 979k, False: 1.53M]
  |  Branch (99:39): [True: 862k, False: 760k]
  |  Branch (99:54): [True: 0, False: 862k]
  ------------------
  100|  2.60M|}
trainer_interface.cc:_ZN13sentencepiece12_GLOBAL__N_116SentenceSelectorC2EPNSt3__16vectorINS2_4pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEENS8_ISB_EEEERKNS_11TrainerSpecE:
  110|  10.1k|      : sentences_(sentences), spec_(&spec) {
  111|  10.1k|    if (spec_->input_sentence_size() > 0) {
  ------------------
  |  Branch (111:9): [True: 2.04k, False: 8.08k]
  ------------------
  112|  2.04k|      if (spec_->shuffle_input_sentence()) {
  ------------------
  |  Branch (112:11): [True: 1.46k, False: 580]
  ------------------
  113|  1.46k|        constexpr size_t kSeed = 12345678;
  114|  1.46k|        sampler_ = std::make_unique<Sampler>(
  115|  1.46k|            sentences, spec_->input_sentence_size(), kSeed);
  116|  1.46k|      } else {
  117|  1.74k|        LOG(INFO)
  ------------------
  |  |  218|    580|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|    580|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|    580|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  1.16k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  1.16k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 580, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|    580|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 580]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|    580|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 580]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|    580|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  2.32k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  2.32k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  118|  1.74k|            << "First " << spec_->input_sentence_size()
  119|  1.74k|            << " sentences are selected. Remaining sentences are discarded.";
  120|    580|      }
  121|  2.04k|    }
  122|  10.1k|  }
trainer_interface.cc:_ZN13sentencepiece12_GLOBAL__N_116SentenceSelector3AddERKNSt3__14pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEE:
  136|  65.5k|  bool Add(const std::pair<std::string, int64_t> &sentence) {
  137|  65.5k|    if (spec_->input_sentence_size() == 0) {
  ------------------
  |  Branch (137:9): [True: 46.6k, False: 18.8k]
  ------------------
  138|  46.6k|      sentences_->emplace_back(sentence);
  139|  46.6k|    } else {
  140|  18.8k|      if (spec_->shuffle_input_sentence()) {
  ------------------
  |  Branch (140:11): [True: 10.5k, False: 8.33k]
  ------------------
  141|  10.5k|        sampler_->Add(sentence);
  142|  10.5k|      } else {
  143|  8.33k|        sentences_->emplace_back(sentence);
  144|  8.33k|        if (sentences_->size() >= spec_->input_sentence_size()) return false;
  ------------------
  |  Branch (144:13): [True: 0, False: 8.33k]
  ------------------
  145|  8.33k|      }
  146|  18.8k|    }
  147|       |
  148|  65.5k|    if (total_size() > 0 && total_size() % kTooBigSentencesSize == 0) {
  ------------------
  |  Branch (148:9): [True: 65.5k, False: 0]
  |  Branch (148:29): [True: 0, False: 65.5k]
  ------------------
  149|      0|      LOG(INFO) << "Loaded " << total_size() << " lines";
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  150|      0|    }
  151|       |
  152|  65.5k|    return true;
  153|  65.5k|  }
trainer_interface.cc:_ZNK13sentencepiece12_GLOBAL__N_116SentenceSelector6FinishEv:
  124|  10.1k|  void Finish() const {
  125|  10.1k|    if (sentences_->size() > kTooBigSentencesSize) {
  ------------------
  |  Branch (125:9): [True: 0, False: 10.1k]
  ------------------
  126|      0|      LOG(WARNING) << "Too many sentences are loaded! (" << sentences_->size()
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  127|      0|                   << "), which may slow down training.";
  128|      0|      LOG(WARNING) << "Consider using "
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  129|      0|                      "--input_sentence_size=<size> and "
  130|      0|                      "--shuffle_input_sentence=true.";
  131|      0|      LOG(WARNING) << "They allow to randomly sample <size> sentences from "
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  132|      0|                      "the entire corpus.";
  133|      0|    }
  134|  10.1k|  }
trainer_interface.cc:_ZNK13sentencepiece12_GLOBAL__N_116SentenceSelector10total_sizeEv:
  155|   141k|  size_t total_size() const {
  156|   141k|    return sampler_.get() ? sampler_->total_size() : sentences_->size();
  ------------------
  |  Branch (156:12): [True: 22.4k, False: 118k]
  ------------------
  157|   141k|  }
trainer_interface.cc:_ZZN13sentencepiece16TrainerInterface14InitMetaPiecesEvENK3$_0clEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  741|  40.5k|  auto insert_id = [&has_unk, this](int id, const std::string &w) -> bool {
  742|  40.5k|    if (id < 0) return true;
  ------------------
  |  Branch (742:9): [True: 10.1k, False: 30.3k]
  ------------------
  743|  30.3k|    if (id >= trainer_spec_.vocab_size() ||
  ------------------
  |  Branch (743:9): [True: 0, False: 30.3k]
  |  Branch (743:9): [True: 0, False: 30.3k]
  ------------------
  744|  30.3k|        meta_pieces_.find(id) != meta_pieces_.end() ||
  ------------------
  |  Branch (744:9): [True: 0, False: 30.3k]
  ------------------
  745|  30.3k|        (has_unk && w == trainer_spec_.unk_piece()))
  ------------------
  |  Branch (745:10): [True: 20.2k, False: 10.1k]
  |  Branch (745:21): [True: 0, False: 20.2k]
  ------------------
  746|      0|      return false;
  747|  30.3k|    if (w == trainer_spec_.unk_piece()) has_unk = true;
  ------------------
  |  Branch (747:9): [True: 10.1k, False: 20.2k]
  ------------------
  748|  30.3k|    meta_pieces_[id] = std::make_pair(
  749|  30.3k|        w, w == trainer_spec_.unk_piece() ? ModelProto::SentencePiece::UNKNOWN
  ------------------
  |  Branch (749:12): [True: 10.1k, False: 20.2k]
  ------------------
  750|  30.3k|                                          : ModelProto::SentencePiece::CONTROL);
  751|  30.3k|    return true;
  752|  30.3k|  };
trainer_interface.cc:_ZZN13sentencepiece16TrainerInterface14InitMetaPiecesEvENK3$_1clERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_29ModelProto_SentencePiece_TypeE:
  766|  22.0k|                        ModelProto::SentencePiece::Type type) -> util::Status {
  767|  22.0k|    if (!dup.insert(w).second) {
  ------------------
  |  Branch (767:9): [True: 0, False: 22.0k]
  ------------------
  768|      0|      return util::InternalError(absl::StrCat(
  769|      0|          w, " is already defined. duplicated symbols are not allowed."));
  770|      0|    }
  771|       |
  772|  22.0k|    if (w == trainer_spec_.unk_piece()) {
  ------------------
  |  Branch (772:9): [True: 0, False: 22.0k]
  ------------------
  773|      0|      return util::InternalError(
  774|      0|          absl::StrCat(trainer_spec_.unk_piece(),
  775|      0|                       " must not be defined with --control_symbols and "
  776|      0|                       "--user_defined_symbols."));
  777|      0|    }
  778|       |
  779|  22.0k|    if (w == trainer_spec_.bos_piece() && trainer_spec_.bos_id() >= 0) {
  ------------------
  |  Branch (779:9): [True: 0, False: 22.0k]
  |  Branch (779:43): [True: 0, False: 0]
  ------------------
  780|      0|      meta_pieces_[trainer_spec_.bos_id()].second = type;
  781|  22.0k|    } else if (w == trainer_spec_.eos_piece() && trainer_spec_.eos_id() >= 0) {
  ------------------
  |  Branch (781:16): [True: 0, False: 22.0k]
  |  Branch (781:50): [True: 0, False: 0]
  ------------------
  782|      0|      meta_pieces_[trainer_spec_.eos_id()].second = type;
  783|  22.0k|    } else if (w == trainer_spec_.pad_piece() && trainer_spec_.pad_id() >= 0) {
  ------------------
  |  Branch (783:16): [True: 0, False: 22.0k]
  |  Branch (783:50): [True: 0, False: 0]
  ------------------
  784|      0|      meta_pieces_[trainer_spec_.pad_id()].second = type;
  785|  22.0k|    } else {
  786|  44.2k|      while (meta_pieces_.find(id) != meta_pieces_.end()) ++id;
  ------------------
  |  Branch (786:14): [True: 22.1k, False: 22.0k]
  ------------------
  787|  22.0k|      meta_pieces_[id] = std::make_pair(w, type);
  788|  22.0k|    }
  789|       |
  790|  22.0k|    return util::OkStatus();
  791|  22.0k|  };
trainer_interface.cc:_ZZNK13sentencepiece16TrainerInterface20IsValidSentencePieceERKNSt3__16vectorIjNS1_9allocatorIjEEEEENK3$_0clEj:
  230|  14.1M|                  [](char32 c) { return c == kWSChar; });
trainer_interface.cc:_ZZN13sentencepiece16TrainerInterface13LoadSentencesEvENK3$_0clEv:
  438|  10.1k|        pool->Schedule([&, n]() {
  439|  75.6k|          for (size_t i = n; i < sentences_.size();
  ------------------
  |  Branch (439:30): [True: 65.5k, False: 10.1k]
  ------------------
  440|  65.5k|               i += trainer_spec_.num_threads()) {
  441|  65.5k|            auto *s = &sentences_[i].first;
  442|  65.5k|            *s = meta_pieces_matcher.GlobalReplace(normalizer.Normalize(*s),
  443|  65.5k|                                                   kUPPBoundaryStr);
  444|  65.5k|          }
  445|  10.1k|        });

_ZN13sentencepiece16TrainerInterface5TrainEPNS_16SentenceIteratorEPNS_10ModelProtoE:
   94|  10.1k|                             ModelProto *output_model_proto) {
   95|  10.1k|    sentence_iterator_ = sentence_iterator;
   96|  10.1k|    output_model_proto_ = output_model_proto;
   97|  10.1k|    return Train();
   98|  10.1k|  }
_ZNK13sentencepiece16TrainerInterface6statusEv:
  102|  30.2k|  virtual util::Status status() const { return status_; }
_ZN13sentencepiece6SortedIjNSt3__14pairIblEEEENS1_6vectorINS2_IT_T0_EENS1_9allocatorIS7_EEEERKN4absl12lts_2026010713flat_hash_mapIS5_S6_NSC_18container_internal17FlatHashMapPolicyIS5_S6_E11DefaultHashENSG_9DefaultEqENSG_12DefaultAllocEEE:
   47|  10.1k|std::vector<std::pair<K, V>> Sorted(const absl::flat_hash_map<K, V> &m) {
   48|  10.1k|  std::vector<std::pair<K, V>> v(m.begin(), m.end());
   49|  10.1k|  return Sorted(v);
   50|  10.1k|}
_ZN13sentencepiece6SortedIjNSt3__14pairIblEEEENS1_6vectorINS2_IT_T0_EENS1_9allocatorIS7_EEEERKSA_:
   36|  10.1k|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>> &m) {
   37|  10.1k|  std::vector<std::pair<K, V>> v = m;
   38|  10.1k|  std::sort(v.begin(), v.end(),
   39|  10.1k|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|  10.1k|              return (p1.second > p2.second ||
   41|  10.1k|                      (p1.second == p2.second && p1.first < p2.first));
   42|  10.1k|            });
   43|  10.1k|  return v;
   44|  10.1k|}
_ZZN13sentencepiece6SortedIjNSt3__14pairIblEEEENS1_6vectorINS2_IT_T0_EENS1_9allocatorIS7_EEEERKSA_ENKUlRKNS2_IjS3_EESF_E_clESF_SF_:
   39|  2.19M|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|  2.19M|              return (p1.second > p2.second ||
  ------------------
  |  Branch (40:23): [True: 879k, False: 1.31M]
  ------------------
   41|  1.31M|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (41:24): [True: 981k, False: 330k]
  |  Branch (41:50): [True: 658k, False: 322k]
  ------------------
   42|  2.19M|            });
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEElEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKN4absl12lts_2026010713flat_hash_mapISA_SB_NSG_18container_internal17FlatHashMapPolicyISA_SB_E11DefaultHashENSK_9DefaultEqENSK_12DefaultAllocEEE:
   47|  14.4k|std::vector<std::pair<K, V>> Sorted(const absl::flat_hash_map<K, V> &m) {
   48|  14.4k|  std::vector<std::pair<K, V>> v(m.begin(), m.end());
   49|  14.4k|  return Sorted(v);
   50|  14.4k|}
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEElEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_:
   36|  14.4k|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>> &m) {
   37|  14.4k|  std::vector<std::pair<K, V>> v = m;
   38|  14.4k|  std::sort(v.begin(), v.end(),
   39|  14.4k|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|  14.4k|              return (p1.second > p2.second ||
   41|  14.4k|                      (p1.second == p2.second && p1.first < p2.first));
   42|  14.4k|            });
   43|  14.4k|  return v;
   44|  14.4k|}
_ZZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEElEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_ENKUlRKNS9_IS7_lEESJ_E_clESJ_SJ_:
   39|  2.61M|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|  2.61M|              return (p1.second > p2.second ||
  ------------------
  |  Branch (40:23): [True: 609k, False: 2.00M]
  ------------------
   41|  2.00M|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (41:24): [True: 1.78M, False: 218k]
  |  Branch (41:50): [True: 1.18M, False: 602k]
  ------------------
   42|  2.61M|            });
_ZN13sentencepiece6SortedIifEENSt3__16vectorINS1_4pairIT_T0_EENS1_9allocatorIS6_EEEERKS9_:
   36|  10.6k|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>> &m) {
   37|  10.6k|  std::vector<std::pair<K, V>> v = m;
   38|  10.6k|  std::sort(v.begin(), v.end(),
   39|  10.6k|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|  10.6k|              return (p1.second > p2.second ||
   41|  10.6k|                      (p1.second == p2.second && p1.first < p2.first));
   42|  10.6k|            });
   43|  10.6k|  return v;
   44|  10.6k|}
_ZZN13sentencepiece6SortedIifEENSt3__16vectorINS1_4pairIT_T0_EENS1_9allocatorIS6_EEEERKS9_ENKUlRKNS3_IifEESE_E_clESE_SE_:
   39|  13.2M|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|  13.2M|              return (p1.second > p2.second ||
  ------------------
  |  Branch (40:23): [True: 8.33M, False: 4.88M]
  ------------------
   41|  4.88M|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (41:24): [True: 514k, False: 4.36M]
  |  Branch (41:50): [True: 301k, False: 213k]
  ------------------
   42|  13.2M|            });
_ZN13sentencepiece6SortedIjlEENSt3__16vectorINS1_4pairIT_T0_EENS1_9allocatorIS6_EEEERKN4absl12lts_2026010713flat_hash_mapIS4_S5_NSB_18container_internal17FlatHashMapPolicyIS4_S5_E11DefaultHashENSF_9DefaultEqENSF_12DefaultAllocEEE:
   47|  8.82k|std::vector<std::pair<K, V>> Sorted(const absl::flat_hash_map<K, V> &m) {
   48|  8.82k|  std::vector<std::pair<K, V>> v(m.begin(), m.end());
   49|  8.82k|  return Sorted(v);
   50|  8.82k|}
_ZN13sentencepiece6SortedIjlEENSt3__16vectorINS1_4pairIT_T0_EENS1_9allocatorIS6_EEEERKS9_:
   36|  8.82k|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>> &m) {
   37|  8.82k|  std::vector<std::pair<K, V>> v = m;
   38|  8.82k|  std::sort(v.begin(), v.end(),
   39|  8.82k|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|  8.82k|              return (p1.second > p2.second ||
   41|  8.82k|                      (p1.second == p2.second && p1.first < p2.first));
   42|  8.82k|            });
   43|  8.82k|  return v;
   44|  8.82k|}
_ZZN13sentencepiece6SortedIjlEENSt3__16vectorINS1_4pairIT_T0_EENS1_9allocatorIS6_EEEERKS9_ENKUlRKNS3_IjlEESE_E_clESE_SE_:
   39|  1.58M|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|  1.58M|              return (p1.second > p2.second ||
  ------------------
  |  Branch (40:23): [True: 629k, False: 953k]
  ------------------
   41|   953k|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (41:24): [True: 725k, False: 228k]
  |  Branch (41:50): [True: 485k, False: 239k]
  ------------------
   42|  1.58M|            });
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEfEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_:
   36|  13.5k|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>> &m) {
   37|  13.5k|  std::vector<std::pair<K, V>> v = m;
   38|  13.5k|  std::sort(v.begin(), v.end(),
   39|  13.5k|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|  13.5k|              return (p1.second > p2.second ||
   41|  13.5k|                      (p1.second == p2.second && p1.first < p2.first));
   42|  13.5k|            });
   43|  13.5k|  return v;
   44|  13.5k|}
_ZZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEfEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_ENKUlRKNS9_IS7_fEESJ_E_clESJ_SJ_:
   39|  3.24M|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|  3.24M|              return (p1.second > p2.second ||
  ------------------
  |  Branch (40:23): [True: 1.94M, False: 1.30M]
  ------------------
   41|  1.30M|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (41:24): [True: 441k, False: 862k]
  |  Branch (41:50): [True: 279k, False: 162k]
  ------------------
   42|  3.24M|            });
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEfEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKN4absl12lts_2026010713flat_hash_mapISA_SB_NSG_18container_internal17FlatHashMapPolicyISA_SB_E11DefaultHashENSK_9DefaultEqENSK_12DefaultAllocEEE:
   47|  6.79k|std::vector<std::pair<K, V>> Sorted(const absl::flat_hash_map<K, V> &m) {
   48|  6.79k|  std::vector<std::pair<K, V>> v(m.begin(), m.end());
   49|  6.79k|  return Sorted(v);
   50|  6.79k|}
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKN4absl12lts_2026010713flat_hash_mapISA_SB_NSG_18container_internal17FlatHashMapPolicyISA_SB_E11DefaultHashENSK_9DefaultEqENSK_12DefaultAllocEEE:
   47|  1.14k|std::vector<std::pair<K, V>> Sorted(const absl::flat_hash_map<K, V> &m) {
   48|  1.14k|  std::vector<std::pair<K, V>> v(m.begin(), m.end());
   49|  1.14k|  return Sorted(v);
   50|  1.14k|}
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_:
   36|  1.14k|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>> &m) {
   37|  1.14k|  std::vector<std::pair<K, V>> v = m;
   38|  1.14k|  std::sort(v.begin(), v.end(),
   39|  1.14k|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|  1.14k|              return (p1.second > p2.second ||
   41|  1.14k|                      (p1.second == p2.second && p1.first < p2.first));
   42|  1.14k|            });
   43|  1.14k|  return v;
   44|  1.14k|}
_ZZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_ENKUlRKNS9_IS7_mEESJ_E_clESJ_SJ_:
   39|   912k|            [](const std::pair<K, V> &p1, const std::pair<K, V> &p2) {
   40|   912k|              return (p1.second > p2.second ||
  ------------------
  |  Branch (40:23): [True: 71.1k, False: 841k]
  ------------------
   41|   841k|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (41:24): [True: 818k, False: 23.6k]
  |  Branch (41:50): [True: 524k, False: 293k]
  ------------------
   42|   912k|            });

_ZN13sentencepiece14unicode_script9GetScriptEj:
   37|  32.6M|ScriptType GetScript(char32 c) {
   38|  32.6M|  static GetScriptInternal sc;
   39|  32.6M|  return sc.GetScript(c);
   40|  32.6M|}
unicode_script.cc:_ZN13sentencepiece14unicode_script12_GLOBAL__N_117GetScriptInternalC2Ev:
   26|      1|  GetScriptInternal() { InitTable(&smap_); }
unicode_script.cc:_ZNK13sentencepiece14unicode_script12_GLOBAL__N_117GetScriptInternal9GetScriptEj:
   28|  32.6M|  ScriptType GetScript(char32 c) const {
   29|  32.6M|    return port::FindWithDefault(smap_, c, ScriptType::U_Common);
   30|  32.6M|  }

unicode_script.cc:_ZN13sentencepiece14unicode_script12_GLOBAL__N_19InitTableEPN4absl12lts_2026010713flat_hash_mapIjNS0_10ScriptTypeENS3_13hash_internal4HashIjEENSt3__18equal_toIjEENS9_9allocatorINS9_4pairIKjS5_EEEEEE:
   21|      1|void InitTable(absl::flat_hash_map<char32, ScriptType> *smap) {
   22|     33|  for (char32 c = 0x0000; c <= 0x001F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (22:27): [True: 32, False: 1]
  ------------------
   23|      1|  (*smap)[0x0020] = U_Common;
   24|      4|  for (char32 c = 0x0021; c <= 0x0023; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (24:27): [True: 3, False: 1]
  ------------------
   25|      1|  (*smap)[0x0024] = U_Common;
   26|      4|  for (char32 c = 0x0025; c <= 0x0027; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (26:27): [True: 3, False: 1]
  ------------------
   27|      1|  (*smap)[0x0028] = U_Common;
   28|      1|  (*smap)[0x0029] = U_Common;
   29|      1|  (*smap)[0x002A] = U_Common;
   30|      1|  (*smap)[0x002B] = U_Common;
   31|      1|  (*smap)[0x002C] = U_Common;
   32|      1|  (*smap)[0x002D] = U_Common;
   33|      3|  for (char32 c = 0x002E; c <= 0x002F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (33:27): [True: 2, False: 1]
  ------------------
   34|     11|  for (char32 c = 0x0030; c <= 0x0039; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (34:27): [True: 10, False: 1]
  ------------------
   35|      3|  for (char32 c = 0x003A; c <= 0x003B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (35:27): [True: 2, False: 1]
  ------------------
   36|      4|  for (char32 c = 0x003C; c <= 0x003E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (36:27): [True: 3, False: 1]
  ------------------
   37|      3|  for (char32 c = 0x003F; c <= 0x0040; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (37:27): [True: 2, False: 1]
  ------------------
   38|      1|  (*smap)[0x005B] = U_Common;
   39|      1|  (*smap)[0x005C] = U_Common;
   40|      1|  (*smap)[0x005D] = U_Common;
   41|      1|  (*smap)[0x005E] = U_Common;
   42|      1|  (*smap)[0x005F] = U_Common;
   43|      1|  (*smap)[0x0060] = U_Common;
   44|      1|  (*smap)[0x007B] = U_Common;
   45|      1|  (*smap)[0x007C] = U_Common;
   46|      1|  (*smap)[0x007D] = U_Common;
   47|      1|  (*smap)[0x007E] = U_Common;
   48|     34|  for (char32 c = 0x007F; c <= 0x009F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (48:27): [True: 33, False: 1]
  ------------------
   49|      1|  (*smap)[0x00A0] = U_Common;
   50|      1|  (*smap)[0x00A1] = U_Common;
   51|      5|  for (char32 c = 0x00A2; c <= 0x00A5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (51:27): [True: 4, False: 1]
  ------------------
   52|      1|  (*smap)[0x00A6] = U_Common;
   53|      1|  (*smap)[0x00A7] = U_Common;
   54|      1|  (*smap)[0x00A8] = U_Common;
   55|      1|  (*smap)[0x00A9] = U_Common;
   56|      1|  (*smap)[0x00AB] = U_Common;
   57|      1|  (*smap)[0x00AC] = U_Common;
   58|      1|  (*smap)[0x00AD] = U_Common;
   59|      1|  (*smap)[0x00AE] = U_Common;
   60|      1|  (*smap)[0x00AF] = U_Common;
   61|      1|  (*smap)[0x00B0] = U_Common;
   62|      1|  (*smap)[0x00B1] = U_Common;
   63|      3|  for (char32 c = 0x00B2; c <= 0x00B3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (63:27): [True: 2, False: 1]
  ------------------
   64|      1|  (*smap)[0x00B4] = U_Common;
   65|      1|  (*smap)[0x00B5] = U_Common;
   66|      3|  for (char32 c = 0x00B6; c <= 0x00B7; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (66:27): [True: 2, False: 1]
  ------------------
   67|      1|  (*smap)[0x00B8] = U_Common;
   68|      1|  (*smap)[0x00B9] = U_Common;
   69|      1|  (*smap)[0x00BB] = U_Common;
   70|      4|  for (char32 c = 0x00BC; c <= 0x00BE; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (70:27): [True: 3, False: 1]
  ------------------
   71|      1|  (*smap)[0x00BF] = U_Common;
   72|      1|  (*smap)[0x00D7] = U_Common;
   73|      1|  (*smap)[0x00F7] = U_Common;
   74|     10|  for (char32 c = 0x02B9; c <= 0x02C1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (74:27): [True: 9, False: 1]
  ------------------
   75|      5|  for (char32 c = 0x02C2; c <= 0x02C5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (75:27): [True: 4, False: 1]
  ------------------
   76|     13|  for (char32 c = 0x02C6; c <= 0x02D1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (76:27): [True: 12, False: 1]
  ------------------
   77|     15|  for (char32 c = 0x02D2; c <= 0x02DF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (77:27): [True: 14, False: 1]
  ------------------
   78|      6|  for (char32 c = 0x02E5; c <= 0x02E9; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (78:27): [True: 5, False: 1]
  ------------------
   79|      1|  (*smap)[0x02EC] = U_Common;
   80|      1|  (*smap)[0x02ED] = U_Common;
   81|      1|  (*smap)[0x02EE] = U_Common;
   82|     18|  for (char32 c = 0x02EF; c <= 0x02FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (82:27): [True: 17, False: 1]
  ------------------
   83|      1|  (*smap)[0x0374] = U_Common;
   84|      1|  (*smap)[0x037E] = U_Common;
   85|      1|  (*smap)[0x0385] = U_Common;
   86|      1|  (*smap)[0x0387] = U_Common;
   87|      1|  (*smap)[0x0589] = U_Common;
   88|      1|  (*smap)[0x0605] = U_Common;
   89|      1|  (*smap)[0x060C] = U_Common;
   90|      1|  (*smap)[0x061B] = U_Common;
   91|      1|  (*smap)[0x061C] = U_Common;
   92|      1|  (*smap)[0x061F] = U_Common;
   93|      1|  (*smap)[0x0640] = U_Common;
   94|      1|  (*smap)[0x06DD] = U_Common;
   95|      1|  (*smap)[0x08E2] = U_Common;
   96|      3|  for (char32 c = 0x0964; c <= 0x0965; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (96:27): [True: 2, False: 1]
  ------------------
   97|      1|  (*smap)[0x0E3F] = U_Common;
   98|      5|  for (char32 c = 0x0FD5; c <= 0x0FD8; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (98:27): [True: 4, False: 1]
  ------------------
   99|      1|  (*smap)[0x10FB] = U_Common;
  100|      4|  for (char32 c = 0x16EB; c <= 0x16ED; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (100:27): [True: 3, False: 1]
  ------------------
  101|      3|  for (char32 c = 0x1735; c <= 0x1736; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (101:27): [True: 2, False: 1]
  ------------------
  102|      3|  for (char32 c = 0x1802; c <= 0x1803; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (102:27): [True: 2, False: 1]
  ------------------
  103|      1|  (*smap)[0x1805] = U_Common;
  104|      1|  (*smap)[0x1CD3] = U_Common;
  105|      1|  (*smap)[0x1CE1] = U_Common;
  106|      5|  for (char32 c = 0x1CE9; c <= 0x1CEC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (106:27): [True: 4, False: 1]
  ------------------
  107|      5|  for (char32 c = 0x1CEE; c <= 0x1CF1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (107:27): [True: 4, False: 1]
  ------------------
  108|      3|  for (char32 c = 0x1CF2; c <= 0x1CF3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (108:27): [True: 2, False: 1]
  ------------------
  109|      3|  for (char32 c = 0x1CF5; c <= 0x1CF6; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (109:27): [True: 2, False: 1]
  ------------------
  110|     12|  for (char32 c = 0x2000; c <= 0x200A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (110:27): [True: 11, False: 1]
  ------------------
  111|      1|  (*smap)[0x200B] = U_Common;
  112|      3|  for (char32 c = 0x200E; c <= 0x200F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (112:27): [True: 2, False: 1]
  ------------------
  113|      7|  for (char32 c = 0x2010; c <= 0x2015; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (113:27): [True: 6, False: 1]
  ------------------
  114|      3|  for (char32 c = 0x2016; c <= 0x2017; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (114:27): [True: 2, False: 1]
  ------------------
  115|      1|  (*smap)[0x2018] = U_Common;
  116|      1|  (*smap)[0x2019] = U_Common;
  117|      1|  (*smap)[0x201A] = U_Common;
  118|      3|  for (char32 c = 0x201B; c <= 0x201C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (118:27): [True: 2, False: 1]
  ------------------
  119|      1|  (*smap)[0x201D] = U_Common;
  120|      1|  (*smap)[0x201E] = U_Common;
  121|      1|  (*smap)[0x201F] = U_Common;
  122|      9|  for (char32 c = 0x2020; c <= 0x2027; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (122:27): [True: 8, False: 1]
  ------------------
  123|      1|  (*smap)[0x2028] = U_Common;
  124|      1|  (*smap)[0x2029] = U_Common;
  125|      6|  for (char32 c = 0x202A; c <= 0x202E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (125:27): [True: 5, False: 1]
  ------------------
  126|      1|  (*smap)[0x202F] = U_Common;
  127|     10|  for (char32 c = 0x2030; c <= 0x2038; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (127:27): [True: 9, False: 1]
  ------------------
  128|      1|  (*smap)[0x2039] = U_Common;
  129|      1|  (*smap)[0x203A] = U_Common;
  130|      5|  for (char32 c = 0x203B; c <= 0x203E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (130:27): [True: 4, False: 1]
  ------------------
  131|      3|  for (char32 c = 0x203F; c <= 0x2040; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (131:27): [True: 2, False: 1]
  ------------------
  132|      4|  for (char32 c = 0x2041; c <= 0x2043; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (132:27): [True: 3, False: 1]
  ------------------
  133|      1|  (*smap)[0x2044] = U_Common;
  134|      1|  (*smap)[0x2045] = U_Common;
  135|      1|  (*smap)[0x2046] = U_Common;
  136|     12|  for (char32 c = 0x2047; c <= 0x2051; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (136:27): [True: 11, False: 1]
  ------------------
  137|      1|  (*smap)[0x2052] = U_Common;
  138|      1|  (*smap)[0x2053] = U_Common;
  139|      1|  (*smap)[0x2054] = U_Common;
  140|     11|  for (char32 c = 0x2055; c <= 0x205E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (140:27): [True: 10, False: 1]
  ------------------
  141|      1|  (*smap)[0x205F] = U_Common;
  142|      6|  for (char32 c = 0x2060; c <= 0x2064; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (142:27): [True: 5, False: 1]
  ------------------
  143|     11|  for (char32 c = 0x2066; c <= 0x206F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (143:27): [True: 10, False: 1]
  ------------------
  144|      1|  (*smap)[0x2070] = U_Common;
  145|      7|  for (char32 c = 0x2074; c <= 0x2079; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (145:27): [True: 6, False: 1]
  ------------------
  146|      4|  for (char32 c = 0x207A; c <= 0x207C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (146:27): [True: 3, False: 1]
  ------------------
  147|      1|  (*smap)[0x207D] = U_Common;
  148|      1|  (*smap)[0x207E] = U_Common;
  149|     11|  for (char32 c = 0x2080; c <= 0x2089; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (149:27): [True: 10, False: 1]
  ------------------
  150|      4|  for (char32 c = 0x208A; c <= 0x208C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (150:27): [True: 3, False: 1]
  ------------------
  151|      1|  (*smap)[0x208D] = U_Common;
  152|      1|  (*smap)[0x208E] = U_Common;
  153|     32|  for (char32 c = 0x20A0; c <= 0x20BE; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (153:27): [True: 31, False: 1]
  ------------------
  154|      3|  for (char32 c = 0x2100; c <= 0x2101; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (154:27): [True: 2, False: 1]
  ------------------
  155|      1|  (*smap)[0x2102] = U_Common;
  156|      5|  for (char32 c = 0x2103; c <= 0x2106; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (156:27): [True: 4, False: 1]
  ------------------
  157|      1|  (*smap)[0x2107] = U_Common;
  158|      3|  for (char32 c = 0x2108; c <= 0x2109; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (158:27): [True: 2, False: 1]
  ------------------
  159|     11|  for (char32 c = 0x210A; c <= 0x2113; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (159:27): [True: 10, False: 1]
  ------------------
  160|      1|  (*smap)[0x2114] = U_Common;
  161|      1|  (*smap)[0x2115] = U_Common;
  162|      3|  for (char32 c = 0x2116; c <= 0x2117; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (162:27): [True: 2, False: 1]
  ------------------
  163|      1|  (*smap)[0x2118] = U_Common;
  164|      6|  for (char32 c = 0x2119; c <= 0x211D; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (164:27): [True: 5, False: 1]
  ------------------
  165|      7|  for (char32 c = 0x211E; c <= 0x2123; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (165:27): [True: 6, False: 1]
  ------------------
  166|      1|  (*smap)[0x2124] = U_Common;
  167|      1|  (*smap)[0x2125] = U_Common;
  168|      1|  (*smap)[0x2127] = U_Common;
  169|      1|  (*smap)[0x2128] = U_Common;
  170|      1|  (*smap)[0x2129] = U_Common;
  171|      3|  for (char32 c = 0x212C; c <= 0x212D; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (171:27): [True: 2, False: 1]
  ------------------
  172|      1|  (*smap)[0x212E] = U_Common;
  173|      4|  for (char32 c = 0x212F; c <= 0x2131; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (173:27): [True: 3, False: 1]
  ------------------
  174|      3|  for (char32 c = 0x2133; c <= 0x2134; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (174:27): [True: 2, False: 1]
  ------------------
  175|      5|  for (char32 c = 0x2135; c <= 0x2138; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (175:27): [True: 4, False: 1]
  ------------------
  176|      1|  (*smap)[0x2139] = U_Common;
  177|      3|  for (char32 c = 0x213A; c <= 0x213B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (177:27): [True: 2, False: 1]
  ------------------
  178|      5|  for (char32 c = 0x213C; c <= 0x213F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (178:27): [True: 4, False: 1]
  ------------------
  179|      6|  for (char32 c = 0x2140; c <= 0x2144; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (179:27): [True: 5, False: 1]
  ------------------
  180|      6|  for (char32 c = 0x2145; c <= 0x2149; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (180:27): [True: 5, False: 1]
  ------------------
  181|      1|  (*smap)[0x214A] = U_Common;
  182|      1|  (*smap)[0x214B] = U_Common;
  183|      3|  for (char32 c = 0x214C; c <= 0x214D; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (183:27): [True: 2, False: 1]
  ------------------
  184|      1|  (*smap)[0x214F] = U_Common;
  185|     17|  for (char32 c = 0x2150; c <= 0x215F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (185:27): [True: 16, False: 1]
  ------------------
  186|      1|  (*smap)[0x2189] = U_Common;
  187|      3|  for (char32 c = 0x218A; c <= 0x218B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (187:27): [True: 2, False: 1]
  ------------------
  188|      6|  for (char32 c = 0x2190; c <= 0x2194; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (188:27): [True: 5, False: 1]
  ------------------
  189|      6|  for (char32 c = 0x2195; c <= 0x2199; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (189:27): [True: 5, False: 1]
  ------------------
  190|      3|  for (char32 c = 0x219A; c <= 0x219B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (190:27): [True: 2, False: 1]
  ------------------
  191|      5|  for (char32 c = 0x219C; c <= 0x219F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (191:27): [True: 4, False: 1]
  ------------------
  192|      1|  (*smap)[0x21A0] = U_Common;
  193|      3|  for (char32 c = 0x21A1; c <= 0x21A2; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (193:27): [True: 2, False: 1]
  ------------------
  194|      1|  (*smap)[0x21A3] = U_Common;
  195|      3|  for (char32 c = 0x21A4; c <= 0x21A5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (195:27): [True: 2, False: 1]
  ------------------
  196|      1|  (*smap)[0x21A6] = U_Common;
  197|      8|  for (char32 c = 0x21A7; c <= 0x21AD; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (197:27): [True: 7, False: 1]
  ------------------
  198|      1|  (*smap)[0x21AE] = U_Common;
  199|     32|  for (char32 c = 0x21AF; c <= 0x21CD; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (199:27): [True: 31, False: 1]
  ------------------
  200|      3|  for (char32 c = 0x21CE; c <= 0x21CF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (200:27): [True: 2, False: 1]
  ------------------
  201|      3|  for (char32 c = 0x21D0; c <= 0x21D1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (201:27): [True: 2, False: 1]
  ------------------
  202|      1|  (*smap)[0x21D2] = U_Common;
  203|      1|  (*smap)[0x21D3] = U_Common;
  204|      1|  (*smap)[0x21D4] = U_Common;
  205|     32|  for (char32 c = 0x21D5; c <= 0x21F3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (205:27): [True: 31, False: 1]
  ------------------
  206|    269|  for (char32 c = 0x21F4; c <= 0x22FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (206:27): [True: 268, False: 1]
  ------------------
  207|      9|  for (char32 c = 0x2300; c <= 0x2307; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (207:27): [True: 8, False: 1]
  ------------------
  208|      1|  (*smap)[0x2308] = U_Common;
  209|      1|  (*smap)[0x2309] = U_Common;
  210|      1|  (*smap)[0x230A] = U_Common;
  211|      1|  (*smap)[0x230B] = U_Common;
  212|     21|  for (char32 c = 0x230C; c <= 0x231F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (212:27): [True: 20, False: 1]
  ------------------
  213|      3|  for (char32 c = 0x2320; c <= 0x2321; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (213:27): [True: 2, False: 1]
  ------------------
  214|      8|  for (char32 c = 0x2322; c <= 0x2328; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (214:27): [True: 7, False: 1]
  ------------------
  215|      1|  (*smap)[0x2329] = U_Common;
  216|      1|  (*smap)[0x232A] = U_Common;
  217|     82|  for (char32 c = 0x232B; c <= 0x237B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (217:27): [True: 81, False: 1]
  ------------------
  218|      1|  (*smap)[0x237C] = U_Common;
  219|     31|  for (char32 c = 0x237D; c <= 0x239A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (219:27): [True: 30, False: 1]
  ------------------
  220|     26|  for (char32 c = 0x239B; c <= 0x23B3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (220:27): [True: 25, False: 1]
  ------------------
  221|     41|  for (char32 c = 0x23B4; c <= 0x23DB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (221:27): [True: 40, False: 1]
  ------------------
  222|      7|  for (char32 c = 0x23DC; c <= 0x23E1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (222:27): [True: 6, False: 1]
  ------------------
  223|     30|  for (char32 c = 0x23E2; c <= 0x23FE; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (223:27): [True: 29, False: 1]
  ------------------
  224|     40|  for (char32 c = 0x2400; c <= 0x2426; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (224:27): [True: 39, False: 1]
  ------------------
  225|     12|  for (char32 c = 0x2440; c <= 0x244A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (225:27): [True: 11, False: 1]
  ------------------
  226|     61|  for (char32 c = 0x2460; c <= 0x249B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (226:27): [True: 60, False: 1]
  ------------------
  227|     79|  for (char32 c = 0x249C; c <= 0x24E9; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (227:27): [True: 78, False: 1]
  ------------------
  228|     23|  for (char32 c = 0x24EA; c <= 0x24FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (228:27): [True: 22, False: 1]
  ------------------
  229|    184|  for (char32 c = 0x2500; c <= 0x25B6; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (229:27): [True: 183, False: 1]
  ------------------
  230|      1|  (*smap)[0x25B7] = U_Common;
  231|     10|  for (char32 c = 0x25B8; c <= 0x25C0; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (231:27): [True: 9, False: 1]
  ------------------
  232|      1|  (*smap)[0x25C1] = U_Common;
  233|     55|  for (char32 c = 0x25C2; c <= 0x25F7; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (233:27): [True: 54, False: 1]
  ------------------
  234|      9|  for (char32 c = 0x25F8; c <= 0x25FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (234:27): [True: 8, False: 1]
  ------------------
  235|    112|  for (char32 c = 0x2600; c <= 0x266E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (235:27): [True: 111, False: 1]
  ------------------
  236|      1|  (*smap)[0x266F] = U_Common;
  237|    249|  for (char32 c = 0x2670; c <= 0x2767; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (237:27): [True: 248, False: 1]
  ------------------
  238|      1|  (*smap)[0x2768] = U_Common;
  239|      1|  (*smap)[0x2769] = U_Common;
  240|      1|  (*smap)[0x276A] = U_Common;
  241|      1|  (*smap)[0x276B] = U_Common;
  242|      1|  (*smap)[0x276C] = U_Common;
  243|      1|  (*smap)[0x276D] = U_Common;
  244|      1|  (*smap)[0x276E] = U_Common;
  245|      1|  (*smap)[0x276F] = U_Common;
  246|      1|  (*smap)[0x2770] = U_Common;
  247|      1|  (*smap)[0x2771] = U_Common;
  248|      1|  (*smap)[0x2772] = U_Common;
  249|      1|  (*smap)[0x2773] = U_Common;
  250|      1|  (*smap)[0x2774] = U_Common;
  251|      1|  (*smap)[0x2775] = U_Common;
  252|     31|  for (char32 c = 0x2776; c <= 0x2793; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (252:27): [True: 30, False: 1]
  ------------------
  253|     45|  for (char32 c = 0x2794; c <= 0x27BF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (253:27): [True: 44, False: 1]
  ------------------
  254|      6|  for (char32 c = 0x27C0; c <= 0x27C4; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (254:27): [True: 5, False: 1]
  ------------------
  255|      1|  (*smap)[0x27C5] = U_Common;
  256|      1|  (*smap)[0x27C6] = U_Common;
  257|     32|  for (char32 c = 0x27C7; c <= 0x27E5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (257:27): [True: 31, False: 1]
  ------------------
  258|      1|  (*smap)[0x27E6] = U_Common;
  259|      1|  (*smap)[0x27E7] = U_Common;
  260|      1|  (*smap)[0x27E8] = U_Common;
  261|      1|  (*smap)[0x27E9] = U_Common;
  262|      1|  (*smap)[0x27EA] = U_Common;
  263|      1|  (*smap)[0x27EB] = U_Common;
  264|      1|  (*smap)[0x27EC] = U_Common;
  265|      1|  (*smap)[0x27ED] = U_Common;
  266|      1|  (*smap)[0x27EE] = U_Common;
  267|      1|  (*smap)[0x27EF] = U_Common;
  268|     17|  for (char32 c = 0x27F0; c <= 0x27FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (268:27): [True: 16, False: 1]
  ------------------
  269|    132|  for (char32 c = 0x2900; c <= 0x2982; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (269:27): [True: 131, False: 1]
  ------------------
  270|      1|  (*smap)[0x2983] = U_Common;
  271|      1|  (*smap)[0x2984] = U_Common;
  272|      1|  (*smap)[0x2985] = U_Common;
  273|      1|  (*smap)[0x2986] = U_Common;
  274|      1|  (*smap)[0x2987] = U_Common;
  275|      1|  (*smap)[0x2988] = U_Common;
  276|      1|  (*smap)[0x2989] = U_Common;
  277|      1|  (*smap)[0x298A] = U_Common;
  278|      1|  (*smap)[0x298B] = U_Common;
  279|      1|  (*smap)[0x298C] = U_Common;
  280|      1|  (*smap)[0x298D] = U_Common;
  281|      1|  (*smap)[0x298E] = U_Common;
  282|      1|  (*smap)[0x298F] = U_Common;
  283|      1|  (*smap)[0x2990] = U_Common;
  284|      1|  (*smap)[0x2991] = U_Common;
  285|      1|  (*smap)[0x2992] = U_Common;
  286|      1|  (*smap)[0x2993] = U_Common;
  287|      1|  (*smap)[0x2994] = U_Common;
  288|      1|  (*smap)[0x2995] = U_Common;
  289|      1|  (*smap)[0x2996] = U_Common;
  290|      1|  (*smap)[0x2997] = U_Common;
  291|      1|  (*smap)[0x2998] = U_Common;
  292|     64|  for (char32 c = 0x2999; c <= 0x29D7; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (292:27): [True: 63, False: 1]
  ------------------
  293|      1|  (*smap)[0x29D8] = U_Common;
  294|      1|  (*smap)[0x29D9] = U_Common;
  295|      1|  (*smap)[0x29DA] = U_Common;
  296|      1|  (*smap)[0x29DB] = U_Common;
  297|     33|  for (char32 c = 0x29DC; c <= 0x29FB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (297:27): [True: 32, False: 1]
  ------------------
  298|      1|  (*smap)[0x29FC] = U_Common;
  299|      1|  (*smap)[0x29FD] = U_Common;
  300|    259|  for (char32 c = 0x29FE; c <= 0x2AFF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (300:27): [True: 258, False: 1]
  ------------------
  301|     49|  for (char32 c = 0x2B00; c <= 0x2B2F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (301:27): [True: 48, False: 1]
  ------------------
  302|     22|  for (char32 c = 0x2B30; c <= 0x2B44; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (302:27): [True: 21, False: 1]
  ------------------
  303|      3|  for (char32 c = 0x2B45; c <= 0x2B46; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (303:27): [True: 2, False: 1]
  ------------------
  304|      7|  for (char32 c = 0x2B47; c <= 0x2B4C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (304:27): [True: 6, False: 1]
  ------------------
  305|     40|  for (char32 c = 0x2B4D; c <= 0x2B73; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (305:27): [True: 39, False: 1]
  ------------------
  306|     33|  for (char32 c = 0x2B76; c <= 0x2B95; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (306:27): [True: 32, False: 1]
  ------------------
  307|     35|  for (char32 c = 0x2B98; c <= 0x2BB9; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (307:27): [True: 34, False: 1]
  ------------------
  308|     13|  for (char32 c = 0x2BBD; c <= 0x2BC8; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (308:27): [True: 12, False: 1]
  ------------------
  309|      9|  for (char32 c = 0x2BCA; c <= 0x2BD1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (309:27): [True: 8, False: 1]
  ------------------
  310|      5|  for (char32 c = 0x2BEC; c <= 0x2BEF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (310:27): [True: 4, False: 1]
  ------------------
  311|      3|  for (char32 c = 0x2E00; c <= 0x2E01; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (311:27): [True: 2, False: 1]
  ------------------
  312|      1|  (*smap)[0x2E02] = U_Common;
  313|      1|  (*smap)[0x2E03] = U_Common;
  314|      1|  (*smap)[0x2E04] = U_Common;
  315|      1|  (*smap)[0x2E05] = U_Common;
  316|      4|  for (char32 c = 0x2E06; c <= 0x2E08; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (316:27): [True: 3, False: 1]
  ------------------
  317|      1|  (*smap)[0x2E09] = U_Common;
  318|      1|  (*smap)[0x2E0A] = U_Common;
  319|      1|  (*smap)[0x2E0B] = U_Common;
  320|      1|  (*smap)[0x2E0C] = U_Common;
  321|      1|  (*smap)[0x2E0D] = U_Common;
  322|     10|  for (char32 c = 0x2E0E; c <= 0x2E16; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (322:27): [True: 9, False: 1]
  ------------------
  323|      1|  (*smap)[0x2E17] = U_Common;
  324|      3|  for (char32 c = 0x2E18; c <= 0x2E19; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (324:27): [True: 2, False: 1]
  ------------------
  325|      1|  (*smap)[0x2E1A] = U_Common;
  326|      1|  (*smap)[0x2E1B] = U_Common;
  327|      1|  (*smap)[0x2E1C] = U_Common;
  328|      1|  (*smap)[0x2E1D] = U_Common;
  329|      3|  for (char32 c = 0x2E1E; c <= 0x2E1F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (329:27): [True: 2, False: 1]
  ------------------
  330|      1|  (*smap)[0x2E20] = U_Common;
  331|      1|  (*smap)[0x2E21] = U_Common;
  332|      1|  (*smap)[0x2E22] = U_Common;
  333|      1|  (*smap)[0x2E23] = U_Common;
  334|      1|  (*smap)[0x2E24] = U_Common;
  335|      1|  (*smap)[0x2E25] = U_Common;
  336|      1|  (*smap)[0x2E26] = U_Common;
  337|      1|  (*smap)[0x2E27] = U_Common;
  338|      1|  (*smap)[0x2E28] = U_Common;
  339|      1|  (*smap)[0x2E29] = U_Common;
  340|      6|  for (char32 c = 0x2E2A; c <= 0x2E2E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (340:27): [True: 5, False: 1]
  ------------------
  341|      1|  (*smap)[0x2E2F] = U_Common;
  342|     11|  for (char32 c = 0x2E30; c <= 0x2E39; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (342:27): [True: 10, False: 1]
  ------------------
  343|      3|  for (char32 c = 0x2E3A; c <= 0x2E3B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (343:27): [True: 2, False: 1]
  ------------------
  344|      5|  for (char32 c = 0x2E3C; c <= 0x2E3F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (344:27): [True: 4, False: 1]
  ------------------
  345|      1|  (*smap)[0x2E40] = U_Common;
  346|      1|  (*smap)[0x2E41] = U_Common;
  347|      1|  (*smap)[0x2E42] = U_Common;
  348|      3|  for (char32 c = 0x2E43; c <= 0x2E44; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (348:27): [True: 2, False: 1]
  ------------------
  349|     13|  for (char32 c = 0x2FF0; c <= 0x2FFB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (349:27): [True: 12, False: 1]
  ------------------
  350|      1|  (*smap)[0x3000] = U_Common;
  351|      4|  for (char32 c = 0x3001; c <= 0x3003; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (351:27): [True: 3, False: 1]
  ------------------
  352|      1|  (*smap)[0x3004] = U_Common;
  353|      1|  (*smap)[0x3006] = U_Common;
  354|      1|  (*smap)[0x3008] = U_Common;
  355|      1|  (*smap)[0x3009] = U_Common;
  356|      1|  (*smap)[0x300A] = U_Common;
  357|      1|  (*smap)[0x300B] = U_Common;
  358|      1|  (*smap)[0x300C] = U_Common;
  359|      1|  (*smap)[0x300D] = U_Common;
  360|      1|  (*smap)[0x300E] = U_Common;
  361|      1|  (*smap)[0x300F] = U_Common;
  362|      1|  (*smap)[0x3010] = U_Common;
  363|      1|  (*smap)[0x3011] = U_Common;
  364|      3|  for (char32 c = 0x3012; c <= 0x3013; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (364:27): [True: 2, False: 1]
  ------------------
  365|      1|  (*smap)[0x3014] = U_Common;
  366|      1|  (*smap)[0x3015] = U_Common;
  367|      1|  (*smap)[0x3016] = U_Common;
  368|      1|  (*smap)[0x3017] = U_Common;
  369|      1|  (*smap)[0x3018] = U_Common;
  370|      1|  (*smap)[0x3019] = U_Common;
  371|      1|  (*smap)[0x301A] = U_Common;
  372|      1|  (*smap)[0x301B] = U_Common;
  373|      1|  (*smap)[0x301C] = U_Common;
  374|      1|  (*smap)[0x301D] = U_Common;
  375|      3|  for (char32 c = 0x301E; c <= 0x301F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (375:27): [True: 2, False: 1]
  ------------------
  376|      1|  (*smap)[0x3020] = U_Common;
  377|      1|  (*smap)[0x3030] = U_Common;
  378|      6|  for (char32 c = 0x3031; c <= 0x3035; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (378:27): [True: 5, False: 1]
  ------------------
  379|      3|  for (char32 c = 0x3036; c <= 0x3037; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (379:27): [True: 2, False: 1]
  ------------------
  380|      1|  (*smap)[0x303C] = U_Common;
  381|      1|  (*smap)[0x303D] = U_Common;
  382|      3|  for (char32 c = 0x303E; c <= 0x303F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (382:27): [True: 2, False: 1]
  ------------------
  383|      3|  for (char32 c = 0x309B; c <= 0x309C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (383:27): [True: 2, False: 1]
  ------------------
  384|      1|  (*smap)[0x30A0] = U_Common;
  385|      1|  (*smap)[0x30FB] = U_Common;
  386|      1|  (*smap)[0x30FC] = U_Common;
  387|      3|  for (char32 c = 0x3190; c <= 0x3191; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (387:27): [True: 2, False: 1]
  ------------------
  388|      5|  for (char32 c = 0x3192; c <= 0x3195; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (388:27): [True: 4, False: 1]
  ------------------
  389|     11|  for (char32 c = 0x3196; c <= 0x319F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (389:27): [True: 10, False: 1]
  ------------------
  390|     37|  for (char32 c = 0x31C0; c <= 0x31E3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (390:27): [True: 36, False: 1]
  ------------------
  391|     11|  for (char32 c = 0x3220; c <= 0x3229; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (391:27): [True: 10, False: 1]
  ------------------
  392|     31|  for (char32 c = 0x322A; c <= 0x3247; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (392:27): [True: 30, False: 1]
  ------------------
  393|      9|  for (char32 c = 0x3248; c <= 0x324F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (393:27): [True: 8, False: 1]
  ------------------
  394|      1|  (*smap)[0x3250] = U_Common;
  395|     16|  for (char32 c = 0x3251; c <= 0x325F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (395:27): [True: 15, False: 1]
  ------------------
  396|      1|  (*smap)[0x327F] = U_Common;
  397|     11|  for (char32 c = 0x3280; c <= 0x3289; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (397:27): [True: 10, False: 1]
  ------------------
  398|     40|  for (char32 c = 0x328A; c <= 0x32B0; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (398:27): [True: 39, False: 1]
  ------------------
  399|     16|  for (char32 c = 0x32B1; c <= 0x32BF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (399:27): [True: 15, False: 1]
  ------------------
  400|     17|  for (char32 c = 0x32C0; c <= 0x32CF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (400:27): [True: 16, False: 1]
  ------------------
  401|    169|  for (char32 c = 0x3358; c <= 0x33FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (401:27): [True: 168, False: 1]
  ------------------
  402|     65|  for (char32 c = 0x4DC0; c <= 0x4DFF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (402:27): [True: 64, False: 1]
  ------------------
  403|     24|  for (char32 c = 0xA700; c <= 0xA716; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (403:27): [True: 23, False: 1]
  ------------------
  404|     10|  for (char32 c = 0xA717; c <= 0xA71F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (404:27): [True: 9, False: 1]
  ------------------
  405|      3|  for (char32 c = 0xA720; c <= 0xA721; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (405:27): [True: 2, False: 1]
  ------------------
  406|      1|  (*smap)[0xA788] = U_Common;
  407|      3|  for (char32 c = 0xA789; c <= 0xA78A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (407:27): [True: 2, False: 1]
  ------------------
  408|      7|  for (char32 c = 0xA830; c <= 0xA835; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (408:27): [True: 6, False: 1]
  ------------------
  409|      3|  for (char32 c = 0xA836; c <= 0xA837; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (409:27): [True: 2, False: 1]
  ------------------
  410|      1|  (*smap)[0xA838] = U_Common;
  411|      1|  (*smap)[0xA839] = U_Common;
  412|      1|  (*smap)[0xA92E] = U_Common;
  413|      1|  (*smap)[0xA9CF] = U_Common;
  414|      1|  (*smap)[0xAB5B] = U_Common;
  415|      1|  (*smap)[0xFD3E] = U_Common;
  416|      1|  (*smap)[0xFD3F] = U_Common;
  417|      8|  for (char32 c = 0xFE10; c <= 0xFE16; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (417:27): [True: 7, False: 1]
  ------------------
  418|      1|  (*smap)[0xFE17] = U_Common;
  419|      1|  (*smap)[0xFE18] = U_Common;
  420|      1|  (*smap)[0xFE19] = U_Common;
  421|      1|  (*smap)[0xFE30] = U_Common;
  422|      3|  for (char32 c = 0xFE31; c <= 0xFE32; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (422:27): [True: 2, False: 1]
  ------------------
  423|      3|  for (char32 c = 0xFE33; c <= 0xFE34; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (423:27): [True: 2, False: 1]
  ------------------
  424|      1|  (*smap)[0xFE35] = U_Common;
  425|      1|  (*smap)[0xFE36] = U_Common;
  426|      1|  (*smap)[0xFE37] = U_Common;
  427|      1|  (*smap)[0xFE38] = U_Common;
  428|      1|  (*smap)[0xFE39] = U_Common;
  429|      1|  (*smap)[0xFE3A] = U_Common;
  430|      1|  (*smap)[0xFE3B] = U_Common;
  431|      1|  (*smap)[0xFE3C] = U_Common;
  432|      1|  (*smap)[0xFE3D] = U_Common;
  433|      1|  (*smap)[0xFE3E] = U_Common;
  434|      1|  (*smap)[0xFE3F] = U_Common;
  435|      1|  (*smap)[0xFE40] = U_Common;
  436|      1|  (*smap)[0xFE41] = U_Common;
  437|      1|  (*smap)[0xFE42] = U_Common;
  438|      1|  (*smap)[0xFE43] = U_Common;
  439|      1|  (*smap)[0xFE44] = U_Common;
  440|      3|  for (char32 c = 0xFE45; c <= 0xFE46; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (440:27): [True: 2, False: 1]
  ------------------
  441|      1|  (*smap)[0xFE47] = U_Common;
  442|      1|  (*smap)[0xFE48] = U_Common;
  443|      5|  for (char32 c = 0xFE49; c <= 0xFE4C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (443:27): [True: 4, False: 1]
  ------------------
  444|      4|  for (char32 c = 0xFE4D; c <= 0xFE4F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (444:27): [True: 3, False: 1]
  ------------------
  445|      4|  for (char32 c = 0xFE50; c <= 0xFE52; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (445:27): [True: 3, False: 1]
  ------------------
  446|      5|  for (char32 c = 0xFE54; c <= 0xFE57; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (446:27): [True: 4, False: 1]
  ------------------
  447|      1|  (*smap)[0xFE58] = U_Common;
  448|      1|  (*smap)[0xFE59] = U_Common;
  449|      1|  (*smap)[0xFE5A] = U_Common;
  450|      1|  (*smap)[0xFE5B] = U_Common;
  451|      1|  (*smap)[0xFE5C] = U_Common;
  452|      1|  (*smap)[0xFE5D] = U_Common;
  453|      1|  (*smap)[0xFE5E] = U_Common;
  454|      4|  for (char32 c = 0xFE5F; c <= 0xFE61; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (454:27): [True: 3, False: 1]
  ------------------
  455|      1|  (*smap)[0xFE62] = U_Common;
  456|      1|  (*smap)[0xFE63] = U_Common;
  457|      4|  for (char32 c = 0xFE64; c <= 0xFE66; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (457:27): [True: 3, False: 1]
  ------------------
  458|      1|  (*smap)[0xFE68] = U_Common;
  459|      1|  (*smap)[0xFE69] = U_Common;
  460|      3|  for (char32 c = 0xFE6A; c <= 0xFE6B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (460:27): [True: 2, False: 1]
  ------------------
  461|      1|  (*smap)[0xFEFF] = U_Common;
  462|      4|  for (char32 c = 0xFF01; c <= 0xFF03; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (462:27): [True: 3, False: 1]
  ------------------
  463|      1|  (*smap)[0xFF04] = U_Common;
  464|      4|  for (char32 c = 0xFF05; c <= 0xFF07; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (464:27): [True: 3, False: 1]
  ------------------
  465|      1|  (*smap)[0xFF08] = U_Common;
  466|      1|  (*smap)[0xFF09] = U_Common;
  467|      1|  (*smap)[0xFF0A] = U_Common;
  468|      1|  (*smap)[0xFF0B] = U_Common;
  469|      1|  (*smap)[0xFF0C] = U_Common;
  470|      1|  (*smap)[0xFF0D] = U_Common;
  471|      3|  for (char32 c = 0xFF0E; c <= 0xFF0F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (471:27): [True: 2, False: 1]
  ------------------
  472|     11|  for (char32 c = 0xFF10; c <= 0xFF19; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (472:27): [True: 10, False: 1]
  ------------------
  473|      3|  for (char32 c = 0xFF1A; c <= 0xFF1B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (473:27): [True: 2, False: 1]
  ------------------
  474|      4|  for (char32 c = 0xFF1C; c <= 0xFF1E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (474:27): [True: 3, False: 1]
  ------------------
  475|      3|  for (char32 c = 0xFF1F; c <= 0xFF20; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (475:27): [True: 2, False: 1]
  ------------------
  476|      1|  (*smap)[0xFF3B] = U_Common;
  477|      1|  (*smap)[0xFF3C] = U_Common;
  478|      1|  (*smap)[0xFF3D] = U_Common;
  479|      1|  (*smap)[0xFF3E] = U_Common;
  480|      1|  (*smap)[0xFF3F] = U_Common;
  481|      1|  (*smap)[0xFF40] = U_Common;
  482|      1|  (*smap)[0xFF5B] = U_Common;
  483|      1|  (*smap)[0xFF5C] = U_Common;
  484|      1|  (*smap)[0xFF5D] = U_Common;
  485|      1|  (*smap)[0xFF5E] = U_Common;
  486|      1|  (*smap)[0xFF5F] = U_Common;
  487|      1|  (*smap)[0xFF60] = U_Common;
  488|      1|  (*smap)[0xFF61] = U_Common;
  489|      1|  (*smap)[0xFF62] = U_Common;
  490|      1|  (*smap)[0xFF63] = U_Common;
  491|      3|  for (char32 c = 0xFF64; c <= 0xFF65; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (491:27): [True: 2, False: 1]
  ------------------
  492|      1|  (*smap)[0xFF70] = U_Common;
  493|      3|  for (char32 c = 0xFF9E; c <= 0xFF9F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (493:27): [True: 2, False: 1]
  ------------------
  494|      3|  for (char32 c = 0xFFE0; c <= 0xFFE1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (494:27): [True: 2, False: 1]
  ------------------
  495|      1|  (*smap)[0xFFE2] = U_Common;
  496|      1|  (*smap)[0xFFE3] = U_Common;
  497|      1|  (*smap)[0xFFE4] = U_Common;
  498|      3|  for (char32 c = 0xFFE5; c <= 0xFFE6; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (498:27): [True: 2, False: 1]
  ------------------
  499|      1|  (*smap)[0xFFE8] = U_Common;
  500|      5|  for (char32 c = 0xFFE9; c <= 0xFFEC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (500:27): [True: 4, False: 1]
  ------------------
  501|      3|  for (char32 c = 0xFFED; c <= 0xFFEE; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (501:27): [True: 2, False: 1]
  ------------------
  502|      4|  for (char32 c = 0xFFF9; c <= 0xFFFB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (502:27): [True: 3, False: 1]
  ------------------
  503|      3|  for (char32 c = 0xFFFC; c <= 0xFFFD; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (503:27): [True: 2, False: 1]
  ------------------
  504|      4|  for (char32 c = 0x10100; c <= 0x10102; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (504:28): [True: 3, False: 1]
  ------------------
  505|     46|  for (char32 c = 0x10107; c <= 0x10133; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (505:28): [True: 45, False: 1]
  ------------------
  506|     10|  for (char32 c = 0x10137; c <= 0x1013F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (506:28): [True: 9, False: 1]
  ------------------
  507|     13|  for (char32 c = 0x10190; c <= 0x1019B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (507:28): [True: 12, False: 1]
  ------------------
  508|     46|  for (char32 c = 0x101D0; c <= 0x101FC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (508:28): [True: 45, False: 1]
  ------------------
  509|     28|  for (char32 c = 0x102E1; c <= 0x102FB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (509:28): [True: 27, False: 1]
  ------------------
  510|      5|  for (char32 c = 0x1BCA0; c <= 0x1BCA3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (510:28): [True: 4, False: 1]
  ------------------
  511|    247|  for (char32 c = 0x1D000; c <= 0x1D0F5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (511:28): [True: 246, False: 1]
  ------------------
  512|     40|  for (char32 c = 0x1D100; c <= 0x1D126; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (512:28): [True: 39, False: 1]
  ------------------
  513|     61|  for (char32 c = 0x1D129; c <= 0x1D164; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (513:28): [True: 60, False: 1]
  ------------------
  514|      3|  for (char32 c = 0x1D165; c <= 0x1D166; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (514:28): [True: 2, False: 1]
  ------------------
  515|      4|  for (char32 c = 0x1D16A; c <= 0x1D16C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (515:28): [True: 3, False: 1]
  ------------------
  516|      7|  for (char32 c = 0x1D16D; c <= 0x1D172; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (516:28): [True: 6, False: 1]
  ------------------
  517|      9|  for (char32 c = 0x1D173; c <= 0x1D17A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (517:28): [True: 8, False: 1]
  ------------------
  518|      3|  for (char32 c = 0x1D183; c <= 0x1D184; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (518:28): [True: 2, False: 1]
  ------------------
  519|     31|  for (char32 c = 0x1D18C; c <= 0x1D1A9; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (519:28): [True: 30, False: 1]
  ------------------
  520|     60|  for (char32 c = 0x1D1AE; c <= 0x1D1E8; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (520:28): [True: 59, False: 1]
  ------------------
  521|     88|  for (char32 c = 0x1D300; c <= 0x1D356; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (521:28): [True: 87, False: 1]
  ------------------
  522|     19|  for (char32 c = 0x1D360; c <= 0x1D371; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (522:28): [True: 18, False: 1]
  ------------------
  523|     86|  for (char32 c = 0x1D400; c <= 0x1D454; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (523:28): [True: 85, False: 1]
  ------------------
  524|     72|  for (char32 c = 0x1D456; c <= 0x1D49C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (524:28): [True: 71, False: 1]
  ------------------
  525|      3|  for (char32 c = 0x1D49E; c <= 0x1D49F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (525:28): [True: 2, False: 1]
  ------------------
  526|      1|  (*smap)[0x1D4A2] = U_Common;
  527|      3|  for (char32 c = 0x1D4A5; c <= 0x1D4A6; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (527:28): [True: 2, False: 1]
  ------------------
  528|      5|  for (char32 c = 0x1D4A9; c <= 0x1D4AC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (528:28): [True: 4, False: 1]
  ------------------
  529|     13|  for (char32 c = 0x1D4AE; c <= 0x1D4B9; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (529:28): [True: 12, False: 1]
  ------------------
  530|      1|  (*smap)[0x1D4BB] = U_Common;
  531|      8|  for (char32 c = 0x1D4BD; c <= 0x1D4C3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (531:28): [True: 7, False: 1]
  ------------------
  532|     66|  for (char32 c = 0x1D4C5; c <= 0x1D505; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (532:28): [True: 65, False: 1]
  ------------------
  533|      5|  for (char32 c = 0x1D507; c <= 0x1D50A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (533:28): [True: 4, False: 1]
  ------------------
  534|      9|  for (char32 c = 0x1D50D; c <= 0x1D514; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (534:28): [True: 8, False: 1]
  ------------------
  535|      8|  for (char32 c = 0x1D516; c <= 0x1D51C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (535:28): [True: 7, False: 1]
  ------------------
  536|     29|  for (char32 c = 0x1D51E; c <= 0x1D539; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (536:28): [True: 28, False: 1]
  ------------------
  537|      5|  for (char32 c = 0x1D53B; c <= 0x1D53E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (537:28): [True: 4, False: 1]
  ------------------
  538|      6|  for (char32 c = 0x1D540; c <= 0x1D544; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (538:28): [True: 5, False: 1]
  ------------------
  539|      1|  (*smap)[0x1D546] = U_Common;
  540|      8|  for (char32 c = 0x1D54A; c <= 0x1D550; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (540:28): [True: 7, False: 1]
  ------------------
  541|    341|  for (char32 c = 0x1D552; c <= 0x1D6A5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (541:28): [True: 340, False: 1]
  ------------------
  542|     26|  for (char32 c = 0x1D6A8; c <= 0x1D6C0; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (542:28): [True: 25, False: 1]
  ------------------
  543|      1|  (*smap)[0x1D6C1] = U_Common;
  544|     26|  for (char32 c = 0x1D6C2; c <= 0x1D6DA; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (544:28): [True: 25, False: 1]
  ------------------
  545|      1|  (*smap)[0x1D6DB] = U_Common;
  546|     32|  for (char32 c = 0x1D6DC; c <= 0x1D6FA; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (546:28): [True: 31, False: 1]
  ------------------
  547|      1|  (*smap)[0x1D6FB] = U_Common;
  548|     26|  for (char32 c = 0x1D6FC; c <= 0x1D714; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (548:28): [True: 25, False: 1]
  ------------------
  549|      1|  (*smap)[0x1D715] = U_Common;
  550|     32|  for (char32 c = 0x1D716; c <= 0x1D734; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (550:28): [True: 31, False: 1]
  ------------------
  551|      1|  (*smap)[0x1D735] = U_Common;
  552|     26|  for (char32 c = 0x1D736; c <= 0x1D74E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (552:28): [True: 25, False: 1]
  ------------------
  553|      1|  (*smap)[0x1D74F] = U_Common;
  554|     32|  for (char32 c = 0x1D750; c <= 0x1D76E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (554:28): [True: 31, False: 1]
  ------------------
  555|      1|  (*smap)[0x1D76F] = U_Common;
  556|     26|  for (char32 c = 0x1D770; c <= 0x1D788; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (556:28): [True: 25, False: 1]
  ------------------
  557|      1|  (*smap)[0x1D789] = U_Common;
  558|     32|  for (char32 c = 0x1D78A; c <= 0x1D7A8; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (558:28): [True: 31, False: 1]
  ------------------
  559|      1|  (*smap)[0x1D7A9] = U_Common;
  560|     26|  for (char32 c = 0x1D7AA; c <= 0x1D7C2; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (560:28): [True: 25, False: 1]
  ------------------
  561|      1|  (*smap)[0x1D7C3] = U_Common;
  562|      9|  for (char32 c = 0x1D7C4; c <= 0x1D7CB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (562:28): [True: 8, False: 1]
  ------------------
  563|     51|  for (char32 c = 0x1D7CE; c <= 0x1D7FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (563:28): [True: 50, False: 1]
  ------------------
  564|     45|  for (char32 c = 0x1F000; c <= 0x1F02B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (564:28): [True: 44, False: 1]
  ------------------
  565|    101|  for (char32 c = 0x1F030; c <= 0x1F093; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (565:28): [True: 100, False: 1]
  ------------------
  566|     16|  for (char32 c = 0x1F0A0; c <= 0x1F0AE; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (566:28): [True: 15, False: 1]
  ------------------
  567|     16|  for (char32 c = 0x1F0B1; c <= 0x1F0BF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (567:28): [True: 15, False: 1]
  ------------------
  568|     16|  for (char32 c = 0x1F0C1; c <= 0x1F0CF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (568:28): [True: 15, False: 1]
  ------------------
  569|     38|  for (char32 c = 0x1F0D1; c <= 0x1F0F5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (569:28): [True: 37, False: 1]
  ------------------
  570|     14|  for (char32 c = 0x1F100; c <= 0x1F10C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (570:28): [True: 13, False: 1]
  ------------------
  571|     32|  for (char32 c = 0x1F110; c <= 0x1F12E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (571:28): [True: 31, False: 1]
  ------------------
  572|     61|  for (char32 c = 0x1F130; c <= 0x1F16B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (572:28): [True: 60, False: 1]
  ------------------
  573|     62|  for (char32 c = 0x1F170; c <= 0x1F1AC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (573:28): [True: 61, False: 1]
  ------------------
  574|     27|  for (char32 c = 0x1F1E6; c <= 0x1F1FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (574:28): [True: 26, False: 1]
  ------------------
  575|      3|  for (char32 c = 0x1F201; c <= 0x1F202; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (575:28): [True: 2, False: 1]
  ------------------
  576|     45|  for (char32 c = 0x1F210; c <= 0x1F23B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (576:28): [True: 44, False: 1]
  ------------------
  577|     10|  for (char32 c = 0x1F240; c <= 0x1F248; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (577:28): [True: 9, False: 1]
  ------------------
  578|      3|  for (char32 c = 0x1F250; c <= 0x1F251; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (578:28): [True: 2, False: 1]
  ------------------
  579|    252|  for (char32 c = 0x1F300; c <= 0x1F3FA; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (579:28): [True: 251, False: 1]
  ------------------
  580|      6|  for (char32 c = 0x1F3FB; c <= 0x1F3FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (580:28): [True: 5, False: 1]
  ------------------
  581|    724|  for (char32 c = 0x1F400; c <= 0x1F6D2; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (581:28): [True: 723, False: 1]
  ------------------
  582|     14|  for (char32 c = 0x1F6E0; c <= 0x1F6EC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (582:28): [True: 13, False: 1]
  ------------------
  583|      8|  for (char32 c = 0x1F6F0; c <= 0x1F6F6; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (583:28): [True: 7, False: 1]
  ------------------
  584|    117|  for (char32 c = 0x1F700; c <= 0x1F773; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (584:28): [True: 116, False: 1]
  ------------------
  585|     86|  for (char32 c = 0x1F780; c <= 0x1F7D4; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (585:28): [True: 85, False: 1]
  ------------------
  586|     13|  for (char32 c = 0x1F800; c <= 0x1F80B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (586:28): [True: 12, False: 1]
  ------------------
  587|     57|  for (char32 c = 0x1F810; c <= 0x1F847; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (587:28): [True: 56, False: 1]
  ------------------
  588|     11|  for (char32 c = 0x1F850; c <= 0x1F859; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (588:28): [True: 10, False: 1]
  ------------------
  589|     41|  for (char32 c = 0x1F860; c <= 0x1F887; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (589:28): [True: 40, False: 1]
  ------------------
  590|     31|  for (char32 c = 0x1F890; c <= 0x1F8AD; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (590:28): [True: 30, False: 1]
  ------------------
  591|     16|  for (char32 c = 0x1F910; c <= 0x1F91E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (591:28): [True: 15, False: 1]
  ------------------
  592|      9|  for (char32 c = 0x1F920; c <= 0x1F927; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (592:28): [True: 8, False: 1]
  ------------------
  593|      1|  (*smap)[0x1F930] = U_Common;
  594|     13|  for (char32 c = 0x1F933; c <= 0x1F93E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (594:28): [True: 12, False: 1]
  ------------------
  595|     13|  for (char32 c = 0x1F940; c <= 0x1F94B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (595:28): [True: 12, False: 1]
  ------------------
  596|     16|  for (char32 c = 0x1F950; c <= 0x1F95E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (596:28): [True: 15, False: 1]
  ------------------
  597|     19|  for (char32 c = 0x1F980; c <= 0x1F991; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (597:28): [True: 18, False: 1]
  ------------------
  598|      1|  (*smap)[0x1F9C0] = U_Common;
  599|      1|  (*smap)[0xE0001] = U_Common;
  600|     97|  for (char32 c = 0xE0020; c <= 0xE007F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (600:28): [True: 96, False: 1]
  ------------------
  601|     27|  for (char32 c = 0x0041; c <= 0x005A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (601:27): [True: 26, False: 1]
  ------------------
  602|     27|  for (char32 c = 0x0061; c <= 0x007A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (602:27): [True: 26, False: 1]
  ------------------
  603|      1|  (*smap)[0x00AA] = U_Latin;
  604|      1|  (*smap)[0x00BA] = U_Latin;
  605|     24|  for (char32 c = 0x00C0; c <= 0x00D6; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (605:27): [True: 23, False: 1]
  ------------------
  606|     32|  for (char32 c = 0x00D8; c <= 0x00F6; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (606:27): [True: 31, False: 1]
  ------------------
  607|    196|  for (char32 c = 0x00F8; c <= 0x01BA; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (607:27): [True: 195, False: 1]
  ------------------
  608|      1|  (*smap)[0x01BB] = U_Latin;
  609|      5|  for (char32 c = 0x01BC; c <= 0x01BF; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (609:27): [True: 4, False: 1]
  ------------------
  610|      5|  for (char32 c = 0x01C0; c <= 0x01C3; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (610:27): [True: 4, False: 1]
  ------------------
  611|    209|  for (char32 c = 0x01C4; c <= 0x0293; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (611:27): [True: 208, False: 1]
  ------------------
  612|      1|  (*smap)[0x0294] = U_Latin;
  613|     28|  for (char32 c = 0x0295; c <= 0x02AF; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (613:27): [True: 27, False: 1]
  ------------------
  614|     10|  for (char32 c = 0x02B0; c <= 0x02B8; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (614:27): [True: 9, False: 1]
  ------------------
  615|      6|  for (char32 c = 0x02E0; c <= 0x02E4; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (615:27): [True: 5, False: 1]
  ------------------
  616|     39|  for (char32 c = 0x1D00; c <= 0x1D25; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (616:27): [True: 38, False: 1]
  ------------------
  617|     50|  for (char32 c = 0x1D2C; c <= 0x1D5C; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (617:27): [True: 49, False: 1]
  ------------------
  618|      5|  for (char32 c = 0x1D62; c <= 0x1D65; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (618:27): [True: 4, False: 1]
  ------------------
  619|     14|  for (char32 c = 0x1D6B; c <= 0x1D77; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (619:27): [True: 13, False: 1]
  ------------------
  620|     35|  for (char32 c = 0x1D79; c <= 0x1D9A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (620:27): [True: 34, False: 1]
  ------------------
  621|     37|  for (char32 c = 0x1D9B; c <= 0x1DBE; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (621:27): [True: 36, False: 1]
  ------------------
  622|    257|  for (char32 c = 0x1E00; c <= 0x1EFF; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (622:27): [True: 256, False: 1]
  ------------------
  623|      1|  (*smap)[0x2071] = U_Latin;
  624|      1|  (*smap)[0x207F] = U_Latin;
  625|     14|  for (char32 c = 0x2090; c <= 0x209C; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (625:27): [True: 13, False: 1]
  ------------------
  626|      3|  for (char32 c = 0x212A; c <= 0x212B; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (626:27): [True: 2, False: 1]
  ------------------
  627|      1|  (*smap)[0x2132] = U_Latin;
  628|      1|  (*smap)[0x214E] = U_Latin;
  629|     36|  for (char32 c = 0x2160; c <= 0x2182; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (629:27): [True: 35, False: 1]
  ------------------
  630|      3|  for (char32 c = 0x2183; c <= 0x2184; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (630:27): [True: 2, False: 1]
  ------------------
  631|      5|  for (char32 c = 0x2185; c <= 0x2188; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (631:27): [True: 4, False: 1]
  ------------------
  632|     29|  for (char32 c = 0x2C60; c <= 0x2C7B; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (632:27): [True: 28, False: 1]
  ------------------
  633|      3|  for (char32 c = 0x2C7C; c <= 0x2C7D; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (633:27): [True: 2, False: 1]
  ------------------
  634|      3|  for (char32 c = 0x2C7E; c <= 0x2C7F; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (634:27): [True: 2, False: 1]
  ------------------
  635|     79|  for (char32 c = 0xA722; c <= 0xA76F; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (635:27): [True: 78, False: 1]
  ------------------
  636|      1|  (*smap)[0xA770] = U_Latin;
  637|     24|  for (char32 c = 0xA771; c <= 0xA787; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (637:27): [True: 23, False: 1]
  ------------------
  638|      5|  for (char32 c = 0xA78B; c <= 0xA78E; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (638:27): [True: 4, False: 1]
  ------------------
  639|      1|  (*smap)[0xA78F] = U_Latin;
  640|     32|  for (char32 c = 0xA790; c <= 0xA7AE; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (640:27): [True: 31, False: 1]
  ------------------
  641|      9|  for (char32 c = 0xA7B0; c <= 0xA7B7; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (641:27): [True: 8, False: 1]
  ------------------
  642|      1|  (*smap)[0xA7F7] = U_Latin;
  643|      3|  for (char32 c = 0xA7F8; c <= 0xA7F9; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (643:27): [True: 2, False: 1]
  ------------------
  644|      1|  (*smap)[0xA7FA] = U_Latin;
  645|      6|  for (char32 c = 0xA7FB; c <= 0xA7FF; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (645:27): [True: 5, False: 1]
  ------------------
  646|     44|  for (char32 c = 0xAB30; c <= 0xAB5A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (646:27): [True: 43, False: 1]
  ------------------
  647|      5|  for (char32 c = 0xAB5C; c <= 0xAB5F; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (647:27): [True: 4, False: 1]
  ------------------
  648|      6|  for (char32 c = 0xAB60; c <= 0xAB64; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (648:27): [True: 5, False: 1]
  ------------------
  649|      8|  for (char32 c = 0xFB00; c <= 0xFB06; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (649:27): [True: 7, False: 1]
  ------------------
  650|     27|  for (char32 c = 0xFF21; c <= 0xFF3A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (650:27): [True: 26, False: 1]
  ------------------
  651|     27|  for (char32 c = 0xFF41; c <= 0xFF5A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (651:27): [True: 26, False: 1]
  ------------------
  652|      5|  for (char32 c = 0x0370; c <= 0x0373; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (652:27): [True: 4, False: 1]
  ------------------
  653|      1|  (*smap)[0x0375] = U_Greek;
  654|      3|  for (char32 c = 0x0376; c <= 0x0377; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (654:27): [True: 2, False: 1]
  ------------------
  655|      1|  (*smap)[0x037A] = U_Greek;
  656|      4|  for (char32 c = 0x037B; c <= 0x037D; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (656:27): [True: 3, False: 1]
  ------------------
  657|      1|  (*smap)[0x037F] = U_Greek;
  658|      1|  (*smap)[0x0384] = U_Greek;
  659|      1|  (*smap)[0x0386] = U_Greek;
  660|      4|  for (char32 c = 0x0388; c <= 0x038A; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (660:27): [True: 3, False: 1]
  ------------------
  661|      1|  (*smap)[0x038C] = U_Greek;
  662|     21|  for (char32 c = 0x038E; c <= 0x03A1; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (662:27): [True: 20, False: 1]
  ------------------
  663|     64|  for (char32 c = 0x03A3; c <= 0x03E1; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (663:27): [True: 63, False: 1]
  ------------------
  664|      7|  for (char32 c = 0x03F0; c <= 0x03F5; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (664:27): [True: 6, False: 1]
  ------------------
  665|      1|  (*smap)[0x03F6] = U_Greek;
  666|     10|  for (char32 c = 0x03F7; c <= 0x03FF; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (666:27): [True: 9, False: 1]
  ------------------
  667|      6|  for (char32 c = 0x1D26; c <= 0x1D2A; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (667:27): [True: 5, False: 1]
  ------------------
  668|      6|  for (char32 c = 0x1D5D; c <= 0x1D61; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (668:27): [True: 5, False: 1]
  ------------------
  669|      6|  for (char32 c = 0x1D66; c <= 0x1D6A; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (669:27): [True: 5, False: 1]
  ------------------
  670|      1|  (*smap)[0x1DBF] = U_Greek;
  671|     23|  for (char32 c = 0x1F00; c <= 0x1F15; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (671:27): [True: 22, False: 1]
  ------------------
  672|      7|  for (char32 c = 0x1F18; c <= 0x1F1D; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (672:27): [True: 6, False: 1]
  ------------------
  673|     39|  for (char32 c = 0x1F20; c <= 0x1F45; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (673:27): [True: 38, False: 1]
  ------------------
  674|      7|  for (char32 c = 0x1F48; c <= 0x1F4D; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (674:27): [True: 6, False: 1]
  ------------------
  675|      9|  for (char32 c = 0x1F50; c <= 0x1F57; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (675:27): [True: 8, False: 1]
  ------------------
  676|      1|  (*smap)[0x1F59] = U_Greek;
  677|      1|  (*smap)[0x1F5B] = U_Greek;
  678|      1|  (*smap)[0x1F5D] = U_Greek;
  679|     32|  for (char32 c = 0x1F5F; c <= 0x1F7D; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (679:27): [True: 31, False: 1]
  ------------------
  680|     54|  for (char32 c = 0x1F80; c <= 0x1FB4; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (680:27): [True: 53, False: 1]
  ------------------
  681|      8|  for (char32 c = 0x1FB6; c <= 0x1FBC; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (681:27): [True: 7, False: 1]
  ------------------
  682|      1|  (*smap)[0x1FBD] = U_Greek;
  683|      1|  (*smap)[0x1FBE] = U_Greek;
  684|      4|  for (char32 c = 0x1FBF; c <= 0x1FC1; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (684:27): [True: 3, False: 1]
  ------------------
  685|      4|  for (char32 c = 0x1FC2; c <= 0x1FC4; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (685:27): [True: 3, False: 1]
  ------------------
  686|      8|  for (char32 c = 0x1FC6; c <= 0x1FCC; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (686:27): [True: 7, False: 1]
  ------------------
  687|      4|  for (char32 c = 0x1FCD; c <= 0x1FCF; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (687:27): [True: 3, False: 1]
  ------------------
  688|      5|  for (char32 c = 0x1FD0; c <= 0x1FD3; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (688:27): [True: 4, False: 1]
  ------------------
  689|      7|  for (char32 c = 0x1FD6; c <= 0x1FDB; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (689:27): [True: 6, False: 1]
  ------------------
  690|      4|  for (char32 c = 0x1FDD; c <= 0x1FDF; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (690:27): [True: 3, False: 1]
  ------------------
  691|     14|  for (char32 c = 0x1FE0; c <= 0x1FEC; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (691:27): [True: 13, False: 1]
  ------------------
  692|      4|  for (char32 c = 0x1FED; c <= 0x1FEF; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (692:27): [True: 3, False: 1]
  ------------------
  693|      4|  for (char32 c = 0x1FF2; c <= 0x1FF4; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (693:27): [True: 3, False: 1]
  ------------------
  694|      8|  for (char32 c = 0x1FF6; c <= 0x1FFC; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (694:27): [True: 7, False: 1]
  ------------------
  695|      3|  for (char32 c = 0x1FFD; c <= 0x1FFE; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (695:27): [True: 2, False: 1]
  ------------------
  696|      1|  (*smap)[0x2126] = U_Greek;
  697|      1|  (*smap)[0xAB65] = U_Greek;
  698|     54|  for (char32 c = 0x10140; c <= 0x10174; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (698:28): [True: 53, False: 1]
  ------------------
  699|      5|  for (char32 c = 0x10175; c <= 0x10178; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (699:28): [True: 4, False: 1]
  ------------------
  700|     18|  for (char32 c = 0x10179; c <= 0x10189; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (700:28): [True: 17, False: 1]
  ------------------
  701|      3|  for (char32 c = 0x1018A; c <= 0x1018B; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (701:28): [True: 2, False: 1]
  ------------------
  702|      4|  for (char32 c = 0x1018C; c <= 0x1018E; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (702:28): [True: 3, False: 1]
  ------------------
  703|      1|  (*smap)[0x101A0] = U_Greek;
  704|     67|  for (char32 c = 0x1D200; c <= 0x1D241; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (704:28): [True: 66, False: 1]
  ------------------
  705|      4|  for (char32 c = 0x1D242; c <= 0x1D244; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (705:28): [True: 3, False: 1]
  ------------------
  706|      1|  (*smap)[0x1D245] = U_Greek;
  707|    131|  for (char32 c = 0x0400; c <= 0x0481; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (707:27): [True: 130, False: 1]
  ------------------
  708|      1|  (*smap)[0x0482] = U_Cyrillic;
  709|      3|  for (char32 c = 0x0483; c <= 0x0484; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (709:27): [True: 2, False: 1]
  ------------------
  710|      1|  (*smap)[0x0487] = U_Cyrillic;
  711|      3|  for (char32 c = 0x0488; c <= 0x0489; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (711:27): [True: 2, False: 1]
  ------------------
  712|    167|  for (char32 c = 0x048A; c <= 0x052F; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (712:27): [True: 166, False: 1]
  ------------------
  713|     10|  for (char32 c = 0x1C80; c <= 0x1C88; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (713:27): [True: 9, False: 1]
  ------------------
  714|      1|  (*smap)[0x1D2B] = U_Cyrillic;
  715|      1|  (*smap)[0x1D78] = U_Cyrillic;
  716|     33|  for (char32 c = 0x2DE0; c <= 0x2DFF; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (716:27): [True: 32, False: 1]
  ------------------
  717|     47|  for (char32 c = 0xA640; c <= 0xA66D; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (717:27): [True: 46, False: 1]
  ------------------
  718|      1|  (*smap)[0xA66E] = U_Cyrillic;
  719|      1|  (*smap)[0xA66F] = U_Cyrillic;
  720|      4|  for (char32 c = 0xA670; c <= 0xA672; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (720:27): [True: 3, False: 1]
  ------------------
  721|      1|  (*smap)[0xA673] = U_Cyrillic;
  722|     11|  for (char32 c = 0xA674; c <= 0xA67D; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (722:27): [True: 10, False: 1]
  ------------------
  723|      1|  (*smap)[0xA67E] = U_Cyrillic;
  724|      1|  (*smap)[0xA67F] = U_Cyrillic;
  725|     29|  for (char32 c = 0xA680; c <= 0xA69B; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (725:27): [True: 28, False: 1]
  ------------------
  726|      3|  for (char32 c = 0xA69C; c <= 0xA69D; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (726:27): [True: 2, False: 1]
  ------------------
  727|      3|  for (char32 c = 0xA69E; c <= 0xA69F; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (727:27): [True: 2, False: 1]
  ------------------
  728|      3|  for (char32 c = 0xFE2E; c <= 0xFE2F; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (728:27): [True: 2, False: 1]
  ------------------
  729|     39|  for (char32 c = 0x0531; c <= 0x0556; ++c) (*smap)[c] = U_Armenian;
  ------------------
  |  Branch (729:27): [True: 38, False: 1]
  ------------------
  730|      1|  (*smap)[0x0559] = U_Armenian;
  731|      7|  for (char32 c = 0x055A; c <= 0x055F; ++c) (*smap)[c] = U_Armenian;
  ------------------
  |  Branch (731:27): [True: 6, False: 1]
  ------------------
  732|     40|  for (char32 c = 0x0561; c <= 0x0587; ++c) (*smap)[c] = U_Armenian;
  ------------------
  |  Branch (732:27): [True: 39, False: 1]
  ------------------
  733|      1|  (*smap)[0x058A] = U_Armenian;
  734|      3|  for (char32 c = 0x058D; c <= 0x058E; ++c) (*smap)[c] = U_Armenian;
  ------------------
  |  Branch (734:27): [True: 2, False: 1]
  ------------------
  735|      1|  (*smap)[0x058F] = U_Armenian;
  736|      6|  for (char32 c = 0xFB13; c <= 0xFB17; ++c) (*smap)[c] = U_Armenian;
  ------------------
  |  Branch (736:27): [True: 5, False: 1]
  ------------------
  737|     46|  for (char32 c = 0x0591; c <= 0x05BD; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (737:27): [True: 45, False: 1]
  ------------------
  738|      1|  (*smap)[0x05BE] = U_Hebrew;
  739|      1|  (*smap)[0x05BF] = U_Hebrew;
  740|      1|  (*smap)[0x05C0] = U_Hebrew;
  741|      3|  for (char32 c = 0x05C1; c <= 0x05C2; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (741:27): [True: 2, False: 1]
  ------------------
  742|      1|  (*smap)[0x05C3] = U_Hebrew;
  743|      3|  for (char32 c = 0x05C4; c <= 0x05C5; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (743:27): [True: 2, False: 1]
  ------------------
  744|      1|  (*smap)[0x05C6] = U_Hebrew;
  745|      1|  (*smap)[0x05C7] = U_Hebrew;
  746|     28|  for (char32 c = 0x05D0; c <= 0x05EA; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (746:27): [True: 27, False: 1]
  ------------------
  747|      4|  for (char32 c = 0x05F0; c <= 0x05F2; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (747:27): [True: 3, False: 1]
  ------------------
  748|      3|  for (char32 c = 0x05F3; c <= 0x05F4; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (748:27): [True: 2, False: 1]
  ------------------
  749|      1|  (*smap)[0xFB1D] = U_Hebrew;
  750|      1|  (*smap)[0xFB1E] = U_Hebrew;
  751|     11|  for (char32 c = 0xFB1F; c <= 0xFB28; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (751:27): [True: 10, False: 1]
  ------------------
  752|      1|  (*smap)[0xFB29] = U_Hebrew;
  753|     14|  for (char32 c = 0xFB2A; c <= 0xFB36; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (753:27): [True: 13, False: 1]
  ------------------
  754|      6|  for (char32 c = 0xFB38; c <= 0xFB3C; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (754:27): [True: 5, False: 1]
  ------------------
  755|      1|  (*smap)[0xFB3E] = U_Hebrew;
  756|      3|  for (char32 c = 0xFB40; c <= 0xFB41; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (756:27): [True: 2, False: 1]
  ------------------
  757|      3|  for (char32 c = 0xFB43; c <= 0xFB44; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (757:27): [True: 2, False: 1]
  ------------------
  758|     11|  for (char32 c = 0xFB46; c <= 0xFB4F; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (758:27): [True: 10, False: 1]
  ------------------
  759|      6|  for (char32 c = 0x0600; c <= 0x0604; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (759:27): [True: 5, False: 1]
  ------------------
  760|      4|  for (char32 c = 0x0606; c <= 0x0608; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (760:27): [True: 3, False: 1]
  ------------------
  761|      3|  for (char32 c = 0x0609; c <= 0x060A; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (761:27): [True: 2, False: 1]
  ------------------
  762|      1|  (*smap)[0x060B] = U_Arabic;
  763|      1|  (*smap)[0x060D] = U_Arabic;
  764|      3|  for (char32 c = 0x060E; c <= 0x060F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (764:27): [True: 2, False: 1]
  ------------------
  765|     12|  for (char32 c = 0x0610; c <= 0x061A; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (765:27): [True: 11, False: 1]
  ------------------
  766|      1|  (*smap)[0x061E] = U_Arabic;
  767|     33|  for (char32 c = 0x0620; c <= 0x063F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (767:27): [True: 32, False: 1]
  ------------------
  768|     11|  for (char32 c = 0x0641; c <= 0x064A; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (768:27): [True: 10, False: 1]
  ------------------
  769|     11|  for (char32 c = 0x0656; c <= 0x065F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (769:27): [True: 10, False: 1]
  ------------------
  770|     11|  for (char32 c = 0x0660; c <= 0x0669; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (770:27): [True: 10, False: 1]
  ------------------
  771|      5|  for (char32 c = 0x066A; c <= 0x066D; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (771:27): [True: 4, False: 1]
  ------------------
  772|      3|  for (char32 c = 0x066E; c <= 0x066F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (772:27): [True: 2, False: 1]
  ------------------
  773|    100|  for (char32 c = 0x0671; c <= 0x06D3; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (773:27): [True: 99, False: 1]
  ------------------
  774|      1|  (*smap)[0x06D4] = U_Arabic;
  775|      1|  (*smap)[0x06D5] = U_Arabic;
  776|      8|  for (char32 c = 0x06D6; c <= 0x06DC; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (776:27): [True: 7, False: 1]
  ------------------
  777|      1|  (*smap)[0x06DE] = U_Arabic;
  778|      7|  for (char32 c = 0x06DF; c <= 0x06E4; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (778:27): [True: 6, False: 1]
  ------------------
  779|      3|  for (char32 c = 0x06E5; c <= 0x06E6; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (779:27): [True: 2, False: 1]
  ------------------
  780|      3|  for (char32 c = 0x06E7; c <= 0x06E8; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (780:27): [True: 2, False: 1]
  ------------------
  781|      1|  (*smap)[0x06E9] = U_Arabic;
  782|      5|  for (char32 c = 0x06EA; c <= 0x06ED; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (782:27): [True: 4, False: 1]
  ------------------
  783|      3|  for (char32 c = 0x06EE; c <= 0x06EF; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (783:27): [True: 2, False: 1]
  ------------------
  784|     11|  for (char32 c = 0x06F0; c <= 0x06F9; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (784:27): [True: 10, False: 1]
  ------------------
  785|      4|  for (char32 c = 0x06FA; c <= 0x06FC; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (785:27): [True: 3, False: 1]
  ------------------
  786|      3|  for (char32 c = 0x06FD; c <= 0x06FE; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (786:27): [True: 2, False: 1]
  ------------------
  787|      1|  (*smap)[0x06FF] = U_Arabic;
  788|     49|  for (char32 c = 0x0750; c <= 0x077F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (788:27): [True: 48, False: 1]
  ------------------
  789|     22|  for (char32 c = 0x08A0; c <= 0x08B4; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (789:27): [True: 21, False: 1]
  ------------------
  790|      9|  for (char32 c = 0x08B6; c <= 0x08BD; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (790:27): [True: 8, False: 1]
  ------------------
  791|     15|  for (char32 c = 0x08D4; c <= 0x08E1; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (791:27): [True: 14, False: 1]
  ------------------
  792|     30|  for (char32 c = 0x08E3; c <= 0x08FF; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (792:27): [True: 29, False: 1]
  ------------------
  793|     99|  for (char32 c = 0xFB50; c <= 0xFBB1; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (793:27): [True: 98, False: 1]
  ------------------
  794|     17|  for (char32 c = 0xFBB2; c <= 0xFBC1; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (794:27): [True: 16, False: 1]
  ------------------
  795|    364|  for (char32 c = 0xFBD3; c <= 0xFD3D; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (795:27): [True: 363, False: 1]
  ------------------
  796|     65|  for (char32 c = 0xFD50; c <= 0xFD8F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (796:27): [True: 64, False: 1]
  ------------------
  797|     55|  for (char32 c = 0xFD92; c <= 0xFDC7; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (797:27): [True: 54, False: 1]
  ------------------
  798|     13|  for (char32 c = 0xFDF0; c <= 0xFDFB; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (798:27): [True: 12, False: 1]
  ------------------
  799|      1|  (*smap)[0xFDFC] = U_Arabic;
  800|      1|  (*smap)[0xFDFD] = U_Arabic;
  801|      6|  for (char32 c = 0xFE70; c <= 0xFE74; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (801:27): [True: 5, False: 1]
  ------------------
  802|    136|  for (char32 c = 0xFE76; c <= 0xFEFC; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (802:27): [True: 135, False: 1]
  ------------------
  803|     32|  for (char32 c = 0x10E60; c <= 0x10E7E; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (803:28): [True: 31, False: 1]
  ------------------
  804|      5|  for (char32 c = 0x1EE00; c <= 0x1EE03; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (804:28): [True: 4, False: 1]
  ------------------
  805|     28|  for (char32 c = 0x1EE05; c <= 0x1EE1F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (805:28): [True: 27, False: 1]
  ------------------
  806|      3|  for (char32 c = 0x1EE21; c <= 0x1EE22; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (806:28): [True: 2, False: 1]
  ------------------
  807|      1|  (*smap)[0x1EE24] = U_Arabic;
  808|      1|  (*smap)[0x1EE27] = U_Arabic;
  809|     11|  for (char32 c = 0x1EE29; c <= 0x1EE32; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (809:28): [True: 10, False: 1]
  ------------------
  810|      5|  for (char32 c = 0x1EE34; c <= 0x1EE37; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (810:28): [True: 4, False: 1]
  ------------------
  811|      1|  (*smap)[0x1EE39] = U_Arabic;
  812|      1|  (*smap)[0x1EE3B] = U_Arabic;
  813|      1|  (*smap)[0x1EE42] = U_Arabic;
  814|      1|  (*smap)[0x1EE47] = U_Arabic;
  815|      1|  (*smap)[0x1EE49] = U_Arabic;
  816|      1|  (*smap)[0x1EE4B] = U_Arabic;
  817|      4|  for (char32 c = 0x1EE4D; c <= 0x1EE4F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (817:28): [True: 3, False: 1]
  ------------------
  818|      3|  for (char32 c = 0x1EE51; c <= 0x1EE52; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (818:28): [True: 2, False: 1]
  ------------------
  819|      1|  (*smap)[0x1EE54] = U_Arabic;
  820|      1|  (*smap)[0x1EE57] = U_Arabic;
  821|      1|  (*smap)[0x1EE59] = U_Arabic;
  822|      1|  (*smap)[0x1EE5B] = U_Arabic;
  823|      1|  (*smap)[0x1EE5D] = U_Arabic;
  824|      1|  (*smap)[0x1EE5F] = U_Arabic;
  825|      3|  for (char32 c = 0x1EE61; c <= 0x1EE62; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (825:28): [True: 2, False: 1]
  ------------------
  826|      1|  (*smap)[0x1EE64] = U_Arabic;
  827|      5|  for (char32 c = 0x1EE67; c <= 0x1EE6A; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (827:28): [True: 4, False: 1]
  ------------------
  828|      8|  for (char32 c = 0x1EE6C; c <= 0x1EE72; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (828:28): [True: 7, False: 1]
  ------------------
  829|      5|  for (char32 c = 0x1EE74; c <= 0x1EE77; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (829:28): [True: 4, False: 1]
  ------------------
  830|      5|  for (char32 c = 0x1EE79; c <= 0x1EE7C; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (830:28): [True: 4, False: 1]
  ------------------
  831|      1|  (*smap)[0x1EE7E] = U_Arabic;
  832|     11|  for (char32 c = 0x1EE80; c <= 0x1EE89; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (832:28): [True: 10, False: 1]
  ------------------
  833|     18|  for (char32 c = 0x1EE8B; c <= 0x1EE9B; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (833:28): [True: 17, False: 1]
  ------------------
  834|      4|  for (char32 c = 0x1EEA1; c <= 0x1EEA3; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (834:28): [True: 3, False: 1]
  ------------------
  835|      6|  for (char32 c = 0x1EEA5; c <= 0x1EEA9; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (835:28): [True: 5, False: 1]
  ------------------
  836|     18|  for (char32 c = 0x1EEAB; c <= 0x1EEBB; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (836:28): [True: 17, False: 1]
  ------------------
  837|      3|  for (char32 c = 0x1EEF0; c <= 0x1EEF1; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (837:28): [True: 2, False: 1]
  ------------------
  838|     15|  for (char32 c = 0x0700; c <= 0x070D; ++c) (*smap)[c] = U_Syriac;
  ------------------
  |  Branch (838:27): [True: 14, False: 1]
  ------------------
  839|      1|  (*smap)[0x070F] = U_Syriac;
  840|      1|  (*smap)[0x0710] = U_Syriac;
  841|      1|  (*smap)[0x0711] = U_Syriac;
  842|     31|  for (char32 c = 0x0712; c <= 0x072F; ++c) (*smap)[c] = U_Syriac;
  ------------------
  |  Branch (842:27): [True: 30, False: 1]
  ------------------
  843|     28|  for (char32 c = 0x0730; c <= 0x074A; ++c) (*smap)[c] = U_Syriac;
  ------------------
  |  Branch (843:27): [True: 27, False: 1]
  ------------------
  844|      4|  for (char32 c = 0x074D; c <= 0x074F; ++c) (*smap)[c] = U_Syriac;
  ------------------
  |  Branch (844:27): [True: 3, False: 1]
  ------------------
  845|     39|  for (char32 c = 0x0780; c <= 0x07A5; ++c) (*smap)[c] = U_Thaana;
  ------------------
  |  Branch (845:27): [True: 38, False: 1]
  ------------------
  846|     12|  for (char32 c = 0x07A6; c <= 0x07B0; ++c) (*smap)[c] = U_Thaana;
  ------------------
  |  Branch (846:27): [True: 11, False: 1]
  ------------------
  847|      1|  (*smap)[0x07B1] = U_Thaana;
  848|      4|  for (char32 c = 0x0900; c <= 0x0902; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (848:27): [True: 3, False: 1]
  ------------------
  849|      1|  (*smap)[0x0903] = U_Devanagari;
  850|     55|  for (char32 c = 0x0904; c <= 0x0939; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (850:27): [True: 54, False: 1]
  ------------------
  851|      1|  (*smap)[0x093A] = U_Devanagari;
  852|      1|  (*smap)[0x093B] = U_Devanagari;
  853|      1|  (*smap)[0x093C] = U_Devanagari;
  854|      1|  (*smap)[0x093D] = U_Devanagari;
  855|      4|  for (char32 c = 0x093E; c <= 0x0940; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (855:27): [True: 3, False: 1]
  ------------------
  856|      9|  for (char32 c = 0x0941; c <= 0x0948; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (856:27): [True: 8, False: 1]
  ------------------
  857|      5|  for (char32 c = 0x0949; c <= 0x094C; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (857:27): [True: 4, False: 1]
  ------------------
  858|      1|  (*smap)[0x094D] = U_Devanagari;
  859|      3|  for (char32 c = 0x094E; c <= 0x094F; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (859:27): [True: 2, False: 1]
  ------------------
  860|      1|  (*smap)[0x0950] = U_Devanagari;
  861|      6|  for (char32 c = 0x0953; c <= 0x0957; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (861:27): [True: 5, False: 1]
  ------------------
  862|     11|  for (char32 c = 0x0958; c <= 0x0961; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (862:27): [True: 10, False: 1]
  ------------------
  863|      3|  for (char32 c = 0x0962; c <= 0x0963; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (863:27): [True: 2, False: 1]
  ------------------
  864|     11|  for (char32 c = 0x0966; c <= 0x096F; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (864:27): [True: 10, False: 1]
  ------------------
  865|      1|  (*smap)[0x0970] = U_Devanagari;
  866|      1|  (*smap)[0x0971] = U_Devanagari;
  867|     15|  for (char32 c = 0x0972; c <= 0x097F; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (867:27): [True: 14, False: 1]
  ------------------
  868|     19|  for (char32 c = 0xA8E0; c <= 0xA8F1; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (868:27): [True: 18, False: 1]
  ------------------
  869|      7|  for (char32 c = 0xA8F2; c <= 0xA8F7; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (869:27): [True: 6, False: 1]
  ------------------
  870|      4|  for (char32 c = 0xA8F8; c <= 0xA8FA; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (870:27): [True: 3, False: 1]
  ------------------
  871|      1|  (*smap)[0xA8FB] = U_Devanagari;
  872|      1|  (*smap)[0xA8FC] = U_Devanagari;
  873|      1|  (*smap)[0xA8FD] = U_Devanagari;
  874|      1|  (*smap)[0x0980] = U_Bengali;
  875|      1|  (*smap)[0x0981] = U_Bengali;
  876|      3|  for (char32 c = 0x0982; c <= 0x0983; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (876:27): [True: 2, False: 1]
  ------------------
  877|      9|  for (char32 c = 0x0985; c <= 0x098C; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (877:27): [True: 8, False: 1]
  ------------------
  878|      3|  for (char32 c = 0x098F; c <= 0x0990; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (878:27): [True: 2, False: 1]
  ------------------
  879|     23|  for (char32 c = 0x0993; c <= 0x09A8; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (879:27): [True: 22, False: 1]
  ------------------
  880|      8|  for (char32 c = 0x09AA; c <= 0x09B0; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (880:27): [True: 7, False: 1]
  ------------------
  881|      1|  (*smap)[0x09B2] = U_Bengali;
  882|      5|  for (char32 c = 0x09B6; c <= 0x09B9; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (882:27): [True: 4, False: 1]
  ------------------
  883|      1|  (*smap)[0x09BC] = U_Bengali;
  884|      1|  (*smap)[0x09BD] = U_Bengali;
  885|      4|  for (char32 c = 0x09BE; c <= 0x09C0; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (885:27): [True: 3, False: 1]
  ------------------
  886|      5|  for (char32 c = 0x09C1; c <= 0x09C4; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (886:27): [True: 4, False: 1]
  ------------------
  887|      3|  for (char32 c = 0x09C7; c <= 0x09C8; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (887:27): [True: 2, False: 1]
  ------------------
  888|      3|  for (char32 c = 0x09CB; c <= 0x09CC; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (888:27): [True: 2, False: 1]
  ------------------
  889|      1|  (*smap)[0x09CD] = U_Bengali;
  890|      1|  (*smap)[0x09CE] = U_Bengali;
  891|      1|  (*smap)[0x09D7] = U_Bengali;
  892|      3|  for (char32 c = 0x09DC; c <= 0x09DD; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (892:27): [True: 2, False: 1]
  ------------------
  893|      4|  for (char32 c = 0x09DF; c <= 0x09E1; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (893:27): [True: 3, False: 1]
  ------------------
  894|      3|  for (char32 c = 0x09E2; c <= 0x09E3; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (894:27): [True: 2, False: 1]
  ------------------
  895|     11|  for (char32 c = 0x09E6; c <= 0x09EF; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (895:27): [True: 10, False: 1]
  ------------------
  896|      3|  for (char32 c = 0x09F0; c <= 0x09F1; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (896:27): [True: 2, False: 1]
  ------------------
  897|      3|  for (char32 c = 0x09F2; c <= 0x09F3; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (897:27): [True: 2, False: 1]
  ------------------
  898|      7|  for (char32 c = 0x09F4; c <= 0x09F9; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (898:27): [True: 6, False: 1]
  ------------------
  899|      1|  (*smap)[0x09FA] = U_Bengali;
  900|      1|  (*smap)[0x09FB] = U_Bengali;
  901|      3|  for (char32 c = 0x0A01; c <= 0x0A02; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (901:27): [True: 2, False: 1]
  ------------------
  902|      1|  (*smap)[0x0A03] = U_Gurmukhi;
  903|      7|  for (char32 c = 0x0A05; c <= 0x0A0A; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (903:27): [True: 6, False: 1]
  ------------------
  904|      3|  for (char32 c = 0x0A0F; c <= 0x0A10; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (904:27): [True: 2, False: 1]
  ------------------
  905|     23|  for (char32 c = 0x0A13; c <= 0x0A28; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (905:27): [True: 22, False: 1]
  ------------------
  906|      8|  for (char32 c = 0x0A2A; c <= 0x0A30; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (906:27): [True: 7, False: 1]
  ------------------
  907|      3|  for (char32 c = 0x0A32; c <= 0x0A33; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (907:27): [True: 2, False: 1]
  ------------------
  908|      3|  for (char32 c = 0x0A35; c <= 0x0A36; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (908:27): [True: 2, False: 1]
  ------------------
  909|      3|  for (char32 c = 0x0A38; c <= 0x0A39; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (909:27): [True: 2, False: 1]
  ------------------
  910|      1|  (*smap)[0x0A3C] = U_Gurmukhi;
  911|      4|  for (char32 c = 0x0A3E; c <= 0x0A40; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (911:27): [True: 3, False: 1]
  ------------------
  912|      3|  for (char32 c = 0x0A41; c <= 0x0A42; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (912:27): [True: 2, False: 1]
  ------------------
  913|      3|  for (char32 c = 0x0A47; c <= 0x0A48; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (913:27): [True: 2, False: 1]
  ------------------
  914|      4|  for (char32 c = 0x0A4B; c <= 0x0A4D; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (914:27): [True: 3, False: 1]
  ------------------
  915|      1|  (*smap)[0x0A51] = U_Gurmukhi;
  916|      5|  for (char32 c = 0x0A59; c <= 0x0A5C; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (916:27): [True: 4, False: 1]
  ------------------
  917|      1|  (*smap)[0x0A5E] = U_Gurmukhi;
  918|     11|  for (char32 c = 0x0A66; c <= 0x0A6F; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (918:27): [True: 10, False: 1]
  ------------------
  919|      3|  for (char32 c = 0x0A70; c <= 0x0A71; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (919:27): [True: 2, False: 1]
  ------------------
  920|      4|  for (char32 c = 0x0A72; c <= 0x0A74; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (920:27): [True: 3, False: 1]
  ------------------
  921|      1|  (*smap)[0x0A75] = U_Gurmukhi;
  922|      3|  for (char32 c = 0x0A81; c <= 0x0A82; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (922:27): [True: 2, False: 1]
  ------------------
  923|      1|  (*smap)[0x0A83] = U_Gujarati;
  924|     10|  for (char32 c = 0x0A85; c <= 0x0A8D; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (924:27): [True: 9, False: 1]
  ------------------
  925|      4|  for (char32 c = 0x0A8F; c <= 0x0A91; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (925:27): [True: 3, False: 1]
  ------------------
  926|     23|  for (char32 c = 0x0A93; c <= 0x0AA8; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (926:27): [True: 22, False: 1]
  ------------------
  927|      8|  for (char32 c = 0x0AAA; c <= 0x0AB0; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (927:27): [True: 7, False: 1]
  ------------------
  928|      3|  for (char32 c = 0x0AB2; c <= 0x0AB3; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (928:27): [True: 2, False: 1]
  ------------------
  929|      6|  for (char32 c = 0x0AB5; c <= 0x0AB9; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (929:27): [True: 5, False: 1]
  ------------------
  930|      1|  (*smap)[0x0ABC] = U_Gujarati;
  931|      1|  (*smap)[0x0ABD] = U_Gujarati;
  932|      4|  for (char32 c = 0x0ABE; c <= 0x0AC0; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (932:27): [True: 3, False: 1]
  ------------------
  933|      6|  for (char32 c = 0x0AC1; c <= 0x0AC5; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (933:27): [True: 5, False: 1]
  ------------------
  934|      3|  for (char32 c = 0x0AC7; c <= 0x0AC8; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (934:27): [True: 2, False: 1]
  ------------------
  935|      1|  (*smap)[0x0AC9] = U_Gujarati;
  936|      3|  for (char32 c = 0x0ACB; c <= 0x0ACC; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (936:27): [True: 2, False: 1]
  ------------------
  937|      1|  (*smap)[0x0ACD] = U_Gujarati;
  938|      1|  (*smap)[0x0AD0] = U_Gujarati;
  939|      3|  for (char32 c = 0x0AE0; c <= 0x0AE1; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (939:27): [True: 2, False: 1]
  ------------------
  940|      3|  for (char32 c = 0x0AE2; c <= 0x0AE3; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (940:27): [True: 2, False: 1]
  ------------------
  941|     11|  for (char32 c = 0x0AE6; c <= 0x0AEF; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (941:27): [True: 10, False: 1]
  ------------------
  942|      1|  (*smap)[0x0AF0] = U_Gujarati;
  943|      1|  (*smap)[0x0AF1] = U_Gujarati;
  944|      1|  (*smap)[0x0AF9] = U_Gujarati;
  945|      1|  (*smap)[0x0B01] = U_Oriya;
  946|      3|  for (char32 c = 0x0B02; c <= 0x0B03; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (946:27): [True: 2, False: 1]
  ------------------
  947|      9|  for (char32 c = 0x0B05; c <= 0x0B0C; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (947:27): [True: 8, False: 1]
  ------------------
  948|      3|  for (char32 c = 0x0B0F; c <= 0x0B10; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (948:27): [True: 2, False: 1]
  ------------------
  949|     23|  for (char32 c = 0x0B13; c <= 0x0B28; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (949:27): [True: 22, False: 1]
  ------------------
  950|      8|  for (char32 c = 0x0B2A; c <= 0x0B30; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (950:27): [True: 7, False: 1]
  ------------------
  951|      3|  for (char32 c = 0x0B32; c <= 0x0B33; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (951:27): [True: 2, False: 1]
  ------------------
  952|      6|  for (char32 c = 0x0B35; c <= 0x0B39; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (952:27): [True: 5, False: 1]
  ------------------
  953|      1|  (*smap)[0x0B3C] = U_Oriya;
  954|      1|  (*smap)[0x0B3D] = U_Oriya;
  955|      1|  (*smap)[0x0B3E] = U_Oriya;
  956|      1|  (*smap)[0x0B3F] = U_Oriya;
  957|      1|  (*smap)[0x0B40] = U_Oriya;
  958|      5|  for (char32 c = 0x0B41; c <= 0x0B44; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (958:27): [True: 4, False: 1]
  ------------------
  959|      3|  for (char32 c = 0x0B47; c <= 0x0B48; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (959:27): [True: 2, False: 1]
  ------------------
  960|      3|  for (char32 c = 0x0B4B; c <= 0x0B4C; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (960:27): [True: 2, False: 1]
  ------------------
  961|      1|  (*smap)[0x0B4D] = U_Oriya;
  962|      1|  (*smap)[0x0B56] = U_Oriya;
  963|      1|  (*smap)[0x0B57] = U_Oriya;
  964|      3|  for (char32 c = 0x0B5C; c <= 0x0B5D; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (964:27): [True: 2, False: 1]
  ------------------
  965|      4|  for (char32 c = 0x0B5F; c <= 0x0B61; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (965:27): [True: 3, False: 1]
  ------------------
  966|      3|  for (char32 c = 0x0B62; c <= 0x0B63; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (966:27): [True: 2, False: 1]
  ------------------
  967|     11|  for (char32 c = 0x0B66; c <= 0x0B6F; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (967:27): [True: 10, False: 1]
  ------------------
  968|      1|  (*smap)[0x0B70] = U_Oriya;
  969|      1|  (*smap)[0x0B71] = U_Oriya;
  970|      7|  for (char32 c = 0x0B72; c <= 0x0B77; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (970:27): [True: 6, False: 1]
  ------------------
  971|      1|  (*smap)[0x0B82] = U_Tamil;
  972|      1|  (*smap)[0x0B83] = U_Tamil;
  973|      7|  for (char32 c = 0x0B85; c <= 0x0B8A; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (973:27): [True: 6, False: 1]
  ------------------
  974|      4|  for (char32 c = 0x0B8E; c <= 0x0B90; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (974:27): [True: 3, False: 1]
  ------------------
  975|      5|  for (char32 c = 0x0B92; c <= 0x0B95; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (975:27): [True: 4, False: 1]
  ------------------
  976|      3|  for (char32 c = 0x0B99; c <= 0x0B9A; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (976:27): [True: 2, False: 1]
  ------------------
  977|      1|  (*smap)[0x0B9C] = U_Tamil;
  978|      3|  for (char32 c = 0x0B9E; c <= 0x0B9F; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (978:27): [True: 2, False: 1]
  ------------------
  979|      3|  for (char32 c = 0x0BA3; c <= 0x0BA4; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (979:27): [True: 2, False: 1]
  ------------------
  980|      4|  for (char32 c = 0x0BA8; c <= 0x0BAA; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (980:27): [True: 3, False: 1]
  ------------------
  981|     13|  for (char32 c = 0x0BAE; c <= 0x0BB9; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (981:27): [True: 12, False: 1]
  ------------------
  982|      3|  for (char32 c = 0x0BBE; c <= 0x0BBF; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (982:27): [True: 2, False: 1]
  ------------------
  983|      1|  (*smap)[0x0BC0] = U_Tamil;
  984|      3|  for (char32 c = 0x0BC1; c <= 0x0BC2; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (984:27): [True: 2, False: 1]
  ------------------
  985|      4|  for (char32 c = 0x0BC6; c <= 0x0BC8; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (985:27): [True: 3, False: 1]
  ------------------
  986|      4|  for (char32 c = 0x0BCA; c <= 0x0BCC; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (986:27): [True: 3, False: 1]
  ------------------
  987|      1|  (*smap)[0x0BCD] = U_Tamil;
  988|      1|  (*smap)[0x0BD0] = U_Tamil;
  989|      1|  (*smap)[0x0BD7] = U_Tamil;
  990|     11|  for (char32 c = 0x0BE6; c <= 0x0BEF; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (990:27): [True: 10, False: 1]
  ------------------
  991|      4|  for (char32 c = 0x0BF0; c <= 0x0BF2; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (991:27): [True: 3, False: 1]
  ------------------
  992|      7|  for (char32 c = 0x0BF3; c <= 0x0BF8; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (992:27): [True: 6, False: 1]
  ------------------
  993|      1|  (*smap)[0x0BF9] = U_Tamil;
  994|      1|  (*smap)[0x0BFA] = U_Tamil;
  995|      1|  (*smap)[0x0C00] = U_Telugu;
  996|      4|  for (char32 c = 0x0C01; c <= 0x0C03; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (996:27): [True: 3, False: 1]
  ------------------
  997|      9|  for (char32 c = 0x0C05; c <= 0x0C0C; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (997:27): [True: 8, False: 1]
  ------------------
  998|      4|  for (char32 c = 0x0C0E; c <= 0x0C10; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (998:27): [True: 3, False: 1]
  ------------------
  999|     24|  for (char32 c = 0x0C12; c <= 0x0C28; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (999:27): [True: 23, False: 1]
  ------------------
 1000|     17|  for (char32 c = 0x0C2A; c <= 0x0C39; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1000:27): [True: 16, False: 1]
  ------------------
 1001|      1|  (*smap)[0x0C3D] = U_Telugu;
 1002|      4|  for (char32 c = 0x0C3E; c <= 0x0C40; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1002:27): [True: 3, False: 1]
  ------------------
 1003|      5|  for (char32 c = 0x0C41; c <= 0x0C44; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1003:27): [True: 4, False: 1]
  ------------------
 1004|      4|  for (char32 c = 0x0C46; c <= 0x0C48; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1004:27): [True: 3, False: 1]
  ------------------
 1005|      5|  for (char32 c = 0x0C4A; c <= 0x0C4D; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1005:27): [True: 4, False: 1]
  ------------------
 1006|      3|  for (char32 c = 0x0C55; c <= 0x0C56; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1006:27): [True: 2, False: 1]
  ------------------
 1007|      4|  for (char32 c = 0x0C58; c <= 0x0C5A; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1007:27): [True: 3, False: 1]
  ------------------
 1008|      3|  for (char32 c = 0x0C60; c <= 0x0C61; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1008:27): [True: 2, False: 1]
  ------------------
 1009|      3|  for (char32 c = 0x0C62; c <= 0x0C63; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1009:27): [True: 2, False: 1]
  ------------------
 1010|     11|  for (char32 c = 0x0C66; c <= 0x0C6F; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1010:27): [True: 10, False: 1]
  ------------------
 1011|      8|  for (char32 c = 0x0C78; c <= 0x0C7E; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1011:27): [True: 7, False: 1]
  ------------------
 1012|      1|  (*smap)[0x0C7F] = U_Telugu;
 1013|      1|  (*smap)[0x0C80] = U_Kannada;
 1014|      1|  (*smap)[0x0C81] = U_Kannada;
 1015|      3|  for (char32 c = 0x0C82; c <= 0x0C83; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1015:27): [True: 2, False: 1]
  ------------------
 1016|      9|  for (char32 c = 0x0C85; c <= 0x0C8C; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1016:27): [True: 8, False: 1]
  ------------------
 1017|      4|  for (char32 c = 0x0C8E; c <= 0x0C90; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1017:27): [True: 3, False: 1]
  ------------------
 1018|     24|  for (char32 c = 0x0C92; c <= 0x0CA8; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1018:27): [True: 23, False: 1]
  ------------------
 1019|     11|  for (char32 c = 0x0CAA; c <= 0x0CB3; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1019:27): [True: 10, False: 1]
  ------------------
 1020|      6|  for (char32 c = 0x0CB5; c <= 0x0CB9; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1020:27): [True: 5, False: 1]
  ------------------
 1021|      1|  (*smap)[0x0CBC] = U_Kannada;
 1022|      1|  (*smap)[0x0CBD] = U_Kannada;
 1023|      1|  (*smap)[0x0CBE] = U_Kannada;
 1024|      1|  (*smap)[0x0CBF] = U_Kannada;
 1025|      6|  for (char32 c = 0x0CC0; c <= 0x0CC4; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1025:27): [True: 5, False: 1]
  ------------------
 1026|      1|  (*smap)[0x0CC6] = U_Kannada;
 1027|      3|  for (char32 c = 0x0CC7; c <= 0x0CC8; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1027:27): [True: 2, False: 1]
  ------------------
 1028|      3|  for (char32 c = 0x0CCA; c <= 0x0CCB; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1028:27): [True: 2, False: 1]
  ------------------
 1029|      3|  for (char32 c = 0x0CCC; c <= 0x0CCD; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1029:27): [True: 2, False: 1]
  ------------------
 1030|      3|  for (char32 c = 0x0CD5; c <= 0x0CD6; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1030:27): [True: 2, False: 1]
  ------------------
 1031|      1|  (*smap)[0x0CDE] = U_Kannada;
 1032|      3|  for (char32 c = 0x0CE0; c <= 0x0CE1; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1032:27): [True: 2, False: 1]
  ------------------
 1033|      3|  for (char32 c = 0x0CE2; c <= 0x0CE3; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1033:27): [True: 2, False: 1]
  ------------------
 1034|     11|  for (char32 c = 0x0CE6; c <= 0x0CEF; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1034:27): [True: 10, False: 1]
  ------------------
 1035|      3|  for (char32 c = 0x0CF1; c <= 0x0CF2; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1035:27): [True: 2, False: 1]
  ------------------
 1036|      1|  (*smap)[0x0D01] = U_Malayalam;
 1037|      3|  for (char32 c = 0x0D02; c <= 0x0D03; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1037:27): [True: 2, False: 1]
  ------------------
 1038|      9|  for (char32 c = 0x0D05; c <= 0x0D0C; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1038:27): [True: 8, False: 1]
  ------------------
 1039|      4|  for (char32 c = 0x0D0E; c <= 0x0D10; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1039:27): [True: 3, False: 1]
  ------------------
 1040|     42|  for (char32 c = 0x0D12; c <= 0x0D3A; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1040:27): [True: 41, False: 1]
  ------------------
 1041|      1|  (*smap)[0x0D3D] = U_Malayalam;
 1042|      4|  for (char32 c = 0x0D3E; c <= 0x0D40; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1042:27): [True: 3, False: 1]
  ------------------
 1043|      5|  for (char32 c = 0x0D41; c <= 0x0D44; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1043:27): [True: 4, False: 1]
  ------------------
 1044|      4|  for (char32 c = 0x0D46; c <= 0x0D48; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1044:27): [True: 3, False: 1]
  ------------------
 1045|      4|  for (char32 c = 0x0D4A; c <= 0x0D4C; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1045:27): [True: 3, False: 1]
  ------------------
 1046|      1|  (*smap)[0x0D4D] = U_Malayalam;
 1047|      1|  (*smap)[0x0D4E] = U_Malayalam;
 1048|      1|  (*smap)[0x0D4F] = U_Malayalam;
 1049|      4|  for (char32 c = 0x0D54; c <= 0x0D56; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1049:27): [True: 3, False: 1]
  ------------------
 1050|      1|  (*smap)[0x0D57] = U_Malayalam;
 1051|      8|  for (char32 c = 0x0D58; c <= 0x0D5E; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1051:27): [True: 7, False: 1]
  ------------------
 1052|      4|  for (char32 c = 0x0D5F; c <= 0x0D61; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1052:27): [True: 3, False: 1]
  ------------------
 1053|      3|  for (char32 c = 0x0D62; c <= 0x0D63; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1053:27): [True: 2, False: 1]
  ------------------
 1054|     11|  for (char32 c = 0x0D66; c <= 0x0D6F; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1054:27): [True: 10, False: 1]
  ------------------
 1055|     10|  for (char32 c = 0x0D70; c <= 0x0D78; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1055:27): [True: 9, False: 1]
  ------------------
 1056|      1|  (*smap)[0x0D79] = U_Malayalam;
 1057|      7|  for (char32 c = 0x0D7A; c <= 0x0D7F; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1057:27): [True: 6, False: 1]
  ------------------
 1058|      3|  for (char32 c = 0x0D82; c <= 0x0D83; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1058:27): [True: 2, False: 1]
  ------------------
 1059|     19|  for (char32 c = 0x0D85; c <= 0x0D96; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1059:27): [True: 18, False: 1]
  ------------------
 1060|     25|  for (char32 c = 0x0D9A; c <= 0x0DB1; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1060:27): [True: 24, False: 1]
  ------------------
 1061|     10|  for (char32 c = 0x0DB3; c <= 0x0DBB; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1061:27): [True: 9, False: 1]
  ------------------
 1062|      1|  (*smap)[0x0DBD] = U_Sinhala;
 1063|      8|  for (char32 c = 0x0DC0; c <= 0x0DC6; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1063:27): [True: 7, False: 1]
  ------------------
 1064|      1|  (*smap)[0x0DCA] = U_Sinhala;
 1065|      4|  for (char32 c = 0x0DCF; c <= 0x0DD1; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1065:27): [True: 3, False: 1]
  ------------------
 1066|      4|  for (char32 c = 0x0DD2; c <= 0x0DD4; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1066:27): [True: 3, False: 1]
  ------------------
 1067|      1|  (*smap)[0x0DD6] = U_Sinhala;
 1068|      9|  for (char32 c = 0x0DD8; c <= 0x0DDF; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1068:27): [True: 8, False: 1]
  ------------------
 1069|     11|  for (char32 c = 0x0DE6; c <= 0x0DEF; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1069:27): [True: 10, False: 1]
  ------------------
 1070|      3|  for (char32 c = 0x0DF2; c <= 0x0DF3; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1070:27): [True: 2, False: 1]
  ------------------
 1071|      1|  (*smap)[0x0DF4] = U_Sinhala;
 1072|     21|  for (char32 c = 0x111E1; c <= 0x111F4; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1072:28): [True: 20, False: 1]
  ------------------
 1073|     49|  for (char32 c = 0x0E01; c <= 0x0E30; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1073:27): [True: 48, False: 1]
  ------------------
 1074|      1|  (*smap)[0x0E31] = U_Thai;
 1075|      3|  for (char32 c = 0x0E32; c <= 0x0E33; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1075:27): [True: 2, False: 1]
  ------------------
 1076|      8|  for (char32 c = 0x0E34; c <= 0x0E3A; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1076:27): [True: 7, False: 1]
  ------------------
 1077|      7|  for (char32 c = 0x0E40; c <= 0x0E45; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1077:27): [True: 6, False: 1]
  ------------------
 1078|      1|  (*smap)[0x0E46] = U_Thai;
 1079|      9|  for (char32 c = 0x0E47; c <= 0x0E4E; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1079:27): [True: 8, False: 1]
  ------------------
 1080|      1|  (*smap)[0x0E4F] = U_Thai;
 1081|     11|  for (char32 c = 0x0E50; c <= 0x0E59; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1081:27): [True: 10, False: 1]
  ------------------
 1082|      3|  for (char32 c = 0x0E5A; c <= 0x0E5B; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1082:27): [True: 2, False: 1]
  ------------------
 1083|      3|  for (char32 c = 0x0E81; c <= 0x0E82; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1083:27): [True: 2, False: 1]
  ------------------
 1084|      1|  (*smap)[0x0E84] = U_Lao;
 1085|      3|  for (char32 c = 0x0E87; c <= 0x0E88; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1085:27): [True: 2, False: 1]
  ------------------
 1086|      1|  (*smap)[0x0E8A] = U_Lao;
 1087|      1|  (*smap)[0x0E8D] = U_Lao;
 1088|      5|  for (char32 c = 0x0E94; c <= 0x0E97; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1088:27): [True: 4, False: 1]
  ------------------
 1089|      8|  for (char32 c = 0x0E99; c <= 0x0E9F; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1089:27): [True: 7, False: 1]
  ------------------
 1090|      4|  for (char32 c = 0x0EA1; c <= 0x0EA3; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1090:27): [True: 3, False: 1]
  ------------------
 1091|      1|  (*smap)[0x0EA5] = U_Lao;
 1092|      1|  (*smap)[0x0EA7] = U_Lao;
 1093|      3|  for (char32 c = 0x0EAA; c <= 0x0EAB; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1093:27): [True: 2, False: 1]
  ------------------
 1094|      5|  for (char32 c = 0x0EAD; c <= 0x0EB0; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1094:27): [True: 4, False: 1]
  ------------------
 1095|      1|  (*smap)[0x0EB1] = U_Lao;
 1096|      3|  for (char32 c = 0x0EB2; c <= 0x0EB3; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1096:27): [True: 2, False: 1]
  ------------------
 1097|      7|  for (char32 c = 0x0EB4; c <= 0x0EB9; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1097:27): [True: 6, False: 1]
  ------------------
 1098|      3|  for (char32 c = 0x0EBB; c <= 0x0EBC; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1098:27): [True: 2, False: 1]
  ------------------
 1099|      1|  (*smap)[0x0EBD] = U_Lao;
 1100|      6|  for (char32 c = 0x0EC0; c <= 0x0EC4; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1100:27): [True: 5, False: 1]
  ------------------
 1101|      1|  (*smap)[0x0EC6] = U_Lao;
 1102|      7|  for (char32 c = 0x0EC8; c <= 0x0ECD; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1102:27): [True: 6, False: 1]
  ------------------
 1103|     11|  for (char32 c = 0x0ED0; c <= 0x0ED9; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1103:27): [True: 10, False: 1]
  ------------------
 1104|      5|  for (char32 c = 0x0EDC; c <= 0x0EDF; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1104:27): [True: 4, False: 1]
  ------------------
 1105|      1|  (*smap)[0x0F00] = U_Tibetan;
 1106|      4|  for (char32 c = 0x0F01; c <= 0x0F03; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1106:27): [True: 3, False: 1]
  ------------------
 1107|     16|  for (char32 c = 0x0F04; c <= 0x0F12; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1107:27): [True: 15, False: 1]
  ------------------
 1108|      1|  (*smap)[0x0F13] = U_Tibetan;
 1109|      1|  (*smap)[0x0F14] = U_Tibetan;
 1110|      4|  for (char32 c = 0x0F15; c <= 0x0F17; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1110:27): [True: 3, False: 1]
  ------------------
 1111|      3|  for (char32 c = 0x0F18; c <= 0x0F19; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1111:27): [True: 2, False: 1]
  ------------------
 1112|      7|  for (char32 c = 0x0F1A; c <= 0x0F1F; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1112:27): [True: 6, False: 1]
  ------------------
 1113|     11|  for (char32 c = 0x0F20; c <= 0x0F29; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1113:27): [True: 10, False: 1]
  ------------------
 1114|     11|  for (char32 c = 0x0F2A; c <= 0x0F33; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1114:27): [True: 10, False: 1]
  ------------------
 1115|      1|  (*smap)[0x0F34] = U_Tibetan;
 1116|      1|  (*smap)[0x0F35] = U_Tibetan;
 1117|      1|  (*smap)[0x0F36] = U_Tibetan;
 1118|      1|  (*smap)[0x0F37] = U_Tibetan;
 1119|      1|  (*smap)[0x0F38] = U_Tibetan;
 1120|      1|  (*smap)[0x0F39] = U_Tibetan;
 1121|      1|  (*smap)[0x0F3A] = U_Tibetan;
 1122|      1|  (*smap)[0x0F3B] = U_Tibetan;
 1123|      1|  (*smap)[0x0F3C] = U_Tibetan;
 1124|      1|  (*smap)[0x0F3D] = U_Tibetan;
 1125|      3|  for (char32 c = 0x0F3E; c <= 0x0F3F; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1125:27): [True: 2, False: 1]
  ------------------
 1126|      9|  for (char32 c = 0x0F40; c <= 0x0F47; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1126:27): [True: 8, False: 1]
  ------------------
 1127|     37|  for (char32 c = 0x0F49; c <= 0x0F6C; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1127:27): [True: 36, False: 1]
  ------------------
 1128|     15|  for (char32 c = 0x0F71; c <= 0x0F7E; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1128:27): [True: 14, False: 1]
  ------------------
 1129|      1|  (*smap)[0x0F7F] = U_Tibetan;
 1130|      6|  for (char32 c = 0x0F80; c <= 0x0F84; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1130:27): [True: 5, False: 1]
  ------------------
 1131|      1|  (*smap)[0x0F85] = U_Tibetan;
 1132|      3|  for (char32 c = 0x0F86; c <= 0x0F87; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1132:27): [True: 2, False: 1]
  ------------------
 1133|      6|  for (char32 c = 0x0F88; c <= 0x0F8C; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1133:27): [True: 5, False: 1]
  ------------------
 1134|     12|  for (char32 c = 0x0F8D; c <= 0x0F97; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1134:27): [True: 11, False: 1]
  ------------------
 1135|     37|  for (char32 c = 0x0F99; c <= 0x0FBC; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1135:27): [True: 36, False: 1]
  ------------------
 1136|      9|  for (char32 c = 0x0FBE; c <= 0x0FC5; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1136:27): [True: 8, False: 1]
  ------------------
 1137|      1|  (*smap)[0x0FC6] = U_Tibetan;
 1138|      7|  for (char32 c = 0x0FC7; c <= 0x0FCC; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1138:27): [True: 6, False: 1]
  ------------------
 1139|      3|  for (char32 c = 0x0FCE; c <= 0x0FCF; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1139:27): [True: 2, False: 1]
  ------------------
 1140|      6|  for (char32 c = 0x0FD0; c <= 0x0FD4; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1140:27): [True: 5, False: 1]
  ------------------
 1141|      3|  for (char32 c = 0x0FD9; c <= 0x0FDA; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1141:27): [True: 2, False: 1]
  ------------------
 1142|     44|  for (char32 c = 0x1000; c <= 0x102A; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1142:27): [True: 43, False: 1]
  ------------------
 1143|      3|  for (char32 c = 0x102B; c <= 0x102C; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1143:27): [True: 2, False: 1]
  ------------------
 1144|      5|  for (char32 c = 0x102D; c <= 0x1030; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1144:27): [True: 4, False: 1]
  ------------------
 1145|      1|  (*smap)[0x1031] = U_Myanmar;
 1146|      7|  for (char32 c = 0x1032; c <= 0x1037; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1146:27): [True: 6, False: 1]
  ------------------
 1147|      1|  (*smap)[0x1038] = U_Myanmar;
 1148|      3|  for (char32 c = 0x1039; c <= 0x103A; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1148:27): [True: 2, False: 1]
  ------------------
 1149|      3|  for (char32 c = 0x103B; c <= 0x103C; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1149:27): [True: 2, False: 1]
  ------------------
 1150|      3|  for (char32 c = 0x103D; c <= 0x103E; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1150:27): [True: 2, False: 1]
  ------------------
 1151|      1|  (*smap)[0x103F] = U_Myanmar;
 1152|     11|  for (char32 c = 0x1040; c <= 0x1049; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1152:27): [True: 10, False: 1]
  ------------------
 1153|      7|  for (char32 c = 0x104A; c <= 0x104F; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1153:27): [True: 6, False: 1]
  ------------------
 1154|      7|  for (char32 c = 0x1050; c <= 0x1055; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1154:27): [True: 6, False: 1]
  ------------------
 1155|      3|  for (char32 c = 0x1056; c <= 0x1057; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1155:27): [True: 2, False: 1]
  ------------------
 1156|      3|  for (char32 c = 0x1058; c <= 0x1059; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1156:27): [True: 2, False: 1]
  ------------------
 1157|      5|  for (char32 c = 0x105A; c <= 0x105D; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1157:27): [True: 4, False: 1]
  ------------------
 1158|      4|  for (char32 c = 0x105E; c <= 0x1060; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1158:27): [True: 3, False: 1]
  ------------------
 1159|      1|  (*smap)[0x1061] = U_Myanmar;
 1160|      4|  for (char32 c = 0x1062; c <= 0x1064; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1160:27): [True: 3, False: 1]
  ------------------
 1161|      3|  for (char32 c = 0x1065; c <= 0x1066; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1161:27): [True: 2, False: 1]
  ------------------
 1162|      8|  for (char32 c = 0x1067; c <= 0x106D; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1162:27): [True: 7, False: 1]
  ------------------
 1163|      4|  for (char32 c = 0x106E; c <= 0x1070; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1163:27): [True: 3, False: 1]
  ------------------
 1164|      5|  for (char32 c = 0x1071; c <= 0x1074; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1164:27): [True: 4, False: 1]
  ------------------
 1165|     14|  for (char32 c = 0x1075; c <= 0x1081; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1165:27): [True: 13, False: 1]
  ------------------
 1166|      1|  (*smap)[0x1082] = U_Myanmar;
 1167|      3|  for (char32 c = 0x1083; c <= 0x1084; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1167:27): [True: 2, False: 1]
  ------------------
 1168|      3|  for (char32 c = 0x1085; c <= 0x1086; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1168:27): [True: 2, False: 1]
  ------------------
 1169|      7|  for (char32 c = 0x1087; c <= 0x108C; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1169:27): [True: 6, False: 1]
  ------------------
 1170|      1|  (*smap)[0x108D] = U_Myanmar;
 1171|      1|  (*smap)[0x108E] = U_Myanmar;
 1172|      1|  (*smap)[0x108F] = U_Myanmar;
 1173|     11|  for (char32 c = 0x1090; c <= 0x1099; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1173:27): [True: 10, False: 1]
  ------------------
 1174|      4|  for (char32 c = 0x109A; c <= 0x109C; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1174:27): [True: 3, False: 1]
  ------------------
 1175|      1|  (*smap)[0x109D] = U_Myanmar;
 1176|      3|  for (char32 c = 0x109E; c <= 0x109F; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1176:27): [True: 2, False: 1]
  ------------------
 1177|      6|  for (char32 c = 0xA9E0; c <= 0xA9E4; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1177:27): [True: 5, False: 1]
  ------------------
 1178|      1|  (*smap)[0xA9E5] = U_Myanmar;
 1179|      1|  (*smap)[0xA9E6] = U_Myanmar;
 1180|     10|  for (char32 c = 0xA9E7; c <= 0xA9EF; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1180:27): [True: 9, False: 1]
  ------------------
 1181|     11|  for (char32 c = 0xA9F0; c <= 0xA9F9; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1181:27): [True: 10, False: 1]
  ------------------
 1182|      6|  for (char32 c = 0xA9FA; c <= 0xA9FE; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1182:27): [True: 5, False: 1]
  ------------------
 1183|     17|  for (char32 c = 0xAA60; c <= 0xAA6F; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1183:27): [True: 16, False: 1]
  ------------------
 1184|      1|  (*smap)[0xAA70] = U_Myanmar;
 1185|      7|  for (char32 c = 0xAA71; c <= 0xAA76; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1185:27): [True: 6, False: 1]
  ------------------
 1186|      4|  for (char32 c = 0xAA77; c <= 0xAA79; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1186:27): [True: 3, False: 1]
  ------------------
 1187|      1|  (*smap)[0xAA7A] = U_Myanmar;
 1188|      1|  (*smap)[0xAA7B] = U_Myanmar;
 1189|      1|  (*smap)[0xAA7C] = U_Myanmar;
 1190|      1|  (*smap)[0xAA7D] = U_Myanmar;
 1191|      3|  for (char32 c = 0xAA7E; c <= 0xAA7F; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1191:27): [True: 2, False: 1]
  ------------------
 1192|     39|  for (char32 c = 0x10A0; c <= 0x10C5; ++c) (*smap)[c] = U_Georgian;
  ------------------
  |  Branch (1192:27): [True: 38, False: 1]
  ------------------
 1193|      1|  (*smap)[0x10C7] = U_Georgian;
 1194|      1|  (*smap)[0x10CD] = U_Georgian;
 1195|     44|  for (char32 c = 0x10D0; c <= 0x10FA; ++c) (*smap)[c] = U_Georgian;
  ------------------
  |  Branch (1195:27): [True: 43, False: 1]
  ------------------
 1196|      1|  (*smap)[0x10FC] = U_Georgian;
 1197|      4|  for (char32 c = 0x10FD; c <= 0x10FF; ++c) (*smap)[c] = U_Georgian;
  ------------------
  |  Branch (1197:27): [True: 3, False: 1]
  ------------------
 1198|     39|  for (char32 c = 0x2D00; c <= 0x2D25; ++c) (*smap)[c] = U_Georgian;
  ------------------
  |  Branch (1198:27): [True: 38, False: 1]
  ------------------
 1199|      1|  (*smap)[0x2D27] = U_Georgian;
 1200|      1|  (*smap)[0x2D2D] = U_Georgian;
 1201|    257|  for (char32 c = 0x1100; c <= 0x11FF; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1201:27): [True: 256, False: 1]
  ------------------
 1202|      3|  for (char32 c = 0x302E; c <= 0x302F; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1202:27): [True: 2, False: 1]
  ------------------
 1203|     95|  for (char32 c = 0x3131; c <= 0x318E; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1203:27): [True: 94, False: 1]
  ------------------
 1204|     32|  for (char32 c = 0x3200; c <= 0x321E; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1204:27): [True: 31, False: 1]
  ------------------
 1205|     32|  for (char32 c = 0x3260; c <= 0x327E; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1205:27): [True: 31, False: 1]
  ------------------
 1206|     30|  for (char32 c = 0xA960; c <= 0xA97C; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1206:27): [True: 29, False: 1]
  ------------------
 1207|  11.1k|  for (char32 c = 0xAC00; c <= 0xD7A3; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1207:27): [True: 11.1k, False: 1]
  ------------------
 1208|     24|  for (char32 c = 0xD7B0; c <= 0xD7C6; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1208:27): [True: 23, False: 1]
  ------------------
 1209|     50|  for (char32 c = 0xD7CB; c <= 0xD7FB; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1209:27): [True: 49, False: 1]
  ------------------
 1210|     32|  for (char32 c = 0xFFA0; c <= 0xFFBE; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1210:27): [True: 31, False: 1]
  ------------------
 1211|      7|  for (char32 c = 0xFFC2; c <= 0xFFC7; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1211:27): [True: 6, False: 1]
  ------------------
 1212|      7|  for (char32 c = 0xFFCA; c <= 0xFFCF; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1212:27): [True: 6, False: 1]
  ------------------
 1213|      7|  for (char32 c = 0xFFD2; c <= 0xFFD7; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1213:27): [True: 6, False: 1]
  ------------------
 1214|      4|  for (char32 c = 0xFFDA; c <= 0xFFDC; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1214:27): [True: 3, False: 1]
  ------------------
 1215|     74|  for (char32 c = 0x1200; c <= 0x1248; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1215:27): [True: 73, False: 1]
  ------------------
 1216|      5|  for (char32 c = 0x124A; c <= 0x124D; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1216:27): [True: 4, False: 1]
  ------------------
 1217|      8|  for (char32 c = 0x1250; c <= 0x1256; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1217:27): [True: 7, False: 1]
  ------------------
 1218|      1|  (*smap)[0x1258] = U_Ethiopic;
 1219|      5|  for (char32 c = 0x125A; c <= 0x125D; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1219:27): [True: 4, False: 1]
  ------------------
 1220|     42|  for (char32 c = 0x1260; c <= 0x1288; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1220:27): [True: 41, False: 1]
  ------------------
 1221|      5|  for (char32 c = 0x128A; c <= 0x128D; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1221:27): [True: 4, False: 1]
  ------------------
 1222|     34|  for (char32 c = 0x1290; c <= 0x12B0; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1222:27): [True: 33, False: 1]
  ------------------
 1223|      5|  for (char32 c = 0x12B2; c <= 0x12B5; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1223:27): [True: 4, False: 1]
  ------------------
 1224|      8|  for (char32 c = 0x12B8; c <= 0x12BE; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1224:27): [True: 7, False: 1]
  ------------------
 1225|      1|  (*smap)[0x12C0] = U_Ethiopic;
 1226|      5|  for (char32 c = 0x12C2; c <= 0x12C5; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1226:27): [True: 4, False: 1]
  ------------------
 1227|     16|  for (char32 c = 0x12C8; c <= 0x12D6; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1227:27): [True: 15, False: 1]
  ------------------
 1228|     58|  for (char32 c = 0x12D8; c <= 0x1310; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1228:27): [True: 57, False: 1]
  ------------------
 1229|      5|  for (char32 c = 0x1312; c <= 0x1315; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1229:27): [True: 4, False: 1]
  ------------------
 1230|     68|  for (char32 c = 0x1318; c <= 0x135A; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1230:27): [True: 67, False: 1]
  ------------------
 1231|      4|  for (char32 c = 0x135D; c <= 0x135F; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1231:27): [True: 3, False: 1]
  ------------------
 1232|     10|  for (char32 c = 0x1360; c <= 0x1368; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1232:27): [True: 9, False: 1]
  ------------------
 1233|     21|  for (char32 c = 0x1369; c <= 0x137C; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1233:27): [True: 20, False: 1]
  ------------------
 1234|     17|  for (char32 c = 0x1380; c <= 0x138F; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1234:27): [True: 16, False: 1]
  ------------------
 1235|     11|  for (char32 c = 0x1390; c <= 0x1399; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1235:27): [True: 10, False: 1]
  ------------------
 1236|     24|  for (char32 c = 0x2D80; c <= 0x2D96; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1236:27): [True: 23, False: 1]
  ------------------
 1237|      8|  for (char32 c = 0x2DA0; c <= 0x2DA6; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1237:27): [True: 7, False: 1]
  ------------------
 1238|      8|  for (char32 c = 0x2DA8; c <= 0x2DAE; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1238:27): [True: 7, False: 1]
  ------------------
 1239|      8|  for (char32 c = 0x2DB0; c <= 0x2DB6; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1239:27): [True: 7, False: 1]
  ------------------
 1240|      8|  for (char32 c = 0x2DB8; c <= 0x2DBE; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1240:27): [True: 7, False: 1]
  ------------------
 1241|      8|  for (char32 c = 0x2DC0; c <= 0x2DC6; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1241:27): [True: 7, False: 1]
  ------------------
 1242|      8|  for (char32 c = 0x2DC8; c <= 0x2DCE; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1242:27): [True: 7, False: 1]
  ------------------
 1243|      8|  for (char32 c = 0x2DD0; c <= 0x2DD6; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1243:27): [True: 7, False: 1]
  ------------------
 1244|      8|  for (char32 c = 0x2DD8; c <= 0x2DDE; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1244:27): [True: 7, False: 1]
  ------------------
 1245|      7|  for (char32 c = 0xAB01; c <= 0xAB06; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1245:27): [True: 6, False: 1]
  ------------------
 1246|      7|  for (char32 c = 0xAB09; c <= 0xAB0E; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1246:27): [True: 6, False: 1]
  ------------------
 1247|      7|  for (char32 c = 0xAB11; c <= 0xAB16; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1247:27): [True: 6, False: 1]
  ------------------
 1248|      8|  for (char32 c = 0xAB20; c <= 0xAB26; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1248:27): [True: 7, False: 1]
  ------------------
 1249|      8|  for (char32 c = 0xAB28; c <= 0xAB2E; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1249:27): [True: 7, False: 1]
  ------------------
 1250|     87|  for (char32 c = 0x13A0; c <= 0x13F5; ++c) (*smap)[c] = U_Cherokee;
  ------------------
  |  Branch (1250:27): [True: 86, False: 1]
  ------------------
 1251|      7|  for (char32 c = 0x13F8; c <= 0x13FD; ++c) (*smap)[c] = U_Cherokee;
  ------------------
  |  Branch (1251:27): [True: 6, False: 1]
  ------------------
 1252|     81|  for (char32 c = 0xAB70; c <= 0xABBF; ++c) (*smap)[c] = U_Cherokee;
  ------------------
  |  Branch (1252:27): [True: 80, False: 1]
  ------------------
 1253|      1|  (*smap)[0x1400] = U_Canadian_Aboriginal;
 1254|    621|  for (char32 c = 0x1401; c <= 0x166C; ++c) (*smap)[c] = U_Canadian_Aboriginal;
  ------------------
  |  Branch (1254:27): [True: 620, False: 1]
  ------------------
 1255|      3|  for (char32 c = 0x166D; c <= 0x166E; ++c) (*smap)[c] = U_Canadian_Aboriginal;
  ------------------
  |  Branch (1255:27): [True: 2, False: 1]
  ------------------
 1256|     18|  for (char32 c = 0x166F; c <= 0x167F; ++c) (*smap)[c] = U_Canadian_Aboriginal;
  ------------------
  |  Branch (1256:27): [True: 17, False: 1]
  ------------------
 1257|     71|  for (char32 c = 0x18B0; c <= 0x18F5; ++c) (*smap)[c] = U_Canadian_Aboriginal;
  ------------------
  |  Branch (1257:27): [True: 70, False: 1]
  ------------------
 1258|      1|  (*smap)[0x1680] = U_Ogham;
 1259|     27|  for (char32 c = 0x1681; c <= 0x169A; ++c) (*smap)[c] = U_Ogham;
  ------------------
  |  Branch (1259:27): [True: 26, False: 1]
  ------------------
 1260|      1|  (*smap)[0x169B] = U_Ogham;
 1261|      1|  (*smap)[0x169C] = U_Ogham;
 1262|     76|  for (char32 c = 0x16A0; c <= 0x16EA; ++c) (*smap)[c] = U_Runic;
  ------------------
  |  Branch (1262:27): [True: 75, False: 1]
  ------------------
 1263|      4|  for (char32 c = 0x16EE; c <= 0x16F0; ++c) (*smap)[c] = U_Runic;
  ------------------
  |  Branch (1263:27): [True: 3, False: 1]
  ------------------
 1264|      9|  for (char32 c = 0x16F1; c <= 0x16F8; ++c) (*smap)[c] = U_Runic;
  ------------------
  |  Branch (1264:27): [True: 8, False: 1]
  ------------------
 1265|     53|  for (char32 c = 0x1780; c <= 0x17B3; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1265:27): [True: 52, False: 1]
  ------------------
 1266|      3|  for (char32 c = 0x17B4; c <= 0x17B5; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1266:27): [True: 2, False: 1]
  ------------------
 1267|      1|  (*smap)[0x17B6] = U_Khmer;
 1268|      8|  for (char32 c = 0x17B7; c <= 0x17BD; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1268:27): [True: 7, False: 1]
  ------------------
 1269|      9|  for (char32 c = 0x17BE; c <= 0x17C5; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1269:27): [True: 8, False: 1]
  ------------------
 1270|      1|  (*smap)[0x17C6] = U_Khmer;
 1271|      3|  for (char32 c = 0x17C7; c <= 0x17C8; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1271:27): [True: 2, False: 1]
  ------------------
 1272|     12|  for (char32 c = 0x17C9; c <= 0x17D3; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1272:27): [True: 11, False: 1]
  ------------------
 1273|      4|  for (char32 c = 0x17D4; c <= 0x17D6; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1273:27): [True: 3, False: 1]
  ------------------
 1274|      1|  (*smap)[0x17D7] = U_Khmer;
 1275|      4|  for (char32 c = 0x17D8; c <= 0x17DA; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1275:27): [True: 3, False: 1]
  ------------------
 1276|      1|  (*smap)[0x17DB] = U_Khmer;
 1277|      1|  (*smap)[0x17DC] = U_Khmer;
 1278|      1|  (*smap)[0x17DD] = U_Khmer;
 1279|     11|  for (char32 c = 0x17E0; c <= 0x17E9; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1279:27): [True: 10, False: 1]
  ------------------
 1280|     11|  for (char32 c = 0x17F0; c <= 0x17F9; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1280:27): [True: 10, False: 1]
  ------------------
 1281|     33|  for (char32 c = 0x19E0; c <= 0x19FF; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1281:27): [True: 32, False: 1]
  ------------------
 1282|      3|  for (char32 c = 0x1800; c <= 0x1801; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1282:27): [True: 2, False: 1]
  ------------------
 1283|      1|  (*smap)[0x1804] = U_Mongolian;
 1284|      1|  (*smap)[0x1806] = U_Mongolian;
 1285|      5|  for (char32 c = 0x1807; c <= 0x180A; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1285:27): [True: 4, False: 1]
  ------------------
 1286|      4|  for (char32 c = 0x180B; c <= 0x180D; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1286:27): [True: 3, False: 1]
  ------------------
 1287|      1|  (*smap)[0x180E] = U_Mongolian;
 1288|     11|  for (char32 c = 0x1810; c <= 0x1819; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1288:27): [True: 10, False: 1]
  ------------------
 1289|     36|  for (char32 c = 0x1820; c <= 0x1842; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1289:27): [True: 35, False: 1]
  ------------------
 1290|      1|  (*smap)[0x1843] = U_Mongolian;
 1291|     53|  for (char32 c = 0x1844; c <= 0x1877; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1291:27): [True: 52, False: 1]
  ------------------
 1292|      6|  for (char32 c = 0x1880; c <= 0x1884; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1292:27): [True: 5, False: 1]
  ------------------
 1293|      3|  for (char32 c = 0x1885; c <= 0x1886; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1293:27): [True: 2, False: 1]
  ------------------
 1294|     35|  for (char32 c = 0x1887; c <= 0x18A8; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1294:27): [True: 34, False: 1]
  ------------------
 1295|      1|  (*smap)[0x18A9] = U_Mongolian;
 1296|      1|  (*smap)[0x18AA] = U_Mongolian;
 1297|     14|  for (char32 c = 0x11660; c <= 0x1166C; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1297:28): [True: 13, False: 1]
  ------------------
 1298|     87|  for (char32 c = 0x3041; c <= 0x3096; ++c) (*smap)[c] = U_Hiragana;
  ------------------
  |  Branch (1298:27): [True: 86, False: 1]
  ------------------
 1299|      3|  for (char32 c = 0x309D; c <= 0x309E; ++c) (*smap)[c] = U_Hiragana;
  ------------------
  |  Branch (1299:27): [True: 2, False: 1]
  ------------------
 1300|      1|  (*smap)[0x309F] = U_Hiragana;
 1301|      1|  (*smap)[0x1B001] = U_Hiragana;
 1302|      1|  (*smap)[0x1F200] = U_Hiragana;
 1303|     91|  for (char32 c = 0x30A1; c <= 0x30FA; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1303:27): [True: 90, False: 1]
  ------------------
 1304|      3|  for (char32 c = 0x30FD; c <= 0x30FE; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1304:27): [True: 2, False: 1]
  ------------------
 1305|      1|  (*smap)[0x30FF] = U_Katakana;
 1306|     17|  for (char32 c = 0x31F0; c <= 0x31FF; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1306:27): [True: 16, False: 1]
  ------------------
 1307|     48|  for (char32 c = 0x32D0; c <= 0x32FE; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1307:27): [True: 47, False: 1]
  ------------------
 1308|     89|  for (char32 c = 0x3300; c <= 0x3357; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1308:27): [True: 88, False: 1]
  ------------------
 1309|     11|  for (char32 c = 0xFF66; c <= 0xFF6F; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1309:27): [True: 10, False: 1]
  ------------------
 1310|     46|  for (char32 c = 0xFF71; c <= 0xFF9D; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1310:27): [True: 45, False: 1]
  ------------------
 1311|      1|  (*smap)[0x1B000] = U_Katakana;
 1312|      3|  for (char32 c = 0x02EA; c <= 0x02EB; ++c) (*smap)[c] = U_Bopomofo;
  ------------------
  |  Branch (1312:27): [True: 2, False: 1]
  ------------------
 1313|     42|  for (char32 c = 0x3105; c <= 0x312D; ++c) (*smap)[c] = U_Bopomofo;
  ------------------
  |  Branch (1313:27): [True: 41, False: 1]
  ------------------
 1314|     28|  for (char32 c = 0x31A0; c <= 0x31BA; ++c) (*smap)[c] = U_Bopomofo;
  ------------------
  |  Branch (1314:27): [True: 27, False: 1]
  ------------------
 1315|     27|  for (char32 c = 0x2E80; c <= 0x2E99; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1315:27): [True: 26, False: 1]
  ------------------
 1316|     90|  for (char32 c = 0x2E9B; c <= 0x2EF3; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1316:27): [True: 89, False: 1]
  ------------------
 1317|    215|  for (char32 c = 0x2F00; c <= 0x2FD5; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1317:27): [True: 214, False: 1]
  ------------------
 1318|      1|  (*smap)[0x3005] = U_Han;
 1319|      1|  (*smap)[0x3007] = U_Han;
 1320|     10|  for (char32 c = 0x3021; c <= 0x3029; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1320:27): [True: 9, False: 1]
  ------------------
 1321|      4|  for (char32 c = 0x3038; c <= 0x303A; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1321:27): [True: 3, False: 1]
  ------------------
 1322|      1|  (*smap)[0x303B] = U_Han;
 1323|  6.58k|  for (char32 c = 0x3400; c <= 0x4DB5; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1323:27): [True: 6.58k, False: 1]
  ------------------
 1324|  20.9k|  for (char32 c = 0x4E00; c <= 0x9FD5; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1324:27): [True: 20.9k, False: 1]
  ------------------
 1325|    367|  for (char32 c = 0xF900; c <= 0xFA6D; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1325:27): [True: 366, False: 1]
  ------------------
 1326|    107|  for (char32 c = 0xFA70; c <= 0xFAD9; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1326:27): [True: 106, False: 1]
  ------------------
 1327|  42.7k|  for (char32 c = 0x20000; c <= 0x2A6D6; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1327:28): [True: 42.7k, False: 1]
  ------------------
 1328|  4.15k|  for (char32 c = 0x2A700; c <= 0x2B734; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1328:28): [True: 4.14k, False: 1]
  ------------------
 1329|    223|  for (char32 c = 0x2B740; c <= 0x2B81D; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1329:28): [True: 222, False: 1]
  ------------------
 1330|  5.76k|  for (char32 c = 0x2B820; c <= 0x2CEA1; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1330:28): [True: 5.76k, False: 1]
  ------------------
 1331|    543|  for (char32 c = 0x2F800; c <= 0x2FA1D; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1331:28): [True: 542, False: 1]
  ------------------
 1332|     22|  for (char32 c = 0xA000; c <= 0xA014; ++c) (*smap)[c] = U_Yi;
  ------------------
  |  Branch (1332:27): [True: 21, False: 1]
  ------------------
 1333|      1|  (*smap)[0xA015] = U_Yi;
 1334|  1.14k|  for (char32 c = 0xA016; c <= 0xA48C; ++c) (*smap)[c] = U_Yi;
  ------------------
  |  Branch (1334:27): [True: 1.14k, False: 1]
  ------------------
 1335|     56|  for (char32 c = 0xA490; c <= 0xA4C6; ++c) (*smap)[c] = U_Yi;
  ------------------
  |  Branch (1335:27): [True: 55, False: 1]
  ------------------
 1336|     33|  for (char32 c = 0x10300; c <= 0x1031F; ++c) (*smap)[c] = U_Old_Italic;
  ------------------
  |  Branch (1336:28): [True: 32, False: 1]
  ------------------
 1337|      5|  for (char32 c = 0x10320; c <= 0x10323; ++c) (*smap)[c] = U_Old_Italic;
  ------------------
  |  Branch (1337:28): [True: 4, False: 1]
  ------------------
 1338|     18|  for (char32 c = 0x10330; c <= 0x10340; ++c) (*smap)[c] = U_Gothic;
  ------------------
  |  Branch (1338:28): [True: 17, False: 1]
  ------------------
 1339|      1|  (*smap)[0x10341] = U_Gothic;
 1340|      9|  for (char32 c = 0x10342; c <= 0x10349; ++c) (*smap)[c] = U_Gothic;
  ------------------
  |  Branch (1340:28): [True: 8, False: 1]
  ------------------
 1341|      1|  (*smap)[0x1034A] = U_Gothic;
 1342|     81|  for (char32 c = 0x10400; c <= 0x1044F; ++c) (*smap)[c] = U_Deseret;
  ------------------
  |  Branch (1342:28): [True: 80, False: 1]
  ------------------
 1343|    113|  for (char32 c = 0x0300; c <= 0x036F; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1343:27): [True: 112, False: 1]
  ------------------
 1344|      3|  for (char32 c = 0x0485; c <= 0x0486; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1344:27): [True: 2, False: 1]
  ------------------
 1345|     12|  for (char32 c = 0x064B; c <= 0x0655; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1345:27): [True: 11, False: 1]
  ------------------
 1346|      1|  (*smap)[0x0670] = U_Inherited;
 1347|      3|  for (char32 c = 0x0951; c <= 0x0952; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1347:27): [True: 2, False: 1]
  ------------------
 1348|     15|  for (char32 c = 0x1AB0; c <= 0x1ABD; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1348:27): [True: 14, False: 1]
  ------------------
 1349|      1|  (*smap)[0x1ABE] = U_Inherited;
 1350|      4|  for (char32 c = 0x1CD0; c <= 0x1CD2; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1350:27): [True: 3, False: 1]
  ------------------
 1351|     14|  for (char32 c = 0x1CD4; c <= 0x1CE0; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1351:27): [True: 13, False: 1]
  ------------------
 1352|      8|  for (char32 c = 0x1CE2; c <= 0x1CE8; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1352:27): [True: 7, False: 1]
  ------------------
 1353|      1|  (*smap)[0x1CED] = U_Inherited;
 1354|      1|  (*smap)[0x1CF4] = U_Inherited;
 1355|      3|  for (char32 c = 0x1CF8; c <= 0x1CF9; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1355:27): [True: 2, False: 1]
  ------------------
 1356|     55|  for (char32 c = 0x1DC0; c <= 0x1DF5; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1356:27): [True: 54, False: 1]
  ------------------
 1357|      6|  for (char32 c = 0x1DFB; c <= 0x1DFF; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1357:27): [True: 5, False: 1]
  ------------------
 1358|      3|  for (char32 c = 0x200C; c <= 0x200D; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1358:27): [True: 2, False: 1]
  ------------------
 1359|     14|  for (char32 c = 0x20D0; c <= 0x20DC; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1359:27): [True: 13, False: 1]
  ------------------
 1360|      5|  for (char32 c = 0x20DD; c <= 0x20E0; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1360:27): [True: 4, False: 1]
  ------------------
 1361|      1|  (*smap)[0x20E1] = U_Inherited;
 1362|      4|  for (char32 c = 0x20E2; c <= 0x20E4; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1362:27): [True: 3, False: 1]
  ------------------
 1363|     13|  for (char32 c = 0x20E5; c <= 0x20F0; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1363:27): [True: 12, False: 1]
  ------------------
 1364|      5|  for (char32 c = 0x302A; c <= 0x302D; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1364:27): [True: 4, False: 1]
  ------------------
 1365|      3|  for (char32 c = 0x3099; c <= 0x309A; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1365:27): [True: 2, False: 1]
  ------------------
 1366|     17|  for (char32 c = 0xFE00; c <= 0xFE0F; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1366:27): [True: 16, False: 1]
  ------------------
 1367|     15|  for (char32 c = 0xFE20; c <= 0xFE2D; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1367:27): [True: 14, False: 1]
  ------------------
 1368|      1|  (*smap)[0x101FD] = U_Inherited;
 1369|      1|  (*smap)[0x102E0] = U_Inherited;
 1370|      4|  for (char32 c = 0x1D167; c <= 0x1D169; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1370:28): [True: 3, False: 1]
  ------------------
 1371|      9|  for (char32 c = 0x1D17B; c <= 0x1D182; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1371:28): [True: 8, False: 1]
  ------------------
 1372|      8|  for (char32 c = 0x1D185; c <= 0x1D18B; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1372:28): [True: 7, False: 1]
  ------------------
 1373|      5|  for (char32 c = 0x1D1AA; c <= 0x1D1AD; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1373:28): [True: 4, False: 1]
  ------------------
 1374|    241|  for (char32 c = 0xE0100; c <= 0xE01EF; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1374:28): [True: 240, False: 1]
  ------------------
 1375|     14|  for (char32 c = 0x1700; c <= 0x170C; ++c) (*smap)[c] = U_Tagalog;
  ------------------
  |  Branch (1375:27): [True: 13, False: 1]
  ------------------
 1376|      5|  for (char32 c = 0x170E; c <= 0x1711; ++c) (*smap)[c] = U_Tagalog;
  ------------------
  |  Branch (1376:27): [True: 4, False: 1]
  ------------------
 1377|      4|  for (char32 c = 0x1712; c <= 0x1714; ++c) (*smap)[c] = U_Tagalog;
  ------------------
  |  Branch (1377:27): [True: 3, False: 1]
  ------------------
 1378|     19|  for (char32 c = 0x1720; c <= 0x1731; ++c) (*smap)[c] = U_Hanunoo;
  ------------------
  |  Branch (1378:27): [True: 18, False: 1]
  ------------------
 1379|      4|  for (char32 c = 0x1732; c <= 0x1734; ++c) (*smap)[c] = U_Hanunoo;
  ------------------
  |  Branch (1379:27): [True: 3, False: 1]
  ------------------
 1380|     19|  for (char32 c = 0x1740; c <= 0x1751; ++c) (*smap)[c] = U_Buhid;
  ------------------
  |  Branch (1380:27): [True: 18, False: 1]
  ------------------
 1381|      3|  for (char32 c = 0x1752; c <= 0x1753; ++c) (*smap)[c] = U_Buhid;
  ------------------
  |  Branch (1381:27): [True: 2, False: 1]
  ------------------
 1382|     14|  for (char32 c = 0x1760; c <= 0x176C; ++c) (*smap)[c] = U_Tagbanwa;
  ------------------
  |  Branch (1382:27): [True: 13, False: 1]
  ------------------
 1383|      4|  for (char32 c = 0x176E; c <= 0x1770; ++c) (*smap)[c] = U_Tagbanwa;
  ------------------
  |  Branch (1383:27): [True: 3, False: 1]
  ------------------
 1384|      3|  for (char32 c = 0x1772; c <= 0x1773; ++c) (*smap)[c] = U_Tagbanwa;
  ------------------
  |  Branch (1384:27): [True: 2, False: 1]
  ------------------
 1385|     32|  for (char32 c = 0x1900; c <= 0x191E; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1385:27): [True: 31, False: 1]
  ------------------
 1386|      4|  for (char32 c = 0x1920; c <= 0x1922; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1386:27): [True: 3, False: 1]
  ------------------
 1387|      5|  for (char32 c = 0x1923; c <= 0x1926; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1387:27): [True: 4, False: 1]
  ------------------
 1388|      3|  for (char32 c = 0x1927; c <= 0x1928; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1388:27): [True: 2, False: 1]
  ------------------
 1389|      4|  for (char32 c = 0x1929; c <= 0x192B; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1389:27): [True: 3, False: 1]
  ------------------
 1390|      3|  for (char32 c = 0x1930; c <= 0x1931; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1390:27): [True: 2, False: 1]
  ------------------
 1391|      1|  (*smap)[0x1932] = U_Limbu;
 1392|      7|  for (char32 c = 0x1933; c <= 0x1938; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1392:27): [True: 6, False: 1]
  ------------------
 1393|      4|  for (char32 c = 0x1939; c <= 0x193B; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1393:27): [True: 3, False: 1]
  ------------------
 1394|      1|  (*smap)[0x1940] = U_Limbu;
 1395|      3|  for (char32 c = 0x1944; c <= 0x1945; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1395:27): [True: 2, False: 1]
  ------------------
 1396|     11|  for (char32 c = 0x1946; c <= 0x194F; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1396:27): [True: 10, False: 1]
  ------------------
 1397|     31|  for (char32 c = 0x1950; c <= 0x196D; ++c) (*smap)[c] = U_Tai_Le;
  ------------------
  |  Branch (1397:27): [True: 30, False: 1]
  ------------------
 1398|      6|  for (char32 c = 0x1970; c <= 0x1974; ++c) (*smap)[c] = U_Tai_Le;
  ------------------
  |  Branch (1398:27): [True: 5, False: 1]
  ------------------
 1399|     13|  for (char32 c = 0x10000; c <= 0x1000B; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1399:28): [True: 12, False: 1]
  ------------------
 1400|     27|  for (char32 c = 0x1000D; c <= 0x10026; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1400:28): [True: 26, False: 1]
  ------------------
 1401|     20|  for (char32 c = 0x10028; c <= 0x1003A; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1401:28): [True: 19, False: 1]
  ------------------
 1402|      3|  for (char32 c = 0x1003C; c <= 0x1003D; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1402:28): [True: 2, False: 1]
  ------------------
 1403|     16|  for (char32 c = 0x1003F; c <= 0x1004D; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1403:28): [True: 15, False: 1]
  ------------------
 1404|     15|  for (char32 c = 0x10050; c <= 0x1005D; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1404:28): [True: 14, False: 1]
  ------------------
 1405|    124|  for (char32 c = 0x10080; c <= 0x100FA; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1405:28): [True: 123, False: 1]
  ------------------
 1406|     31|  for (char32 c = 0x10380; c <= 0x1039D; ++c) (*smap)[c] = U_Ugaritic;
  ------------------
  |  Branch (1406:28): [True: 30, False: 1]
  ------------------
 1407|      1|  (*smap)[0x1039F] = U_Ugaritic;
 1408|     49|  for (char32 c = 0x10450; c <= 0x1047F; ++c) (*smap)[c] = U_Shavian;
  ------------------
  |  Branch (1408:28): [True: 48, False: 1]
  ------------------
 1409|     31|  for (char32 c = 0x10480; c <= 0x1049D; ++c) (*smap)[c] = U_Osmanya;
  ------------------
  |  Branch (1409:28): [True: 30, False: 1]
  ------------------
 1410|     11|  for (char32 c = 0x104A0; c <= 0x104A9; ++c) (*smap)[c] = U_Osmanya;
  ------------------
  |  Branch (1410:28): [True: 10, False: 1]
  ------------------
 1411|      7|  for (char32 c = 0x10800; c <= 0x10805; ++c) (*smap)[c] = U_Cypriot;
  ------------------
  |  Branch (1411:28): [True: 6, False: 1]
  ------------------
 1412|      1|  (*smap)[0x10808] = U_Cypriot;
 1413|     45|  for (char32 c = 0x1080A; c <= 0x10835; ++c) (*smap)[c] = U_Cypriot;
  ------------------
  |  Branch (1413:28): [True: 44, False: 1]
  ------------------
 1414|      3|  for (char32 c = 0x10837; c <= 0x10838; ++c) (*smap)[c] = U_Cypriot;
  ------------------
  |  Branch (1414:28): [True: 2, False: 1]
  ------------------
 1415|      1|  (*smap)[0x1083C] = U_Cypriot;
 1416|      1|  (*smap)[0x1083F] = U_Cypriot;
 1417|    257|  for (char32 c = 0x2800; c <= 0x28FF; ++c) (*smap)[c] = U_Braille;
  ------------------
  |  Branch (1417:27): [True: 256, False: 1]
  ------------------
 1418|     24|  for (char32 c = 0x1A00; c <= 0x1A16; ++c) (*smap)[c] = U_Buginese;
  ------------------
  |  Branch (1418:27): [True: 23, False: 1]
  ------------------
 1419|      3|  for (char32 c = 0x1A17; c <= 0x1A18; ++c) (*smap)[c] = U_Buginese;
  ------------------
  |  Branch (1419:27): [True: 2, False: 1]
  ------------------
 1420|      3|  for (char32 c = 0x1A19; c <= 0x1A1A; ++c) (*smap)[c] = U_Buginese;
  ------------------
  |  Branch (1420:27): [True: 2, False: 1]
  ------------------
 1421|      1|  (*smap)[0x1A1B] = U_Buginese;
 1422|      3|  for (char32 c = 0x1A1E; c <= 0x1A1F; ++c) (*smap)[c] = U_Buginese;
  ------------------
  |  Branch (1422:27): [True: 2, False: 1]
  ------------------
 1423|     15|  for (char32 c = 0x03E2; c <= 0x03EF; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1423:27): [True: 14, False: 1]
  ------------------
 1424|    102|  for (char32 c = 0x2C80; c <= 0x2CE4; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1424:27): [True: 101, False: 1]
  ------------------
 1425|      7|  for (char32 c = 0x2CE5; c <= 0x2CEA; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1425:27): [True: 6, False: 1]
  ------------------
 1426|      5|  for (char32 c = 0x2CEB; c <= 0x2CEE; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1426:27): [True: 4, False: 1]
  ------------------
 1427|      4|  for (char32 c = 0x2CEF; c <= 0x2CF1; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1427:27): [True: 3, False: 1]
  ------------------
 1428|      3|  for (char32 c = 0x2CF2; c <= 0x2CF3; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1428:27): [True: 2, False: 1]
  ------------------
 1429|      5|  for (char32 c = 0x2CF9; c <= 0x2CFC; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1429:27): [True: 4, False: 1]
  ------------------
 1430|      1|  (*smap)[0x2CFD] = U_Coptic;
 1431|      3|  for (char32 c = 0x2CFE; c <= 0x2CFF; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1431:27): [True: 2, False: 1]
  ------------------
 1432|     45|  for (char32 c = 0x1980; c <= 0x19AB; ++c) (*smap)[c] = U_New_Tai_Lue;
  ------------------
  |  Branch (1432:27): [True: 44, False: 1]
  ------------------
 1433|     27|  for (char32 c = 0x19B0; c <= 0x19C9; ++c) (*smap)[c] = U_New_Tai_Lue;
  ------------------
  |  Branch (1433:27): [True: 26, False: 1]
  ------------------
 1434|     11|  for (char32 c = 0x19D0; c <= 0x19D9; ++c) (*smap)[c] = U_New_Tai_Lue;
  ------------------
  |  Branch (1434:27): [True: 10, False: 1]
  ------------------
 1435|      1|  (*smap)[0x19DA] = U_New_Tai_Lue;
 1436|      3|  for (char32 c = 0x19DE; c <= 0x19DF; ++c) (*smap)[c] = U_New_Tai_Lue;
  ------------------
  |  Branch (1436:27): [True: 2, False: 1]
  ------------------
 1437|     48|  for (char32 c = 0x2C00; c <= 0x2C2E; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1437:27): [True: 47, False: 1]
  ------------------
 1438|     48|  for (char32 c = 0x2C30; c <= 0x2C5E; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1438:27): [True: 47, False: 1]
  ------------------
 1439|      8|  for (char32 c = 0x1E000; c <= 0x1E006; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1439:28): [True: 7, False: 1]
  ------------------
 1440|     18|  for (char32 c = 0x1E008; c <= 0x1E018; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1440:28): [True: 17, False: 1]
  ------------------
 1441|      8|  for (char32 c = 0x1E01B; c <= 0x1E021; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1441:28): [True: 7, False: 1]
  ------------------
 1442|      3|  for (char32 c = 0x1E023; c <= 0x1E024; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1442:28): [True: 2, False: 1]
  ------------------
 1443|      6|  for (char32 c = 0x1E026; c <= 0x1E02A; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1443:28): [True: 5, False: 1]
  ------------------
 1444|     57|  for (char32 c = 0x2D30; c <= 0x2D67; ++c) (*smap)[c] = U_Tifinagh;
  ------------------
  |  Branch (1444:27): [True: 56, False: 1]
  ------------------
 1445|      1|  (*smap)[0x2D6F] = U_Tifinagh;
 1446|      1|  (*smap)[0x2D70] = U_Tifinagh;
 1447|      1|  (*smap)[0x2D7F] = U_Tifinagh;
 1448|      3|  for (char32 c = 0xA800; c <= 0xA801; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1448:27): [True: 2, False: 1]
  ------------------
 1449|      1|  (*smap)[0xA802] = U_Syloti_Nagri;
 1450|      4|  for (char32 c = 0xA803; c <= 0xA805; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1450:27): [True: 3, False: 1]
  ------------------
 1451|      1|  (*smap)[0xA806] = U_Syloti_Nagri;
 1452|      5|  for (char32 c = 0xA807; c <= 0xA80A; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1452:27): [True: 4, False: 1]
  ------------------
 1453|      1|  (*smap)[0xA80B] = U_Syloti_Nagri;
 1454|     24|  for (char32 c = 0xA80C; c <= 0xA822; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1454:27): [True: 23, False: 1]
  ------------------
 1455|      3|  for (char32 c = 0xA823; c <= 0xA824; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1455:27): [True: 2, False: 1]
  ------------------
 1456|      3|  for (char32 c = 0xA825; c <= 0xA826; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1456:27): [True: 2, False: 1]
  ------------------
 1457|      1|  (*smap)[0xA827] = U_Syloti_Nagri;
 1458|      5|  for (char32 c = 0xA828; c <= 0xA82B; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1458:27): [True: 4, False: 1]
  ------------------
 1459|     37|  for (char32 c = 0x103A0; c <= 0x103C3; ++c) (*smap)[c] = U_Old_Persian;
  ------------------
  |  Branch (1459:28): [True: 36, False: 1]
  ------------------
 1460|      9|  for (char32 c = 0x103C8; c <= 0x103CF; ++c) (*smap)[c] = U_Old_Persian;
  ------------------
  |  Branch (1460:28): [True: 8, False: 1]
  ------------------
 1461|      1|  (*smap)[0x103D0] = U_Old_Persian;
 1462|      6|  for (char32 c = 0x103D1; c <= 0x103D5; ++c) (*smap)[c] = U_Old_Persian;
  ------------------
  |  Branch (1462:28): [True: 5, False: 1]
  ------------------
 1463|      1|  (*smap)[0x10A00] = U_Kharoshthi;
 1464|      4|  for (char32 c = 0x10A01; c <= 0x10A03; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1464:28): [True: 3, False: 1]
  ------------------
 1465|      3|  for (char32 c = 0x10A05; c <= 0x10A06; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1465:28): [True: 2, False: 1]
  ------------------
 1466|      5|  for (char32 c = 0x10A0C; c <= 0x10A0F; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1466:28): [True: 4, False: 1]
  ------------------
 1467|      5|  for (char32 c = 0x10A10; c <= 0x10A13; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1467:28): [True: 4, False: 1]
  ------------------
 1468|      4|  for (char32 c = 0x10A15; c <= 0x10A17; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1468:28): [True: 3, False: 1]
  ------------------
 1469|     28|  for (char32 c = 0x10A19; c <= 0x10A33; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1469:28): [True: 27, False: 1]
  ------------------
 1470|      4|  for (char32 c = 0x10A38; c <= 0x10A3A; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1470:28): [True: 3, False: 1]
  ------------------
 1471|      1|  (*smap)[0x10A3F] = U_Kharoshthi;
 1472|      9|  for (char32 c = 0x10A40; c <= 0x10A47; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1472:28): [True: 8, False: 1]
  ------------------
 1473|     10|  for (char32 c = 0x10A50; c <= 0x10A58; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1473:28): [True: 9, False: 1]
  ------------------
 1474|      5|  for (char32 c = 0x1B00; c <= 0x1B03; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1474:27): [True: 4, False: 1]
  ------------------
 1475|      1|  (*smap)[0x1B04] = U_Balinese;
 1476|     48|  for (char32 c = 0x1B05; c <= 0x1B33; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1476:27): [True: 47, False: 1]
  ------------------
 1477|      1|  (*smap)[0x1B34] = U_Balinese;
 1478|      1|  (*smap)[0x1B35] = U_Balinese;
 1479|      6|  for (char32 c = 0x1B36; c <= 0x1B3A; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1479:27): [True: 5, False: 1]
  ------------------
 1480|      1|  (*smap)[0x1B3B] = U_Balinese;
 1481|      1|  (*smap)[0x1B3C] = U_Balinese;
 1482|      6|  for (char32 c = 0x1B3D; c <= 0x1B41; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1482:27): [True: 5, False: 1]
  ------------------
 1483|      1|  (*smap)[0x1B42] = U_Balinese;
 1484|      3|  for (char32 c = 0x1B43; c <= 0x1B44; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1484:27): [True: 2, False: 1]
  ------------------
 1485|      8|  for (char32 c = 0x1B45; c <= 0x1B4B; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1485:27): [True: 7, False: 1]
  ------------------
 1486|     11|  for (char32 c = 0x1B50; c <= 0x1B59; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1486:27): [True: 10, False: 1]
  ------------------
 1487|      8|  for (char32 c = 0x1B5A; c <= 0x1B60; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1487:27): [True: 7, False: 1]
  ------------------
 1488|     11|  for (char32 c = 0x1B61; c <= 0x1B6A; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1488:27): [True: 10, False: 1]
  ------------------
 1489|     10|  for (char32 c = 0x1B6B; c <= 0x1B73; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1489:27): [True: 9, False: 1]
  ------------------
 1490|     10|  for (char32 c = 0x1B74; c <= 0x1B7C; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1490:27): [True: 9, False: 1]
  ------------------
 1491|    923|  for (char32 c = 0x12000; c <= 0x12399; ++c) (*smap)[c] = U_Cuneiform;
  ------------------
  |  Branch (1491:28): [True: 922, False: 1]
  ------------------
 1492|    112|  for (char32 c = 0x12400; c <= 0x1246E; ++c) (*smap)[c] = U_Cuneiform;
  ------------------
  |  Branch (1492:28): [True: 111, False: 1]
  ------------------
 1493|      6|  for (char32 c = 0x12470; c <= 0x12474; ++c) (*smap)[c] = U_Cuneiform;
  ------------------
  |  Branch (1493:28): [True: 5, False: 1]
  ------------------
 1494|    197|  for (char32 c = 0x12480; c <= 0x12543; ++c) (*smap)[c] = U_Cuneiform;
  ------------------
  |  Branch (1494:28): [True: 196, False: 1]
  ------------------
 1495|     23|  for (char32 c = 0x10900; c <= 0x10915; ++c) (*smap)[c] = U_Phoenician;
  ------------------
  |  Branch (1495:28): [True: 22, False: 1]
  ------------------
 1496|      7|  for (char32 c = 0x10916; c <= 0x1091B; ++c) (*smap)[c] = U_Phoenician;
  ------------------
  |  Branch (1496:28): [True: 6, False: 1]
  ------------------
 1497|      1|  (*smap)[0x1091F] = U_Phoenician;
 1498|     53|  for (char32 c = 0xA840; c <= 0xA873; ++c) (*smap)[c] = U_Phags_Pa;
  ------------------
  |  Branch (1498:27): [True: 52, False: 1]
  ------------------
 1499|      5|  for (char32 c = 0xA874; c <= 0xA877; ++c) (*smap)[c] = U_Phags_Pa;
  ------------------
  |  Branch (1499:27): [True: 4, False: 1]
  ------------------
 1500|     11|  for (char32 c = 0x07C0; c <= 0x07C9; ++c) (*smap)[c] = U_Nko;
  ------------------
  |  Branch (1500:27): [True: 10, False: 1]
  ------------------
 1501|     34|  for (char32 c = 0x07CA; c <= 0x07EA; ++c) (*smap)[c] = U_Nko;
  ------------------
  |  Branch (1501:27): [True: 33, False: 1]
  ------------------
 1502|     10|  for (char32 c = 0x07EB; c <= 0x07F3; ++c) (*smap)[c] = U_Nko;
  ------------------
  |  Branch (1502:27): [True: 9, False: 1]
  ------------------
 1503|      3|  for (char32 c = 0x07F4; c <= 0x07F5; ++c) (*smap)[c] = U_Nko;
  ------------------
  |  Branch (1503:27): [True: 2, False: 1]
  ------------------
 1504|      1|  (*smap)[0x07F6] = U_Nko;
 1505|      4|  for (char32 c = 0x07F7; c <= 0x07F9; ++c) (*smap)[c] = U_Nko;
  ------------------
  |  Branch (1505:27): [True: 3, False: 1]
  ------------------
 1506|      1|  (*smap)[0x07FA] = U_Nko;
 1507|      3|  for (char32 c = 0x1B80; c <= 0x1B81; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1507:27): [True: 2, False: 1]
  ------------------
 1508|      1|  (*smap)[0x1B82] = U_Sundanese;
 1509|     31|  for (char32 c = 0x1B83; c <= 0x1BA0; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1509:27): [True: 30, False: 1]
  ------------------
 1510|      1|  (*smap)[0x1BA1] = U_Sundanese;
 1511|      5|  for (char32 c = 0x1BA2; c <= 0x1BA5; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1511:27): [True: 4, False: 1]
  ------------------
 1512|      3|  for (char32 c = 0x1BA6; c <= 0x1BA7; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1512:27): [True: 2, False: 1]
  ------------------
 1513|      3|  for (char32 c = 0x1BA8; c <= 0x1BA9; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1513:27): [True: 2, False: 1]
  ------------------
 1514|      1|  (*smap)[0x1BAA] = U_Sundanese;
 1515|      4|  for (char32 c = 0x1BAB; c <= 0x1BAD; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1515:27): [True: 3, False: 1]
  ------------------
 1516|      3|  for (char32 c = 0x1BAE; c <= 0x1BAF; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1516:27): [True: 2, False: 1]
  ------------------
 1517|     11|  for (char32 c = 0x1BB0; c <= 0x1BB9; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1517:27): [True: 10, False: 1]
  ------------------
 1518|      7|  for (char32 c = 0x1BBA; c <= 0x1BBF; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1518:27): [True: 6, False: 1]
  ------------------
 1519|      9|  for (char32 c = 0x1CC0; c <= 0x1CC7; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1519:27): [True: 8, False: 1]
  ------------------
 1520|     37|  for (char32 c = 0x1C00; c <= 0x1C23; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1520:27): [True: 36, False: 1]
  ------------------
 1521|      9|  for (char32 c = 0x1C24; c <= 0x1C2B; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1521:27): [True: 8, False: 1]
  ------------------
 1522|      9|  for (char32 c = 0x1C2C; c <= 0x1C33; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1522:27): [True: 8, False: 1]
  ------------------
 1523|      3|  for (char32 c = 0x1C34; c <= 0x1C35; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1523:27): [True: 2, False: 1]
  ------------------
 1524|      3|  for (char32 c = 0x1C36; c <= 0x1C37; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1524:27): [True: 2, False: 1]
  ------------------
 1525|      6|  for (char32 c = 0x1C3B; c <= 0x1C3F; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1525:27): [True: 5, False: 1]
  ------------------
 1526|     11|  for (char32 c = 0x1C40; c <= 0x1C49; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1526:27): [True: 10, False: 1]
  ------------------
 1527|      4|  for (char32 c = 0x1C4D; c <= 0x1C4F; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1527:27): [True: 3, False: 1]
  ------------------
 1528|     11|  for (char32 c = 0x1C50; c <= 0x1C59; ++c) (*smap)[c] = U_Ol_Chiki;
  ------------------
  |  Branch (1528:27): [True: 10, False: 1]
  ------------------
 1529|     31|  for (char32 c = 0x1C5A; c <= 0x1C77; ++c) (*smap)[c] = U_Ol_Chiki;
  ------------------
  |  Branch (1529:27): [True: 30, False: 1]
  ------------------
 1530|      7|  for (char32 c = 0x1C78; c <= 0x1C7D; ++c) (*smap)[c] = U_Ol_Chiki;
  ------------------
  |  Branch (1530:27): [True: 6, False: 1]
  ------------------
 1531|      3|  for (char32 c = 0x1C7E; c <= 0x1C7F; ++c) (*smap)[c] = U_Ol_Chiki;
  ------------------
  |  Branch (1531:27): [True: 2, False: 1]
  ------------------
 1532|    269|  for (char32 c = 0xA500; c <= 0xA60B; ++c) (*smap)[c] = U_Vai;
  ------------------
  |  Branch (1532:27): [True: 268, False: 1]
  ------------------
 1533|      1|  (*smap)[0xA60C] = U_Vai;
 1534|      4|  for (char32 c = 0xA60D; c <= 0xA60F; ++c) (*smap)[c] = U_Vai;
  ------------------
  |  Branch (1534:27): [True: 3, False: 1]
  ------------------
 1535|     17|  for (char32 c = 0xA610; c <= 0xA61F; ++c) (*smap)[c] = U_Vai;
  ------------------
  |  Branch (1535:27): [True: 16, False: 1]
  ------------------
 1536|     11|  for (char32 c = 0xA620; c <= 0xA629; ++c) (*smap)[c] = U_Vai;
  ------------------
  |  Branch (1536:27): [True: 10, False: 1]
  ------------------
 1537|      3|  for (char32 c = 0xA62A; c <= 0xA62B; ++c) (*smap)[c] = U_Vai;
  ------------------
  |  Branch (1537:27): [True: 2, False: 1]
  ------------------
 1538|      3|  for (char32 c = 0xA880; c <= 0xA881; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1538:27): [True: 2, False: 1]
  ------------------
 1539|     51|  for (char32 c = 0xA882; c <= 0xA8B3; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1539:27): [True: 50, False: 1]
  ------------------
 1540|     17|  for (char32 c = 0xA8B4; c <= 0xA8C3; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1540:27): [True: 16, False: 1]
  ------------------
 1541|      3|  for (char32 c = 0xA8C4; c <= 0xA8C5; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1541:27): [True: 2, False: 1]
  ------------------
 1542|      3|  for (char32 c = 0xA8CE; c <= 0xA8CF; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1542:27): [True: 2, False: 1]
  ------------------
 1543|     11|  for (char32 c = 0xA8D0; c <= 0xA8D9; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1543:27): [True: 10, False: 1]
  ------------------
 1544|     11|  for (char32 c = 0xA900; c <= 0xA909; ++c) (*smap)[c] = U_Kayah_Li;
  ------------------
  |  Branch (1544:27): [True: 10, False: 1]
  ------------------
 1545|     29|  for (char32 c = 0xA90A; c <= 0xA925; ++c) (*smap)[c] = U_Kayah_Li;
  ------------------
  |  Branch (1545:27): [True: 28, False: 1]
  ------------------
 1546|      9|  for (char32 c = 0xA926; c <= 0xA92D; ++c) (*smap)[c] = U_Kayah_Li;
  ------------------
  |  Branch (1546:27): [True: 8, False: 1]
  ------------------
 1547|      1|  (*smap)[0xA92F] = U_Kayah_Li;
 1548|     24|  for (char32 c = 0xA930; c <= 0xA946; ++c) (*smap)[c] = U_Rejang;
  ------------------
  |  Branch (1548:27): [True: 23, False: 1]
  ------------------
 1549|     12|  for (char32 c = 0xA947; c <= 0xA951; ++c) (*smap)[c] = U_Rejang;
  ------------------
  |  Branch (1549:27): [True: 11, False: 1]
  ------------------
 1550|      3|  for (char32 c = 0xA952; c <= 0xA953; ++c) (*smap)[c] = U_Rejang;
  ------------------
  |  Branch (1550:27): [True: 2, False: 1]
  ------------------
 1551|      1|  (*smap)[0xA95F] = U_Rejang;
 1552|     30|  for (char32 c = 0x10280; c <= 0x1029C; ++c) (*smap)[c] = U_Lycian;
  ------------------
  |  Branch (1552:28): [True: 29, False: 1]
  ------------------
 1553|     50|  for (char32 c = 0x102A0; c <= 0x102D0; ++c) (*smap)[c] = U_Carian;
  ------------------
  |  Branch (1553:28): [True: 49, False: 1]
  ------------------
 1554|     27|  for (char32 c = 0x10920; c <= 0x10939; ++c) (*smap)[c] = U_Lydian;
  ------------------
  |  Branch (1554:28): [True: 26, False: 1]
  ------------------
 1555|      1|  (*smap)[0x1093F] = U_Lydian;
 1556|     42|  for (char32 c = 0xAA00; c <= 0xAA28; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1556:27): [True: 41, False: 1]
  ------------------
 1557|      7|  for (char32 c = 0xAA29; c <= 0xAA2E; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1557:27): [True: 6, False: 1]
  ------------------
 1558|      3|  for (char32 c = 0xAA2F; c <= 0xAA30; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1558:27): [True: 2, False: 1]
  ------------------
 1559|      3|  for (char32 c = 0xAA31; c <= 0xAA32; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1559:27): [True: 2, False: 1]
  ------------------
 1560|      3|  for (char32 c = 0xAA33; c <= 0xAA34; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1560:27): [True: 2, False: 1]
  ------------------
 1561|      3|  for (char32 c = 0xAA35; c <= 0xAA36; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1561:27): [True: 2, False: 1]
  ------------------
 1562|      4|  for (char32 c = 0xAA40; c <= 0xAA42; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1562:27): [True: 3, False: 1]
  ------------------
 1563|      1|  (*smap)[0xAA43] = U_Cham;
 1564|      9|  for (char32 c = 0xAA44; c <= 0xAA4B; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1564:27): [True: 8, False: 1]
  ------------------
 1565|      1|  (*smap)[0xAA4C] = U_Cham;
 1566|      1|  (*smap)[0xAA4D] = U_Cham;
 1567|     11|  for (char32 c = 0xAA50; c <= 0xAA59; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1567:27): [True: 10, False: 1]
  ------------------
 1568|      5|  for (char32 c = 0xAA5C; c <= 0xAA5F; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1568:27): [True: 4, False: 1]
  ------------------
 1569|     54|  for (char32 c = 0x1A20; c <= 0x1A54; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1569:27): [True: 53, False: 1]
  ------------------
 1570|      1|  (*smap)[0x1A55] = U_Tai_Tham;
 1571|      1|  (*smap)[0x1A56] = U_Tai_Tham;
 1572|      1|  (*smap)[0x1A57] = U_Tai_Tham;
 1573|      8|  for (char32 c = 0x1A58; c <= 0x1A5E; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1573:27): [True: 7, False: 1]
  ------------------
 1574|      1|  (*smap)[0x1A60] = U_Tai_Tham;
 1575|      1|  (*smap)[0x1A61] = U_Tai_Tham;
 1576|      1|  (*smap)[0x1A62] = U_Tai_Tham;
 1577|      3|  for (char32 c = 0x1A63; c <= 0x1A64; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1577:27): [True: 2, False: 1]
  ------------------
 1578|      9|  for (char32 c = 0x1A65; c <= 0x1A6C; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1578:27): [True: 8, False: 1]
  ------------------
 1579|      7|  for (char32 c = 0x1A6D; c <= 0x1A72; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1579:27): [True: 6, False: 1]
  ------------------
 1580|     11|  for (char32 c = 0x1A73; c <= 0x1A7C; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1580:27): [True: 10, False: 1]
  ------------------
 1581|      1|  (*smap)[0x1A7F] = U_Tai_Tham;
 1582|     11|  for (char32 c = 0x1A80; c <= 0x1A89; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1582:27): [True: 10, False: 1]
  ------------------
 1583|     11|  for (char32 c = 0x1A90; c <= 0x1A99; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1583:27): [True: 10, False: 1]
  ------------------
 1584|      8|  for (char32 c = 0x1AA0; c <= 0x1AA6; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1584:27): [True: 7, False: 1]
  ------------------
 1585|      1|  (*smap)[0x1AA7] = U_Tai_Tham;
 1586|      7|  for (char32 c = 0x1AA8; c <= 0x1AAD; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1586:27): [True: 6, False: 1]
  ------------------
 1587|     49|  for (char32 c = 0xAA80; c <= 0xAAAF; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1587:27): [True: 48, False: 1]
  ------------------
 1588|      1|  (*smap)[0xAAB0] = U_Tai_Viet;
 1589|      1|  (*smap)[0xAAB1] = U_Tai_Viet;
 1590|      4|  for (char32 c = 0xAAB2; c <= 0xAAB4; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1590:27): [True: 3, False: 1]
  ------------------
 1591|      3|  for (char32 c = 0xAAB5; c <= 0xAAB6; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1591:27): [True: 2, False: 1]
  ------------------
 1592|      3|  for (char32 c = 0xAAB7; c <= 0xAAB8; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1592:27): [True: 2, False: 1]
  ------------------
 1593|      6|  for (char32 c = 0xAAB9; c <= 0xAABD; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1593:27): [True: 5, False: 1]
  ------------------
 1594|      3|  for (char32 c = 0xAABE; c <= 0xAABF; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1594:27): [True: 2, False: 1]
  ------------------
 1595|      1|  (*smap)[0xAAC0] = U_Tai_Viet;
 1596|      1|  (*smap)[0xAAC1] = U_Tai_Viet;
 1597|      1|  (*smap)[0xAAC2] = U_Tai_Viet;
 1598|      3|  for (char32 c = 0xAADB; c <= 0xAADC; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1598:27): [True: 2, False: 1]
  ------------------
 1599|      1|  (*smap)[0xAADD] = U_Tai_Viet;
 1600|      3|  for (char32 c = 0xAADE; c <= 0xAADF; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1600:27): [True: 2, False: 1]
  ------------------
 1601|     55|  for (char32 c = 0x10B00; c <= 0x10B35; ++c) (*smap)[c] = U_Avestan;
  ------------------
  |  Branch (1601:28): [True: 54, False: 1]
  ------------------
 1602|      8|  for (char32 c = 0x10B39; c <= 0x10B3F; ++c) (*smap)[c] = U_Avestan;
  ------------------
  |  Branch (1602:28): [True: 7, False: 1]
  ------------------
 1603|  1.07k|  for (char32 c = 0x13000; c <= 0x1342E; ++c)
  ------------------
  |  Branch (1603:28): [True: 1.07k, False: 1]
  ------------------
 1604|  1.07k|    (*smap)[c] = U_Egyptian_Hieroglyphs;
 1605|     23|  for (char32 c = 0x0800; c <= 0x0815; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1605:27): [True: 22, False: 1]
  ------------------
 1606|      5|  for (char32 c = 0x0816; c <= 0x0819; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1606:27): [True: 4, False: 1]
  ------------------
 1607|      1|  (*smap)[0x081A] = U_Samaritan;
 1608|     10|  for (char32 c = 0x081B; c <= 0x0823; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1608:27): [True: 9, False: 1]
  ------------------
 1609|      1|  (*smap)[0x0824] = U_Samaritan;
 1610|      4|  for (char32 c = 0x0825; c <= 0x0827; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1610:27): [True: 3, False: 1]
  ------------------
 1611|      1|  (*smap)[0x0828] = U_Samaritan;
 1612|      6|  for (char32 c = 0x0829; c <= 0x082D; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1612:27): [True: 5, False: 1]
  ------------------
 1613|     16|  for (char32 c = 0x0830; c <= 0x083E; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1613:27): [True: 15, False: 1]
  ------------------
 1614|     41|  for (char32 c = 0xA4D0; c <= 0xA4F7; ++c) (*smap)[c] = U_Lisu;
  ------------------
  |  Branch (1614:27): [True: 40, False: 1]
  ------------------
 1615|      7|  for (char32 c = 0xA4F8; c <= 0xA4FD; ++c) (*smap)[c] = U_Lisu;
  ------------------
  |  Branch (1615:27): [True: 6, False: 1]
  ------------------
 1616|      3|  for (char32 c = 0xA4FE; c <= 0xA4FF; ++c) (*smap)[c] = U_Lisu;
  ------------------
  |  Branch (1616:27): [True: 2, False: 1]
  ------------------
 1617|     71|  for (char32 c = 0xA6A0; c <= 0xA6E5; ++c) (*smap)[c] = U_Bamum;
  ------------------
  |  Branch (1617:27): [True: 70, False: 1]
  ------------------
 1618|     11|  for (char32 c = 0xA6E6; c <= 0xA6EF; ++c) (*smap)[c] = U_Bamum;
  ------------------
  |  Branch (1618:27): [True: 10, False: 1]
  ------------------
 1619|      3|  for (char32 c = 0xA6F0; c <= 0xA6F1; ++c) (*smap)[c] = U_Bamum;
  ------------------
  |  Branch (1619:27): [True: 2, False: 1]
  ------------------
 1620|      7|  for (char32 c = 0xA6F2; c <= 0xA6F7; ++c) (*smap)[c] = U_Bamum;
  ------------------
  |  Branch (1620:27): [True: 6, False: 1]
  ------------------
 1621|    570|  for (char32 c = 0x16800; c <= 0x16A38; ++c) (*smap)[c] = U_Bamum;
  ------------------
  |  Branch (1621:28): [True: 569, False: 1]
  ------------------
 1622|      4|  for (char32 c = 0xA980; c <= 0xA982; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1622:27): [True: 3, False: 1]
  ------------------
 1623|      1|  (*smap)[0xA983] = U_Javanese;
 1624|     48|  for (char32 c = 0xA984; c <= 0xA9B2; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1624:27): [True: 47, False: 1]
  ------------------
 1625|      1|  (*smap)[0xA9B3] = U_Javanese;
 1626|      3|  for (char32 c = 0xA9B4; c <= 0xA9B5; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1626:27): [True: 2, False: 1]
  ------------------
 1627|      5|  for (char32 c = 0xA9B6; c <= 0xA9B9; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1627:27): [True: 4, False: 1]
  ------------------
 1628|      3|  for (char32 c = 0xA9BA; c <= 0xA9BB; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1628:27): [True: 2, False: 1]
  ------------------
 1629|      1|  (*smap)[0xA9BC] = U_Javanese;
 1630|      5|  for (char32 c = 0xA9BD; c <= 0xA9C0; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1630:27): [True: 4, False: 1]
  ------------------
 1631|     14|  for (char32 c = 0xA9C1; c <= 0xA9CD; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1631:27): [True: 13, False: 1]
  ------------------
 1632|     11|  for (char32 c = 0xA9D0; c <= 0xA9D9; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1632:27): [True: 10, False: 1]
  ------------------
 1633|      3|  for (char32 c = 0xA9DE; c <= 0xA9DF; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1633:27): [True: 2, False: 1]
  ------------------
 1634|     12|  for (char32 c = 0xAAE0; c <= 0xAAEA; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1634:27): [True: 11, False: 1]
  ------------------
 1635|      1|  (*smap)[0xAAEB] = U_Meetei_Mayek;
 1636|      3|  for (char32 c = 0xAAEC; c <= 0xAAED; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1636:27): [True: 2, False: 1]
  ------------------
 1637|      3|  for (char32 c = 0xAAEE; c <= 0xAAEF; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1637:27): [True: 2, False: 1]
  ------------------
 1638|      3|  for (char32 c = 0xAAF0; c <= 0xAAF1; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1638:27): [True: 2, False: 1]
  ------------------
 1639|      1|  (*smap)[0xAAF2] = U_Meetei_Mayek;
 1640|      3|  for (char32 c = 0xAAF3; c <= 0xAAF4; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1640:27): [True: 2, False: 1]
  ------------------
 1641|      1|  (*smap)[0xAAF5] = U_Meetei_Mayek;
 1642|      1|  (*smap)[0xAAF6] = U_Meetei_Mayek;
 1643|     36|  for (char32 c = 0xABC0; c <= 0xABE2; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1643:27): [True: 35, False: 1]
  ------------------
 1644|      3|  for (char32 c = 0xABE3; c <= 0xABE4; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1644:27): [True: 2, False: 1]
  ------------------
 1645|      1|  (*smap)[0xABE5] = U_Meetei_Mayek;
 1646|      3|  for (char32 c = 0xABE6; c <= 0xABE7; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1646:27): [True: 2, False: 1]
  ------------------
 1647|      1|  (*smap)[0xABE8] = U_Meetei_Mayek;
 1648|      3|  for (char32 c = 0xABE9; c <= 0xABEA; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1648:27): [True: 2, False: 1]
  ------------------
 1649|      1|  (*smap)[0xABEB] = U_Meetei_Mayek;
 1650|      1|  (*smap)[0xABEC] = U_Meetei_Mayek;
 1651|      1|  (*smap)[0xABED] = U_Meetei_Mayek;
 1652|     11|  for (char32 c = 0xABF0; c <= 0xABF9; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1652:27): [True: 10, False: 1]
  ------------------
 1653|     23|  for (char32 c = 0x10840; c <= 0x10855; ++c) (*smap)[c] = U_Imperial_Aramaic;
  ------------------
  |  Branch (1653:28): [True: 22, False: 1]
  ------------------
 1654|      1|  (*smap)[0x10857] = U_Imperial_Aramaic;
 1655|      9|  for (char32 c = 0x10858; c <= 0x1085F; ++c) (*smap)[c] = U_Imperial_Aramaic;
  ------------------
  |  Branch (1655:28): [True: 8, False: 1]
  ------------------
 1656|     30|  for (char32 c = 0x10A60; c <= 0x10A7C; ++c) (*smap)[c] = U_Old_South_Arabian;
  ------------------
  |  Branch (1656:28): [True: 29, False: 1]
  ------------------
 1657|      3|  for (char32 c = 0x10A7D; c <= 0x10A7E; ++c) (*smap)[c] = U_Old_South_Arabian;
  ------------------
  |  Branch (1657:28): [True: 2, False: 1]
  ------------------
 1658|      1|  (*smap)[0x10A7F] = U_Old_South_Arabian;
 1659|     23|  for (char32 c = 0x10B40; c <= 0x10B55; ++c)
  ------------------
  |  Branch (1659:28): [True: 22, False: 1]
  ------------------
 1660|     22|    (*smap)[c] = U_Inscriptional_Parthian;
 1661|      9|  for (char32 c = 0x10B58; c <= 0x10B5F; ++c)
  ------------------
  |  Branch (1661:28): [True: 8, False: 1]
  ------------------
 1662|      8|    (*smap)[c] = U_Inscriptional_Parthian;
 1663|     20|  for (char32 c = 0x10B60; c <= 0x10B72; ++c)
  ------------------
  |  Branch (1663:28): [True: 19, False: 1]
  ------------------
 1664|     19|    (*smap)[c] = U_Inscriptional_Pahlavi;
 1665|      9|  for (char32 c = 0x10B78; c <= 0x10B7F; ++c)
  ------------------
  |  Branch (1665:28): [True: 8, False: 1]
  ------------------
 1666|      8|    (*smap)[c] = U_Inscriptional_Pahlavi;
 1667|     74|  for (char32 c = 0x10C00; c <= 0x10C48; ++c) (*smap)[c] = U_Old_Turkic;
  ------------------
  |  Branch (1667:28): [True: 73, False: 1]
  ------------------
 1668|      3|  for (char32 c = 0x11080; c <= 0x11081; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1668:28): [True: 2, False: 1]
  ------------------
 1669|      1|  (*smap)[0x11082] = U_Kaithi;
 1670|     46|  for (char32 c = 0x11083; c <= 0x110AF; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1670:28): [True: 45, False: 1]
  ------------------
 1671|      4|  for (char32 c = 0x110B0; c <= 0x110B2; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1671:28): [True: 3, False: 1]
  ------------------
 1672|      5|  for (char32 c = 0x110B3; c <= 0x110B6; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1672:28): [True: 4, False: 1]
  ------------------
 1673|      3|  for (char32 c = 0x110B7; c <= 0x110B8; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1673:28): [True: 2, False: 1]
  ------------------
 1674|      3|  for (char32 c = 0x110B9; c <= 0x110BA; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1674:28): [True: 2, False: 1]
  ------------------
 1675|      3|  for (char32 c = 0x110BB; c <= 0x110BC; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1675:28): [True: 2, False: 1]
  ------------------
 1676|      1|  (*smap)[0x110BD] = U_Kaithi;
 1677|      5|  for (char32 c = 0x110BE; c <= 0x110C1; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1677:28): [True: 4, False: 1]
  ------------------
 1678|     39|  for (char32 c = 0x1BC0; c <= 0x1BE5; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1678:27): [True: 38, False: 1]
  ------------------
 1679|      1|  (*smap)[0x1BE6] = U_Batak;
 1680|      1|  (*smap)[0x1BE7] = U_Batak;
 1681|      3|  for (char32 c = 0x1BE8; c <= 0x1BE9; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1681:27): [True: 2, False: 1]
  ------------------
 1682|      4|  for (char32 c = 0x1BEA; c <= 0x1BEC; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1682:27): [True: 3, False: 1]
  ------------------
 1683|      1|  (*smap)[0x1BED] = U_Batak;
 1684|      1|  (*smap)[0x1BEE] = U_Batak;
 1685|      4|  for (char32 c = 0x1BEF; c <= 0x1BF1; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1685:27): [True: 3, False: 1]
  ------------------
 1686|      3|  for (char32 c = 0x1BF2; c <= 0x1BF3; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1686:27): [True: 2, False: 1]
  ------------------
 1687|      5|  for (char32 c = 0x1BFC; c <= 0x1BFF; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1687:27): [True: 4, False: 1]
  ------------------
 1688|      1|  (*smap)[0x11000] = U_Brahmi;
 1689|      1|  (*smap)[0x11001] = U_Brahmi;
 1690|      1|  (*smap)[0x11002] = U_Brahmi;
 1691|     54|  for (char32 c = 0x11003; c <= 0x11037; ++c) (*smap)[c] = U_Brahmi;
  ------------------
  |  Branch (1691:28): [True: 53, False: 1]
  ------------------
 1692|     16|  for (char32 c = 0x11038; c <= 0x11046; ++c) (*smap)[c] = U_Brahmi;
  ------------------
  |  Branch (1692:28): [True: 15, False: 1]
  ------------------
 1693|      8|  for (char32 c = 0x11047; c <= 0x1104D; ++c) (*smap)[c] = U_Brahmi;
  ------------------
  |  Branch (1693:28): [True: 7, False: 1]
  ------------------
 1694|     21|  for (char32 c = 0x11052; c <= 0x11065; ++c) (*smap)[c] = U_Brahmi;
  ------------------
  |  Branch (1694:28): [True: 20, False: 1]
  ------------------
 1695|     11|  for (char32 c = 0x11066; c <= 0x1106F; ++c) (*smap)[c] = U_Brahmi;
  ------------------
  |  Branch (1695:28): [True: 10, False: 1]
  ------------------
 1696|      1|  (*smap)[0x1107F] = U_Brahmi;
 1697|     26|  for (char32 c = 0x0840; c <= 0x0858; ++c) (*smap)[c] = U_Mandaic;
  ------------------
  |  Branch (1697:27): [True: 25, False: 1]
  ------------------
 1698|      4|  for (char32 c = 0x0859; c <= 0x085B; ++c) (*smap)[c] = U_Mandaic;
  ------------------
  |  Branch (1698:27): [True: 3, False: 1]
  ------------------
 1699|      1|  (*smap)[0x085E] = U_Mandaic;
 1700|      4|  for (char32 c = 0x11100; c <= 0x11102; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1700:28): [True: 3, False: 1]
  ------------------
 1701|     37|  for (char32 c = 0x11103; c <= 0x11126; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1701:28): [True: 36, False: 1]
  ------------------
 1702|      6|  for (char32 c = 0x11127; c <= 0x1112B; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1702:28): [True: 5, False: 1]
  ------------------
 1703|      1|  (*smap)[0x1112C] = U_Chakma;
 1704|      9|  for (char32 c = 0x1112D; c <= 0x11134; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1704:28): [True: 8, False: 1]
  ------------------
 1705|     11|  for (char32 c = 0x11136; c <= 0x1113F; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1705:28): [True: 10, False: 1]
  ------------------
 1706|      5|  for (char32 c = 0x11140; c <= 0x11143; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1706:28): [True: 4, False: 1]
  ------------------
 1707|     25|  for (char32 c = 0x109A0; c <= 0x109B7; ++c) (*smap)[c] = U_Meroitic_Cursive;
  ------------------
  |  Branch (1707:28): [True: 24, False: 1]
  ------------------
 1708|      3|  for (char32 c = 0x109BC; c <= 0x109BD; ++c) (*smap)[c] = U_Meroitic_Cursive;
  ------------------
  |  Branch (1708:28): [True: 2, False: 1]
  ------------------
 1709|      3|  for (char32 c = 0x109BE; c <= 0x109BF; ++c) (*smap)[c] = U_Meroitic_Cursive;
  ------------------
  |  Branch (1709:28): [True: 2, False: 1]
  ------------------
 1710|     17|  for (char32 c = 0x109C0; c <= 0x109CF; ++c) (*smap)[c] = U_Meroitic_Cursive;
  ------------------
  |  Branch (1710:28): [True: 16, False: 1]
  ------------------
 1711|     47|  for (char32 c = 0x109D2; c <= 0x109FF; ++c) (*smap)[c] = U_Meroitic_Cursive;
  ------------------
  |  Branch (1711:28): [True: 46, False: 1]
  ------------------
 1712|     33|  for (char32 c = 0x10980; c <= 0x1099F; ++c)
  ------------------
  |  Branch (1712:28): [True: 32, False: 1]
  ------------------
 1713|     32|    (*smap)[c] = U_Meroitic_Hieroglyphs;
 1714|     70|  for (char32 c = 0x16F00; c <= 0x16F44; ++c) (*smap)[c] = U_Miao;
  ------------------
  |  Branch (1714:28): [True: 69, False: 1]
  ------------------
 1715|      1|  (*smap)[0x16F50] = U_Miao;
 1716|     47|  for (char32 c = 0x16F51; c <= 0x16F7E; ++c) (*smap)[c] = U_Miao;
  ------------------
  |  Branch (1716:28): [True: 46, False: 1]
  ------------------
 1717|      5|  for (char32 c = 0x16F8F; c <= 0x16F92; ++c) (*smap)[c] = U_Miao;
  ------------------
  |  Branch (1717:28): [True: 4, False: 1]
  ------------------
 1718|     14|  for (char32 c = 0x16F93; c <= 0x16F9F; ++c) (*smap)[c] = U_Miao;
  ------------------
  |  Branch (1718:28): [True: 13, False: 1]
  ------------------
 1719|      3|  for (char32 c = 0x11180; c <= 0x11181; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1719:28): [True: 2, False: 1]
  ------------------
 1720|      1|  (*smap)[0x11182] = U_Sharada;
 1721|     49|  for (char32 c = 0x11183; c <= 0x111B2; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1721:28): [True: 48, False: 1]
  ------------------
 1722|      4|  for (char32 c = 0x111B3; c <= 0x111B5; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1722:28): [True: 3, False: 1]
  ------------------
 1723|     10|  for (char32 c = 0x111B6; c <= 0x111BE; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1723:28): [True: 9, False: 1]
  ------------------
 1724|      3|  for (char32 c = 0x111BF; c <= 0x111C0; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1724:28): [True: 2, False: 1]
  ------------------
 1725|      5|  for (char32 c = 0x111C1; c <= 0x111C4; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1725:28): [True: 4, False: 1]
  ------------------
 1726|      6|  for (char32 c = 0x111C5; c <= 0x111C9; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1726:28): [True: 5, False: 1]
  ------------------
 1727|      4|  for (char32 c = 0x111CA; c <= 0x111CC; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1727:28): [True: 3, False: 1]
  ------------------
 1728|      1|  (*smap)[0x111CD] = U_Sharada;
 1729|     11|  for (char32 c = 0x111D0; c <= 0x111D9; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1729:28): [True: 10, False: 1]
  ------------------
 1730|      1|  (*smap)[0x111DA] = U_Sharada;
 1731|      1|  (*smap)[0x111DB] = U_Sharada;
 1732|      1|  (*smap)[0x111DC] = U_Sharada;
 1733|      4|  for (char32 c = 0x111DD; c <= 0x111DF; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1733:28): [True: 3, False: 1]
  ------------------
 1734|     26|  for (char32 c = 0x110D0; c <= 0x110E8; ++c) (*smap)[c] = U_Sora_Sompeng;
  ------------------
  |  Branch (1734:28): [True: 25, False: 1]
  ------------------
 1735|     11|  for (char32 c = 0x110F0; c <= 0x110F9; ++c) (*smap)[c] = U_Sora_Sompeng;
  ------------------
  |  Branch (1735:28): [True: 10, False: 1]
  ------------------
 1736|     44|  for (char32 c = 0x11680; c <= 0x116AA; ++c) (*smap)[c] = U_Takri;
  ------------------
  |  Branch (1736:28): [True: 43, False: 1]
  ------------------
 1737|      1|  (*smap)[0x116AB] = U_Takri;
 1738|      1|  (*smap)[0x116AC] = U_Takri;
 1739|      1|  (*smap)[0x116AD] = U_Takri;
 1740|      3|  for (char32 c = 0x116AE; c <= 0x116AF; ++c) (*smap)[c] = U_Takri;
  ------------------
  |  Branch (1740:28): [True: 2, False: 1]
  ------------------
 1741|      7|  for (char32 c = 0x116B0; c <= 0x116B5; ++c) (*smap)[c] = U_Takri;
  ------------------
  |  Branch (1741:28): [True: 6, False: 1]
  ------------------
 1742|      1|  (*smap)[0x116B6] = U_Takri;
 1743|      1|  (*smap)[0x116B7] = U_Takri;
 1744|     11|  for (char32 c = 0x116C0; c <= 0x116C9; ++c) (*smap)[c] = U_Takri;
  ------------------
  |  Branch (1744:28): [True: 10, False: 1]
  ------------------
 1745|     53|  for (char32 c = 0x10530; c <= 0x10563; ++c) (*smap)[c] = U_Caucasian_Albanian;
  ------------------
  |  Branch (1745:28): [True: 52, False: 1]
  ------------------
 1746|      1|  (*smap)[0x1056F] = U_Caucasian_Albanian;
 1747|     31|  for (char32 c = 0x16AD0; c <= 0x16AED; ++c) (*smap)[c] = U_Bassa_Vah;
  ------------------
  |  Branch (1747:28): [True: 30, False: 1]
  ------------------
 1748|      6|  for (char32 c = 0x16AF0; c <= 0x16AF4; ++c) (*smap)[c] = U_Bassa_Vah;
  ------------------
  |  Branch (1748:28): [True: 5, False: 1]
  ------------------
 1749|      1|  (*smap)[0x16AF5] = U_Bassa_Vah;
 1750|    108|  for (char32 c = 0x1BC00; c <= 0x1BC6A; ++c) (*smap)[c] = U_Duployan;
  ------------------
  |  Branch (1750:28): [True: 107, False: 1]
  ------------------
 1751|     14|  for (char32 c = 0x1BC70; c <= 0x1BC7C; ++c) (*smap)[c] = U_Duployan;
  ------------------
  |  Branch (1751:28): [True: 13, False: 1]
  ------------------
 1752|     10|  for (char32 c = 0x1BC80; c <= 0x1BC88; ++c) (*smap)[c] = U_Duployan;
  ------------------
  |  Branch (1752:28): [True: 9, False: 1]
  ------------------
 1753|     11|  for (char32 c = 0x1BC90; c <= 0x1BC99; ++c) (*smap)[c] = U_Duployan;
  ------------------
  |  Branch (1753:28): [True: 10, False: 1]
  ------------------
 1754|      1|  (*smap)[0x1BC9C] = U_Duployan;
 1755|      3|  for (char32 c = 0x1BC9D; c <= 0x1BC9E; ++c) (*smap)[c] = U_Duployan;
  ------------------
  |  Branch (1755:28): [True: 2, False: 1]
  ------------------
 1756|      1|  (*smap)[0x1BC9F] = U_Duployan;
 1757|     41|  for (char32 c = 0x10500; c <= 0x10527; ++c) (*smap)[c] = U_Elbasan;
  ------------------
  |  Branch (1757:28): [True: 40, False: 1]
  ------------------
 1758|      3|  for (char32 c = 0x11300; c <= 0x11301; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1758:28): [True: 2, False: 1]
  ------------------
 1759|      3|  for (char32 c = 0x11302; c <= 0x11303; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1759:28): [True: 2, False: 1]
  ------------------
 1760|      9|  for (char32 c = 0x11305; c <= 0x1130C; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1760:28): [True: 8, False: 1]
  ------------------
 1761|      3|  for (char32 c = 0x1130F; c <= 0x11310; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1761:28): [True: 2, False: 1]
  ------------------
 1762|     23|  for (char32 c = 0x11313; c <= 0x11328; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1762:28): [True: 22, False: 1]
  ------------------
 1763|      8|  for (char32 c = 0x1132A; c <= 0x11330; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1763:28): [True: 7, False: 1]
  ------------------
 1764|      3|  for (char32 c = 0x11332; c <= 0x11333; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1764:28): [True: 2, False: 1]
  ------------------
 1765|      6|  for (char32 c = 0x11335; c <= 0x11339; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1765:28): [True: 5, False: 1]
  ------------------
 1766|      1|  (*smap)[0x1133C] = U_Grantha;
 1767|      1|  (*smap)[0x1133D] = U_Grantha;
 1768|      3|  for (char32 c = 0x1133E; c <= 0x1133F; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1768:28): [True: 2, False: 1]
  ------------------
 1769|      1|  (*smap)[0x11340] = U_Grantha;
 1770|      5|  for (char32 c = 0x11341; c <= 0x11344; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1770:28): [True: 4, False: 1]
  ------------------
 1771|      3|  for (char32 c = 0x11347; c <= 0x11348; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1771:28): [True: 2, False: 1]
  ------------------
 1772|      4|  for (char32 c = 0x1134B; c <= 0x1134D; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1772:28): [True: 3, False: 1]
  ------------------
 1773|      1|  (*smap)[0x11350] = U_Grantha;
 1774|      1|  (*smap)[0x11357] = U_Grantha;
 1775|      6|  for (char32 c = 0x1135D; c <= 0x11361; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1775:28): [True: 5, False: 1]
  ------------------
 1776|      3|  for (char32 c = 0x11362; c <= 0x11363; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1776:28): [True: 2, False: 1]
  ------------------
 1777|      8|  for (char32 c = 0x11366; c <= 0x1136C; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1777:28): [True: 7, False: 1]
  ------------------
 1778|      6|  for (char32 c = 0x11370; c <= 0x11374; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1778:28): [True: 5, False: 1]
  ------------------
 1779|     49|  for (char32 c = 0x16B00; c <= 0x16B2F; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1779:28): [True: 48, False: 1]
  ------------------
 1780|      8|  for (char32 c = 0x16B30; c <= 0x16B36; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1780:28): [True: 7, False: 1]
  ------------------
 1781|      6|  for (char32 c = 0x16B37; c <= 0x16B3B; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1781:28): [True: 5, False: 1]
  ------------------
 1782|      5|  for (char32 c = 0x16B3C; c <= 0x16B3F; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1782:28): [True: 4, False: 1]
  ------------------
 1783|      5|  for (char32 c = 0x16B40; c <= 0x16B43; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1783:28): [True: 4, False: 1]
  ------------------
 1784|      1|  (*smap)[0x16B44] = U_Pahawh_Hmong;
 1785|      1|  (*smap)[0x16B45] = U_Pahawh_Hmong;
 1786|     11|  for (char32 c = 0x16B50; c <= 0x16B59; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1786:28): [True: 10, False: 1]
  ------------------
 1787|      8|  for (char32 c = 0x16B5B; c <= 0x16B61; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1787:28): [True: 7, False: 1]
  ------------------
 1788|     22|  for (char32 c = 0x16B63; c <= 0x16B77; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1788:28): [True: 21, False: 1]
  ------------------
 1789|     20|  for (char32 c = 0x16B7D; c <= 0x16B8F; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1789:28): [True: 19, False: 1]
  ------------------
 1790|     19|  for (char32 c = 0x11200; c <= 0x11211; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1790:28): [True: 18, False: 1]
  ------------------
 1791|     26|  for (char32 c = 0x11213; c <= 0x1122B; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1791:28): [True: 25, False: 1]
  ------------------
 1792|      4|  for (char32 c = 0x1122C; c <= 0x1122E; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1792:28): [True: 3, False: 1]
  ------------------
 1793|      4|  for (char32 c = 0x1122F; c <= 0x11231; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1793:28): [True: 3, False: 1]
  ------------------
 1794|      3|  for (char32 c = 0x11232; c <= 0x11233; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1794:28): [True: 2, False: 1]
  ------------------
 1795|      1|  (*smap)[0x11234] = U_Khojki;
 1796|      1|  (*smap)[0x11235] = U_Khojki;
 1797|      3|  for (char32 c = 0x11236; c <= 0x11237; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1797:28): [True: 2, False: 1]
  ------------------
 1798|      7|  for (char32 c = 0x11238; c <= 0x1123D; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1798:28): [True: 6, False: 1]
  ------------------
 1799|      1|  (*smap)[0x1123E] = U_Khojki;
 1800|    312|  for (char32 c = 0x10600; c <= 0x10736; ++c) (*smap)[c] = U_Linear_A;
  ------------------
  |  Branch (1800:28): [True: 311, False: 1]
  ------------------
 1801|     23|  for (char32 c = 0x10740; c <= 0x10755; ++c) (*smap)[c] = U_Linear_A;
  ------------------
  |  Branch (1801:28): [True: 22, False: 1]
  ------------------
 1802|      9|  for (char32 c = 0x10760; c <= 0x10767; ++c) (*smap)[c] = U_Linear_A;
  ------------------
  |  Branch (1802:28): [True: 8, False: 1]
  ------------------
 1803|     36|  for (char32 c = 0x11150; c <= 0x11172; ++c) (*smap)[c] = U_Mahajani;
  ------------------
  |  Branch (1803:28): [True: 35, False: 1]
  ------------------
 1804|      1|  (*smap)[0x11173] = U_Mahajani;
 1805|      3|  for (char32 c = 0x11174; c <= 0x11175; ++c) (*smap)[c] = U_Mahajani;
  ------------------
  |  Branch (1805:28): [True: 2, False: 1]
  ------------------
 1806|      1|  (*smap)[0x11176] = U_Mahajani;
 1807|      9|  for (char32 c = 0x10AC0; c <= 0x10AC7; ++c) (*smap)[c] = U_Manichaean;
  ------------------
  |  Branch (1807:28): [True: 8, False: 1]
  ------------------
 1808|      1|  (*smap)[0x10AC8] = U_Manichaean;
 1809|     29|  for (char32 c = 0x10AC9; c <= 0x10AE4; ++c) (*smap)[c] = U_Manichaean;
  ------------------
  |  Branch (1809:28): [True: 28, False: 1]
  ------------------
 1810|      3|  for (char32 c = 0x10AE5; c <= 0x10AE6; ++c) (*smap)[c] = U_Manichaean;
  ------------------
  |  Branch (1810:28): [True: 2, False: 1]
  ------------------
 1811|      6|  for (char32 c = 0x10AEB; c <= 0x10AEF; ++c) (*smap)[c] = U_Manichaean;
  ------------------
  |  Branch (1811:28): [True: 5, False: 1]
  ------------------
 1812|      8|  for (char32 c = 0x10AF0; c <= 0x10AF6; ++c) (*smap)[c] = U_Manichaean;
  ------------------
  |  Branch (1812:28): [True: 7, False: 1]
  ------------------
 1813|    198|  for (char32 c = 0x1E800; c <= 0x1E8C4; ++c) (*smap)[c] = U_Mende_Kikakui;
  ------------------
  |  Branch (1813:28): [True: 197, False: 1]
  ------------------
 1814|     10|  for (char32 c = 0x1E8C7; c <= 0x1E8CF; ++c) (*smap)[c] = U_Mende_Kikakui;
  ------------------
  |  Branch (1814:28): [True: 9, False: 1]
  ------------------
 1815|      8|  for (char32 c = 0x1E8D0; c <= 0x1E8D6; ++c) (*smap)[c] = U_Mende_Kikakui;
  ------------------
  |  Branch (1815:28): [True: 7, False: 1]
  ------------------
 1816|     49|  for (char32 c = 0x11600; c <= 0x1162F; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1816:28): [True: 48, False: 1]
  ------------------
 1817|      4|  for (char32 c = 0x11630; c <= 0x11632; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1817:28): [True: 3, False: 1]
  ------------------
 1818|      9|  for (char32 c = 0x11633; c <= 0x1163A; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1818:28): [True: 8, False: 1]
  ------------------
 1819|      3|  for (char32 c = 0x1163B; c <= 0x1163C; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1819:28): [True: 2, False: 1]
  ------------------
 1820|      1|  (*smap)[0x1163D] = U_Modi;
 1821|      1|  (*smap)[0x1163E] = U_Modi;
 1822|      3|  for (char32 c = 0x1163F; c <= 0x11640; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1822:28): [True: 2, False: 1]
  ------------------
 1823|      4|  for (char32 c = 0x11641; c <= 0x11643; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1823:28): [True: 3, False: 1]
  ------------------
 1824|      1|  (*smap)[0x11644] = U_Modi;
 1825|     11|  for (char32 c = 0x11650; c <= 0x11659; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1825:28): [True: 10, False: 1]
  ------------------
 1826|     32|  for (char32 c = 0x16A40; c <= 0x16A5E; ++c) (*smap)[c] = U_Mro;
  ------------------
  |  Branch (1826:28): [True: 31, False: 1]
  ------------------
 1827|     11|  for (char32 c = 0x16A60; c <= 0x16A69; ++c) (*smap)[c] = U_Mro;
  ------------------
  |  Branch (1827:28): [True: 10, False: 1]
  ------------------
 1828|      3|  for (char32 c = 0x16A6E; c <= 0x16A6F; ++c) (*smap)[c] = U_Mro;
  ------------------
  |  Branch (1828:28): [True: 2, False: 1]
  ------------------
 1829|     30|  for (char32 c = 0x10A80; c <= 0x10A9C; ++c) (*smap)[c] = U_Old_North_Arabian;
  ------------------
  |  Branch (1829:28): [True: 29, False: 1]
  ------------------
 1830|      4|  for (char32 c = 0x10A9D; c <= 0x10A9F; ++c) (*smap)[c] = U_Old_North_Arabian;
  ------------------
  |  Branch (1830:28): [True: 3, False: 1]
  ------------------
 1831|     32|  for (char32 c = 0x10880; c <= 0x1089E; ++c) (*smap)[c] = U_Nabataean;
  ------------------
  |  Branch (1831:28): [True: 31, False: 1]
  ------------------
 1832|     10|  for (char32 c = 0x108A7; c <= 0x108AF; ++c) (*smap)[c] = U_Nabataean;
  ------------------
  |  Branch (1832:28): [True: 9, False: 1]
  ------------------
 1833|     24|  for (char32 c = 0x10860; c <= 0x10876; ++c) (*smap)[c] = U_Palmyrene;
  ------------------
  |  Branch (1833:28): [True: 23, False: 1]
  ------------------
 1834|      3|  for (char32 c = 0x10877; c <= 0x10878; ++c) (*smap)[c] = U_Palmyrene;
  ------------------
  |  Branch (1834:28): [True: 2, False: 1]
  ------------------
 1835|      8|  for (char32 c = 0x10879; c <= 0x1087F; ++c) (*smap)[c] = U_Palmyrene;
  ------------------
  |  Branch (1835:28): [True: 7, False: 1]
  ------------------
 1836|     58|  for (char32 c = 0x11AC0; c <= 0x11AF8; ++c) (*smap)[c] = U_Pau_Cin_Hau;
  ------------------
  |  Branch (1836:28): [True: 57, False: 1]
  ------------------
 1837|     39|  for (char32 c = 0x10350; c <= 0x10375; ++c) (*smap)[c] = U_Old_Permic;
  ------------------
  |  Branch (1837:28): [True: 38, False: 1]
  ------------------
 1838|      6|  for (char32 c = 0x10376; c <= 0x1037A; ++c) (*smap)[c] = U_Old_Permic;
  ------------------
  |  Branch (1838:28): [True: 5, False: 1]
  ------------------
 1839|     19|  for (char32 c = 0x10B80; c <= 0x10B91; ++c) (*smap)[c] = U_Psalter_Pahlavi;
  ------------------
  |  Branch (1839:28): [True: 18, False: 1]
  ------------------
 1840|      5|  for (char32 c = 0x10B99; c <= 0x10B9C; ++c) (*smap)[c] = U_Psalter_Pahlavi;
  ------------------
  |  Branch (1840:28): [True: 4, False: 1]
  ------------------
 1841|      8|  for (char32 c = 0x10BA9; c <= 0x10BAF; ++c) (*smap)[c] = U_Psalter_Pahlavi;
  ------------------
  |  Branch (1841:28): [True: 7, False: 1]
  ------------------
 1842|     48|  for (char32 c = 0x11580; c <= 0x115AE; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1842:28): [True: 47, False: 1]
  ------------------
 1843|      4|  for (char32 c = 0x115AF; c <= 0x115B1; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1843:28): [True: 3, False: 1]
  ------------------
 1844|      5|  for (char32 c = 0x115B2; c <= 0x115B5; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1844:28): [True: 4, False: 1]
  ------------------
 1845|      5|  for (char32 c = 0x115B8; c <= 0x115BB; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1845:28): [True: 4, False: 1]
  ------------------
 1846|      3|  for (char32 c = 0x115BC; c <= 0x115BD; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1846:28): [True: 2, False: 1]
  ------------------
 1847|      1|  (*smap)[0x115BE] = U_Siddham;
 1848|      3|  for (char32 c = 0x115BF; c <= 0x115C0; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1848:28): [True: 2, False: 1]
  ------------------
 1849|     24|  for (char32 c = 0x115C1; c <= 0x115D7; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1849:28): [True: 23, False: 1]
  ------------------
 1850|      5|  for (char32 c = 0x115D8; c <= 0x115DB; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1850:28): [True: 4, False: 1]
  ------------------
 1851|      3|  for (char32 c = 0x115DC; c <= 0x115DD; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1851:28): [True: 2, False: 1]
  ------------------
 1852|     48|  for (char32 c = 0x112B0; c <= 0x112DE; ++c) (*smap)[c] = U_Khudawadi;
  ------------------
  |  Branch (1852:28): [True: 47, False: 1]
  ------------------
 1853|      1|  (*smap)[0x112DF] = U_Khudawadi;
 1854|      4|  for (char32 c = 0x112E0; c <= 0x112E2; ++c) (*smap)[c] = U_Khudawadi;
  ------------------
  |  Branch (1854:28): [True: 3, False: 1]
  ------------------
 1855|      9|  for (char32 c = 0x112E3; c <= 0x112EA; ++c) (*smap)[c] = U_Khudawadi;
  ------------------
  |  Branch (1855:28): [True: 8, False: 1]
  ------------------
 1856|     11|  for (char32 c = 0x112F0; c <= 0x112F9; ++c) (*smap)[c] = U_Khudawadi;
  ------------------
  |  Branch (1856:28): [True: 10, False: 1]
  ------------------
 1857|     49|  for (char32 c = 0x11480; c <= 0x114AF; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1857:28): [True: 48, False: 1]
  ------------------
 1858|      4|  for (char32 c = 0x114B0; c <= 0x114B2; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1858:28): [True: 3, False: 1]
  ------------------
 1859|      7|  for (char32 c = 0x114B3; c <= 0x114B8; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1859:28): [True: 6, False: 1]
  ------------------
 1860|      1|  (*smap)[0x114B9] = U_Tirhuta;
 1861|      1|  (*smap)[0x114BA] = U_Tirhuta;
 1862|      5|  for (char32 c = 0x114BB; c <= 0x114BE; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1862:28): [True: 4, False: 1]
  ------------------
 1863|      3|  for (char32 c = 0x114BF; c <= 0x114C0; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1863:28): [True: 2, False: 1]
  ------------------
 1864|      1|  (*smap)[0x114C1] = U_Tirhuta;
 1865|      3|  for (char32 c = 0x114C2; c <= 0x114C3; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1865:28): [True: 2, False: 1]
  ------------------
 1866|      3|  for (char32 c = 0x114C4; c <= 0x114C5; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1866:28): [True: 2, False: 1]
  ------------------
 1867|      1|  (*smap)[0x114C6] = U_Tirhuta;
 1868|      1|  (*smap)[0x114C7] = U_Tirhuta;
 1869|     11|  for (char32 c = 0x114D0; c <= 0x114D9; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1869:28): [True: 10, False: 1]
  ------------------
 1870|     65|  for (char32 c = 0x118A0; c <= 0x118DF; ++c) (*smap)[c] = U_Warang_Citi;
  ------------------
  |  Branch (1870:28): [True: 64, False: 1]
  ------------------
 1871|     11|  for (char32 c = 0x118E0; c <= 0x118E9; ++c) (*smap)[c] = U_Warang_Citi;
  ------------------
  |  Branch (1871:28): [True: 10, False: 1]
  ------------------
 1872|     10|  for (char32 c = 0x118EA; c <= 0x118F2; ++c) (*smap)[c] = U_Warang_Citi;
  ------------------
  |  Branch (1872:28): [True: 9, False: 1]
  ------------------
 1873|      1|  (*smap)[0x118FF] = U_Warang_Citi;
 1874|     27|  for (char32 c = 0x11700; c <= 0x11719; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1874:28): [True: 26, False: 1]
  ------------------
 1875|      4|  for (char32 c = 0x1171D; c <= 0x1171F; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1875:28): [True: 3, False: 1]
  ------------------
 1876|      3|  for (char32 c = 0x11720; c <= 0x11721; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1876:28): [True: 2, False: 1]
  ------------------
 1877|      5|  for (char32 c = 0x11722; c <= 0x11725; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1877:28): [True: 4, False: 1]
  ------------------
 1878|      1|  (*smap)[0x11726] = U_Ahom;
 1879|      6|  for (char32 c = 0x11727; c <= 0x1172B; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1879:28): [True: 5, False: 1]
  ------------------
 1880|     11|  for (char32 c = 0x11730; c <= 0x11739; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1880:28): [True: 10, False: 1]
  ------------------
 1881|      3|  for (char32 c = 0x1173A; c <= 0x1173B; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1881:28): [True: 2, False: 1]
  ------------------
 1882|      4|  for (char32 c = 0x1173C; c <= 0x1173E; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1882:28): [True: 3, False: 1]
  ------------------
 1883|      1|  (*smap)[0x1173F] = U_Ahom;
 1884|    584|  for (char32 c = 0x14400; c <= 0x14646; ++c)
  ------------------
  |  Branch (1884:28): [True: 583, False: 1]
  ------------------
 1885|    583|    (*smap)[c] = U_Anatolian_Hieroglyphs;
 1886|     20|  for (char32 c = 0x108E0; c <= 0x108F2; ++c) (*smap)[c] = U_Hatran;
  ------------------
  |  Branch (1886:28): [True: 19, False: 1]
  ------------------
 1887|      3|  for (char32 c = 0x108F4; c <= 0x108F5; ++c) (*smap)[c] = U_Hatran;
  ------------------
  |  Branch (1887:28): [True: 2, False: 1]
  ------------------
 1888|      6|  for (char32 c = 0x108FB; c <= 0x108FF; ++c) (*smap)[c] = U_Hatran;
  ------------------
  |  Branch (1888:28): [True: 5, False: 1]
  ------------------
 1889|      8|  for (char32 c = 0x11280; c <= 0x11286; ++c) (*smap)[c] = U_Multani;
  ------------------
  |  Branch (1889:28): [True: 7, False: 1]
  ------------------
 1890|      1|  (*smap)[0x11288] = U_Multani;
 1891|      5|  for (char32 c = 0x1128A; c <= 0x1128D; ++c) (*smap)[c] = U_Multani;
  ------------------
  |  Branch (1891:28): [True: 4, False: 1]
  ------------------
 1892|     16|  for (char32 c = 0x1128F; c <= 0x1129D; ++c) (*smap)[c] = U_Multani;
  ------------------
  |  Branch (1892:28): [True: 15, False: 1]
  ------------------
 1893|     11|  for (char32 c = 0x1129F; c <= 0x112A8; ++c) (*smap)[c] = U_Multani;
  ------------------
  |  Branch (1893:28): [True: 10, False: 1]
  ------------------
 1894|      1|  (*smap)[0x112A9] = U_Multani;
 1895|     52|  for (char32 c = 0x10C80; c <= 0x10CB2; ++c) (*smap)[c] = U_Old_Hungarian;
  ------------------
  |  Branch (1895:28): [True: 51, False: 1]
  ------------------
 1896|     52|  for (char32 c = 0x10CC0; c <= 0x10CF2; ++c) (*smap)[c] = U_Old_Hungarian;
  ------------------
  |  Branch (1896:28): [True: 51, False: 1]
  ------------------
 1897|      7|  for (char32 c = 0x10CFA; c <= 0x10CFF; ++c) (*smap)[c] = U_Old_Hungarian;
  ------------------
  |  Branch (1897:28): [True: 6, False: 1]
  ------------------
 1898|    513|  for (char32 c = 0x1D800; c <= 0x1D9FF; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1898:28): [True: 512, False: 1]
  ------------------
 1899|     56|  for (char32 c = 0x1DA00; c <= 0x1DA36; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1899:28): [True: 55, False: 1]
  ------------------
 1900|      5|  for (char32 c = 0x1DA37; c <= 0x1DA3A; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1900:28): [True: 4, False: 1]
  ------------------
 1901|     51|  for (char32 c = 0x1DA3B; c <= 0x1DA6C; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1901:28): [True: 50, False: 1]
  ------------------
 1902|      9|  for (char32 c = 0x1DA6D; c <= 0x1DA74; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1902:28): [True: 8, False: 1]
  ------------------
 1903|      1|  (*smap)[0x1DA75] = U_SignWriting;
 1904|     15|  for (char32 c = 0x1DA76; c <= 0x1DA83; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1904:28): [True: 14, False: 1]
  ------------------
 1905|      1|  (*smap)[0x1DA84] = U_SignWriting;
 1906|      3|  for (char32 c = 0x1DA85; c <= 0x1DA86; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1906:28): [True: 2, False: 1]
  ------------------
 1907|      6|  for (char32 c = 0x1DA87; c <= 0x1DA8B; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1907:28): [True: 5, False: 1]
  ------------------
 1908|      6|  for (char32 c = 0x1DA9B; c <= 0x1DA9F; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1908:28): [True: 5, False: 1]
  ------------------
 1909|     16|  for (char32 c = 0x1DAA1; c <= 0x1DAAF; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1909:28): [True: 15, False: 1]
  ------------------
 1910|     69|  for (char32 c = 0x1E900; c <= 0x1E943; ++c) (*smap)[c] = U_Adlam;
  ------------------
  |  Branch (1910:28): [True: 68, False: 1]
  ------------------
 1911|      8|  for (char32 c = 0x1E944; c <= 0x1E94A; ++c) (*smap)[c] = U_Adlam;
  ------------------
  |  Branch (1911:28): [True: 7, False: 1]
  ------------------
 1912|     11|  for (char32 c = 0x1E950; c <= 0x1E959; ++c) (*smap)[c] = U_Adlam;
  ------------------
  |  Branch (1912:28): [True: 10, False: 1]
  ------------------
 1913|      3|  for (char32 c = 0x1E95E; c <= 0x1E95F; ++c) (*smap)[c] = U_Adlam;
  ------------------
  |  Branch (1913:28): [True: 2, False: 1]
  ------------------
 1914|     10|  for (char32 c = 0x11C00; c <= 0x11C08; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1914:28): [True: 9, False: 1]
  ------------------
 1915|     38|  for (char32 c = 0x11C0A; c <= 0x11C2E; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1915:28): [True: 37, False: 1]
  ------------------
 1916|      1|  (*smap)[0x11C2F] = U_Bhaiksuki;
 1917|      8|  for (char32 c = 0x11C30; c <= 0x11C36; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1917:28): [True: 7, False: 1]
  ------------------
 1918|      7|  for (char32 c = 0x11C38; c <= 0x11C3D; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1918:28): [True: 6, False: 1]
  ------------------
 1919|      1|  (*smap)[0x11C3E] = U_Bhaiksuki;
 1920|      1|  (*smap)[0x11C3F] = U_Bhaiksuki;
 1921|      1|  (*smap)[0x11C40] = U_Bhaiksuki;
 1922|      6|  for (char32 c = 0x11C41; c <= 0x11C45; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1922:28): [True: 5, False: 1]
  ------------------
 1923|     11|  for (char32 c = 0x11C50; c <= 0x11C59; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1923:28): [True: 10, False: 1]
  ------------------
 1924|     20|  for (char32 c = 0x11C5A; c <= 0x11C6C; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1924:28): [True: 19, False: 1]
  ------------------
 1925|      3|  for (char32 c = 0x11C70; c <= 0x11C71; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1925:28): [True: 2, False: 1]
  ------------------
 1926|     31|  for (char32 c = 0x11C72; c <= 0x11C8F; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1926:28): [True: 30, False: 1]
  ------------------
 1927|     23|  for (char32 c = 0x11C92; c <= 0x11CA7; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1927:28): [True: 22, False: 1]
  ------------------
 1928|      1|  (*smap)[0x11CA9] = U_Marchen;
 1929|      8|  for (char32 c = 0x11CAA; c <= 0x11CB0; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1929:28): [True: 7, False: 1]
  ------------------
 1930|      1|  (*smap)[0x11CB1] = U_Marchen;
 1931|      3|  for (char32 c = 0x11CB2; c <= 0x11CB3; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1931:28): [True: 2, False: 1]
  ------------------
 1932|      1|  (*smap)[0x11CB4] = U_Marchen;
 1933|      3|  for (char32 c = 0x11CB5; c <= 0x11CB6; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1933:28): [True: 2, False: 1]
  ------------------
 1934|     54|  for (char32 c = 0x11400; c <= 0x11434; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1934:28): [True: 53, False: 1]
  ------------------
 1935|      4|  for (char32 c = 0x11435; c <= 0x11437; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1935:28): [True: 3, False: 1]
  ------------------
 1936|      9|  for (char32 c = 0x11438; c <= 0x1143F; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1936:28): [True: 8, False: 1]
  ------------------
 1937|      3|  for (char32 c = 0x11440; c <= 0x11441; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1937:28): [True: 2, False: 1]
  ------------------
 1938|      4|  for (char32 c = 0x11442; c <= 0x11444; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1938:28): [True: 3, False: 1]
  ------------------
 1939|      1|  (*smap)[0x11445] = U_Newa;
 1940|      1|  (*smap)[0x11446] = U_Newa;
 1941|      5|  for (char32 c = 0x11447; c <= 0x1144A; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1941:28): [True: 4, False: 1]
  ------------------
 1942|      6|  for (char32 c = 0x1144B; c <= 0x1144F; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1942:28): [True: 5, False: 1]
  ------------------
 1943|     11|  for (char32 c = 0x11450; c <= 0x11459; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1943:28): [True: 10, False: 1]
  ------------------
 1944|      1|  (*smap)[0x1145B] = U_Newa;
 1945|      1|  (*smap)[0x1145D] = U_Newa;
 1946|     37|  for (char32 c = 0x104B0; c <= 0x104D3; ++c) (*smap)[c] = U_Osage;
  ------------------
  |  Branch (1946:28): [True: 36, False: 1]
  ------------------
 1947|     37|  for (char32 c = 0x104D8; c <= 0x104FB; ++c) (*smap)[c] = U_Osage;
  ------------------
  |  Branch (1947:28): [True: 36, False: 1]
  ------------------
 1948|      1|  (*smap)[0x16FE0] = U_Tangut;
 1949|  6.12k|  for (char32 c = 0x17000; c <= 0x187EC; ++c) (*smap)[c] = U_Tangut;
  ------------------
  |  Branch (1949:28): [True: 6.12k, False: 1]
  ------------------
 1950|    756|  for (char32 c = 0x18800; c <= 0x18AF2; ++c) (*smap)[c] = U_Tangut;
  ------------------
  |  Branch (1950:28): [True: 755, False: 1]
  ------------------
 1951|      1|}

_ZN13sentencepiece7unigram7LatticeC2Ev:
   90|  56.2k|Lattice::Lattice() : node_allocator_(kPreallocateLatticeNodeSize) {}
_ZN13sentencepiece7unigram7LatticeD2Ev:
   91|  56.2k|Lattice::~Lattice() {}
_ZNK13sentencepiece7unigram7Lattice11begin_nodesEi:
   93|  4.29M|const std::vector<Lattice::Node *> &Lattice::begin_nodes(int pos) const {
   94|  4.29M|  return begin_nodes_[pos];
   95|  4.29M|}
_ZNK13sentencepiece7unigram7Lattice9end_nodesEi:
   97|  46.1M|const std::vector<Lattice::Node *> &Lattice::end_nodes(int pos) const {
   98|  46.1M|  return end_nodes_[pos];
   99|  46.1M|}
_ZNK13sentencepiece7unigram7Lattice4sizeEv:
  101|  19.8M|int Lattice::size() const {
  102|       |  // -1 because surface_ may include the EOS.
  103|  19.8M|  return std::max<int>(0, surface_.size() - 1);
  104|  19.8M|}
_ZNK13sentencepiece7unigram7Lattice9utf8_sizeEv:
  106|  4.29M|int Lattice::utf8_size() const { return sentence_.size(); }
_ZNK13sentencepiece7unigram7Lattice8sentenceEv:
  108|  4.29M|const char *Lattice::sentence() const { return sentence_.data(); }
_ZNK13sentencepiece7unigram7Lattice7surfaceEi:
  110|  1.80G|const char *Lattice::surface(int pos) const { return surface_[pos]; }
_ZNK13sentencepiece7unigram7Lattice8bos_nodeEv:
  112|  12.9M|Lattice::Node *Lattice::bos_node() const { return end_nodes_[0][0]; }
_ZNK13sentencepiece7unigram7Lattice8eos_nodeEv:
  114|  1.91M|Lattice::Node *Lattice::eos_node() const { return begin_nodes_[size()][0]; }
_ZN13sentencepiece7unigram7Lattice7NewNodeEv:
  116|   232M|Lattice::Node *Lattice::NewNode() {
  117|   232M|  Node *node = node_allocator_.Allocate();
  118|   232M|  node->node_id = node_allocator_.size() - 1;
  119|   232M|  return node;
  120|   232M|}
_ZN13sentencepiece7unigram7Lattice5ClearEv:
  122|  4.29M|void Lattice::Clear() {
  123|  4.29M|  begin_nodes_.clear();
  124|  4.29M|  end_nodes_.clear();
  125|  4.29M|  sentence_ = absl::string_view("");
  126|  4.29M|  surface_.clear();
  127|  4.29M|  node_allocator_.Free();
  128|  4.29M|}
_ZN13sentencepiece7unigram7Lattice11SetSentenceENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  130|  4.29M|void Lattice::SetSentence(absl::string_view sentence) {
  131|  4.29M|  Clear();
  132|       |
  133|  4.29M|  sentence_ = sentence;
  134|  4.29M|  surface_.reserve(sentence.size() + 1);
  135|       |
  136|   117M|  while (!sentence.empty()) {
  ------------------
  |  Branch (136:10): [True: 113M, False: 4.29M]
  ------------------
  137|   113M|    const int mblen = std::min<int>(string_util::OneCharLen(sentence.data()),
  138|   113M|                                    sentence.size());
  139|   113M|    surface_.push_back(sentence.data());
  140|   113M|    sentence.remove_prefix(mblen);
  141|   113M|  }
  142|  4.29M|  surface_.push_back(sentence.data());
  143|       |
  144|  4.29M|  const size_t len = size();
  145|  4.29M|  begin_nodes_.resize(len + 1);
  146|  4.29M|  end_nodes_.resize(len + 1);
  147|       |
  148|  4.29M|  constexpr size_t kReservedNodeSize = 16;
  149|   122M|  for (size_t i = 0; i <= len; ++i) {
  ------------------
  |  Branch (149:22): [True: 117M, False: 4.29M]
  ------------------
  150|   117M|    begin_nodes_[i].reserve(kReservedNodeSize);
  151|   117M|    end_nodes_[i].reserve(kReservedNodeSize);
  152|   117M|  }
  153|       |
  154|  4.29M|  Node *bos = NewNode();
  155|  4.29M|  bos->id = -1;
  156|  4.29M|  bos->pos = 0;
  157|  4.29M|  end_nodes_[0].push_back(bos);
  158|       |
  159|  4.29M|  Node *eos = NewNode();
  160|  4.29M|  eos->id = -1;
  161|  4.29M|  eos->pos = len;
  162|  4.29M|  begin_nodes_[len].push_back(eos);
  163|  4.29M|}
_ZN13sentencepiece7unigram7Lattice6InsertEii:
  165|   223M|Lattice::Node *Lattice::Insert(int pos, int length) {
  166|   223M|  Node *node = NewNode();
  167|   223M|  node->pos = pos;
  168|   223M|  node->length = length;
  169|   223M|  const int utf8_length =
  170|   223M|      static_cast<int>(surface(pos + length) - surface(pos));
  171|   223M|  node->piece = absl::string_view(surface(pos), utf8_length);
  172|   223M|  begin_nodes_[pos].push_back(node);
  173|   223M|  end_nodes_[pos + node->length].push_back(node);
  174|       |
  175|   223M|  return node;
  176|   223M|}
_ZN13sentencepiece7unigram7Lattice7ViterbiEv:
  178|  4.29M|Lattice::LatticePathWithScore Lattice::Viterbi() {
  179|  4.29M|  const size_t len = size();
  180|       |
  181|   122M|  for (size_t pos = 0; pos <= len; ++pos) {
  ------------------
  |  Branch (181:24): [True: 117M, False: 4.29M]
  ------------------
  182|   227M|    for (Node *rnode : begin_nodes_[pos]) {
  ------------------
  |  Branch (182:22): [True: 227M, False: 117M]
  ------------------
  183|   227M|      rnode->prev = nullptr;
  184|   227M|      float best_score = 0.0;
  185|   227M|      Node *best_node = nullptr;
  186|   845M|      for (Node *lnode : end_nodes_[pos]) {
  ------------------
  |  Branch (186:24): [True: 845M, False: 227M]
  ------------------
  187|   845M|        const float score = lnode->backtrace_score + rnode->score;
  188|   845M|        if (best_node == nullptr || score > best_score) {
  ------------------
  |  Branch (188:13): [True: 227M, False: 617M]
  |  Branch (188:37): [True: 63.1M, False: 554M]
  ------------------
  189|   291M|          best_node = lnode;
  190|   291M|          best_score = score;
  191|   291M|        }
  192|   845M|      }
  193|   227M|      if (best_node == nullptr) {
  ------------------
  |  Branch (193:11): [True: 0, False: 227M]
  ------------------
  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|   227M|      rnode->prev = best_node;
  198|   227M|      rnode->backtrace_score = best_score;
  199|   227M|    }
  200|   117M|  }
  201|       |
  202|       |  // backtrace
  203|  4.29M|  std::vector<Node *> results;
  204|  4.29M|  float score = begin_nodes(len)[0]->backtrace_score;
  205|  59.6M|  for (Node *node = begin_nodes_[len][0]->prev; node->prev != nullptr;
  ------------------
  |  Branch (205:49): [True: 55.3M, False: 4.29M]
  ------------------
  206|  55.3M|       node = node->prev) {
  207|  55.3M|    results.push_back(node);
  208|  55.3M|  }
  209|       |
  210|  4.29M|  std::reverse(results.begin(), results.end());
  211|       |
  212|  4.29M|  LatticePathWithScore retval = {results, score};
  213|       |
  214|  4.29M|  return retval;
  215|  4.29M|}
_ZNK13sentencepiece7unigram7Lattice16ForwardAlgorithmEf:
  217|  1.68M|std::vector<float> Lattice::ForwardAlgorithm(float inv_theta) const {
  218|  1.68M|  const size_t len = size();
  219|  1.68M|  std::vector<float> alpha(node_allocator_.size(), 0.0);
  220|       |
  221|  77.3M|  for (size_t pos = 0; pos <= len; ++pos) {
  ------------------
  |  Branch (221:24): [True: 75.6M, False: 1.68M]
  ------------------
  222|   150M|    for (Node *rnode : begin_nodes_[pos]) {
  ------------------
  |  Branch (222:22): [True: 150M, False: 75.6M]
  ------------------
  223|   600M|      for (Node *lnode : end_nodes_[pos]) {
  ------------------
  |  Branch (223:24): [True: 600M, False: 150M]
  ------------------
  224|   600M|        alpha[rnode->node_id] =
  225|   600M|            LogSumExp(alpha[rnode->node_id],
  226|   600M|                      inv_theta * lnode->score + alpha[lnode->node_id],
  227|   600M|                      lnode == end_nodes_[pos][0]);
  228|   600M|      }
  229|   150M|    }
  230|  75.6M|  }
  231|       |
  232|  1.68M|  return alpha;
  233|  1.68M|}
_ZNK13sentencepiece7unigram7Lattice17BackwardAlgorithmEf:
  235|  1.68M|std::vector<float> Lattice::BackwardAlgorithm(float inv_theta) const {
  236|  1.68M|  const size_t len = size();
  237|  1.68M|  std::vector<float> beta(node_allocator_.size(), 0.0);
  238|       |
  239|  77.3M|  for (int pos = len; pos >= 0; --pos) {
  ------------------
  |  Branch (239:23): [True: 75.6M, False: 1.68M]
  ------------------
  240|   150M|    for (Node *lnode : end_nodes_[pos]) {
  ------------------
  |  Branch (240:22): [True: 150M, False: 75.6M]
  ------------------
  241|   600M|      for (Node *rnode : begin_nodes_[pos]) {
  ------------------
  |  Branch (241:24): [True: 600M, False: 150M]
  ------------------
  242|   600M|        beta[lnode->node_id] =
  243|   600M|            LogSumExp(beta[lnode->node_id], rnode->score + beta[rnode->node_id],
  244|   600M|                      rnode == begin_nodes_[pos][0]);
  245|   600M|      }
  246|   150M|    }
  247|  75.6M|  }
  248|       |
  249|  1.68M|  return beta;
  250|  1.68M|}
_ZNK13sentencepiece7unigram7Lattice16PopulateMarginalEfPNSt3__16vectorIfNS2_9allocatorIfEEEE:
  253|  1.68M|                                std::vector<float> *expected) const {
  254|  1.68M|  if (expected == nullptr) return 0.0;
  ------------------
  |  Branch (254:7): [True: 0, False: 1.68M]
  ------------------
  255|       |
  256|  1.68M|  const size_t len = size();
  257|       |
  258|       |  // alpha and beta (accumulative log prob) in Forward Backward.
  259|       |  // the index of alpha/beta is Node::node_id.
  260|       |
  261|  1.68M|  const auto alpha = ForwardAlgorithm(1.0);
  262|  1.68M|  const auto beta = BackwardAlgorithm(1.0);
  263|       |
  264|  1.68M|  const float Z = alpha[begin_nodes_[len][0]->node_id];
  265|  75.6M|  for (size_t pos = 0; pos < len; ++pos) {
  ------------------
  |  Branch (265:24): [True: 73.9M, False: 1.68M]
  ------------------
  266|   148M|    for (Node *node : begin_nodes_[pos]) {
  ------------------
  |  Branch (266:21): [True: 148M, False: 73.9M]
  ------------------
  267|   148M|      if (node->id >= 0) {
  ------------------
  |  Branch (267:11): [True: 148M, False: 0]
  ------------------
  268|       |        // the index of |expected| is a Node::id, which is a vocabulary id.
  269|   148M|        (*expected)[node->id] +=
  270|   148M|            freq *
  271|   148M|            std::exp(static_cast<double>(alpha[node->node_id] + node->score +
  272|   148M|                                         beta[node->node_id] - Z));
  273|   148M|      }
  274|   148M|    }
  275|  73.9M|  }
  276|       |
  277|  1.68M|  return freq * Z;
  278|  1.68M|}
_ZN13sentencepiece7unigram7Lattice5NBestEmbf:
  364|  1.91M|                                                          float inv_theta) {
  365|  1.91M|  if (nbest_size < 1) {
  ------------------
  |  Branch (365:7): [True: 0, False: 1.91M]
  ------------------
  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.91M|  if (nbest_size == 1 && !sample) {
  ------------------
  |  Branch (370:7): [True: 0, False: 1.91M]
  |  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.91M|  class HypothesisComparator {
  387|  1.91M|   public:
  388|  1.91M|    const bool operator()(Hypothesis *h1, Hypothesis *h2) {
  389|  1.91M|      return (h1->fx < h2->fx);
  390|  1.91M|    }
  391|  1.91M|  };
  392|       |
  393|  1.91M|  using Agenda = std::priority_queue<Hypothesis *, std::vector<Hypothesis *>,
  394|  1.91M|                                     HypothesisComparator>;
  395|  1.91M|  constexpr size_t kPreallocatedHypothesisSize = 512;
  396|  1.91M|  model::FreeList<Hypothesis> hypothesis_allocator(kPreallocatedHypothesisSize);
  397|       |
  398|  1.91M|  Agenda agenda;
  399|  1.91M|  std::vector<Lattice::LatticePathWithScore> results;
  400|       |
  401|  1.91M|  auto *eos = hypothesis_allocator.Allocate();
  402|  1.91M|  eos->node = eos_node();
  403|  1.91M|  eos->next = nullptr;
  404|  1.91M|  eos->gx = 0.0;
  405|       |
  406|  1.91M|  std::vector<float> alpha(node_allocator_.size(), 0.0);
  407|       |
  408|  1.91M|  if (sample) {
  ------------------
  |  Branch (408:7): [True: 0, False: 1.91M]
  ------------------
  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.91M|  } else {
  414|       |    // Run Viterbi first to fill backtrace score.
  415|  1.91M|    Viterbi();
  416|  1.91M|    eos->fx = eos->node->backtrace_score;
  417|  1.91M|  }
  418|  1.91M|  agenda.push(eos);
  419|       |
  420|  1.91M|  int shrink_count = 0;  // Number of times agenda has shrunk. For logging only.
  421|  1.91M|  bool printed_memory_warning = false;  // For logging only.
  422|  13.2M|  while (!agenda.empty()) {
  ------------------
  |  Branch (422:10): [True: 12.9M, False: 332k]
  ------------------
  423|  12.9M|    auto *top = agenda.top();
  424|  12.9M|    agenda.pop();
  425|  12.9M|    auto *node = top->node;
  426|       |
  427|       |    // Reaches to BOS
  428|  12.9M|    if (node == bos_node()) {
  ------------------
  |  Branch (428:9): [True: 3.49M, False: 9.46M]
  ------------------
  429|  3.49M|      results.resize(results.size() + 1);
  430|  10.8M|      for (auto *n = top->next; n->next != nullptr; n = n->next) {
  ------------------
  |  Branch (430:33): [True: 7.40M, False: 3.49M]
  ------------------
  431|  7.40M|        results.back().first.push_back(n->node);
  432|  7.40M|      }
  433|  3.49M|      results.back().second = top->fx;
  434|  3.49M|      if (results.size() == nbest_size) {
  ------------------
  |  Branch (434:11): [True: 1.57M, False: 1.91M]
  ------------------
  435|  1.57M|        break;
  436|  1.57M|      }
  437|  1.91M|      continue;
  438|  3.49M|    }
  439|       |
  440|  9.46M|    const size_t end_nodes_size = end_nodes(node->pos).size();
  441|  9.46M|    std::vector<float> probs(end_nodes_size, 0.0);
  442|  9.46M|    std::vector<float> perturbed_probs(end_nodes_size, 0.0);
  443|  9.46M|    std::vector<double> adjusted_probs(end_nodes_size, 0.0);
  444|  9.46M|    const float Z = alpha[node->node_id];
  445|  9.46M|    if (sample) {
  ------------------
  |  Branch (445:9): [True: 0, False: 9.46M]
  ------------------
  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|  23.0M|    for (size_t i = 0; i < end_nodes(node->pos).size(); i++) {
  ------------------
  |  Branch (470:24): [True: 13.5M, False: 9.46M]
  ------------------
  471|  13.5M|      Node *lnode = end_nodes(node->pos)[i];
  472|  13.5M|      auto *hyp = hypothesis_allocator.Allocate();
  473|  13.5M|      hyp->node = lnode;
  474|  13.5M|      if (sample) {
  ------------------
  |  Branch (474:11): [True: 0, False: 13.5M]
  ------------------
  475|      0|        hyp->gx = probs[i];
  476|      0|        hyp->fx = adjusted_probs[i];
  477|  13.5M|      } else {
  478|  13.5M|        hyp->gx = lnode->score + top->gx;  // just adds node->score
  479|  13.5M|        hyp->fx =
  480|  13.5M|            lnode->backtrace_score + top->gx;  // backtrace_score is h(node).
  481|  13.5M|      }
  482|  13.5M|      hyp->next = top;
  483|  13.5M|      agenda.push(hyp);
  484|  13.5M|    }
  485|       |
  486|  9.46M|    static constexpr int kOneBillion = 1000000000;  // 10^9.
  487|  9.46M|    if (hypothesis_allocator.size() >= kOneBillion) {
  ------------------
  |  Branch (487:9): [True: 0, False: 9.46M]
  ------------------
  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|  9.46M|    constexpr int kMaxAgendaSize = 10000;
  499|  9.46M|    constexpr int kMinAgendaSize = 512;
  500|  9.46M|    if (agenda.size() >= kMaxAgendaSize) {
  ------------------
  |  Branch (500:9): [True: 0, False: 9.46M]
  ------------------
  501|       |      // Keeps the top `kMinAgendaSize` hypothesis.
  502|      0|      Agenda new_agenda;
  503|       |      // Keeps the top hypothesis and the ones on their "next" paths.
  504|      0|      model::FreeList<Hypothesis> new_allocator(kPreallocatedHypothesisSize);
  505|       |      // Map between old Hypothesis* and new Hypothesis*.
  506|      0|      absl::flat_hash_map<const Hypothesis *, Hypothesis *> clone_map;
  507|       |
  508|      0|      const size_t size = std::min<size_t>(kMinAgendaSize, nbest_size * 10);
  509|      0|      shrink_count++;
  510|      0|      LOG(WARNING) << "Too big agenda size " << agenda.size()
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  511|      0|                   << ". Shrinking (round " << shrink_count << ") down to "
  512|      0|                   << size << ".";
  513|      0|      for (size_t i = 0; i < size; ++i) {
  ------------------
  |  Branch (513:26): [True: 0, False: 0]
  ------------------
  514|      0|        const Hypothesis *top_hyp = agenda.top();
  515|      0|        Hypothesis *cloned_hyp =
  516|      0|            CloneHypAndDependents(top_hyp, &clone_map, &new_allocator);
  517|      0|        new_agenda.push(cloned_hyp);
  518|      0|        agenda.pop();
  519|      0|      }
  520|      0|      agenda = std::move(new_agenda);
  521|      0|      hypothesis_allocator = std::move(new_allocator);
  522|      0|    }
  523|  9.46M|  }
  524|       |
  525|  1.91M|  return results;
  526|  1.91M|}
_ZNK13sentencepiece7unigram5Model13PopulateNodesEPNS0_7LatticeE:
  561|  4.29M|void Model::PopulateNodes(Lattice *lattice) const {
  562|  4.29M|  auto get_chars_length = [&lattice](int begin_pos, const char *end) {
  563|  4.29M|    int pos = begin_pos;
  564|  4.29M|    while (lattice->surface(pos) < end) ++pos;
  565|  4.29M|    return pos - begin_pos;
  566|  4.29M|  };
  567|       |
  568|  4.29M|  const float unk_score = min_score() - kUnkPenalty;
  569|       |
  570|  4.29M|  const size_t len = lattice->size();
  571|  4.29M|  const char *end = lattice->sentence() + lattice->utf8_size();
  572|       |
  573|       |  // +1 just in case.
  574|  4.29M|  std::vector<Darts::DoubleArray::result_pair_type> trie_results(
  575|  4.29M|      trie_results_size_ + 1);
  576|       |
  577|   117M|  for (size_t begin_pos = 0; begin_pos < len; ++begin_pos) {
  ------------------
  |  Branch (577:30): [True: 113M, False: 4.29M]
  ------------------
  578|   113M|    const char *begin = lattice->surface(begin_pos);
  579|       |
  580|       |    // Finds all pieces which are prefix of surface(begin_pos).
  581|   113M|    const size_t num_nodes = trie_->commonPrefixSearch(
  582|   113M|        begin, trie_results.data(), trie_results.size(),
  583|   113M|        static_cast<int>(end - begin));
  584|   113M|    CHECK_LT(num_nodes, trie_results.size());
  ------------------
  |  |  124|   113M|  ABSL_LOG_INTERNAL_CHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   55|   113M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_LT, <, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|   113M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 113M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|   113M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|   113M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|   113M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|   113M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|   113M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|   113M|    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|   113M|    bool has_single_node = false;
  587|       |
  588|       |    // Inserts pieces to the lattice.
  589|   329M|    for (size_t k = 0; k < num_nodes; ++k) {
  ------------------
  |  Branch (589:24): [True: 215M, False: 113M]
  ------------------
  590|   215M|      const int length =
  591|   215M|          get_chars_length(begin_pos, begin + trie_results[k].length);
  592|   215M|      const int id = trie_results[k].value;
  593|   215M|      if (IsUnusedInlined(id)) continue;
  ------------------
  |  Branch (593:11): [True: 0, False: 215M]
  ------------------
  594|   215M|      Lattice::Node *node = lattice->Insert(begin_pos, length);
  595|   215M|      node->id = id;  // the value of Trie stores vocab_id.
  596|       |      // User defined symbol receives extra bonus to always be selected.
  597|   215M|      node->score = IsUserDefinedInlined(id) ? GetUserDefinedScore(length)
  ------------------
  |  Branch (597:21): [True: 0, False: 215M]
  ------------------
  598|   215M|                                             : GetScoreInlined(id);
  599|   215M|      if (!has_single_node && node->length == 1) {
  ------------------
  |  Branch (599:11): [True: 109M, False: 106M]
  |  Branch (599:31): [True: 105M, False: 3.42M]
  ------------------
  600|   105M|        has_single_node = true;
  601|   105M|      }
  602|   215M|    }
  603|       |
  604|   113M|    if (!has_single_node) {
  ------------------
  |  Branch (604:9): [True: 7.67M, False: 105M]
  ------------------
  605|  7.67M|      Lattice::Node *node = lattice->Insert(begin_pos, 1);
  606|  7.67M|      node->id = unk_id_;  // add UNK node.
  607|  7.67M|      node->score = unk_score;
  608|  7.67M|    }
  609|   113M|  }
  610|  4.29M|}
_ZN13sentencepiece7unigram5Model9BuildTrieEPNSt3__16vectorINS2_4pairINS2_17basic_string_viewIcNS2_11char_traitsIcEEEEiEENS2_9allocatorIS9_EEEE:
  622|  52.3k|void Model::BuildTrie(std::vector<std::pair<absl::string_view, int>> *pieces) {
  623|  52.3k|  if (!status().ok()) return;
  ------------------
  |  Branch (623:7): [True: 0, False: 52.3k]
  ------------------
  624|       |
  625|  52.3k|  if (pieces->empty()) {
  ------------------
  |  Branch (625:7): [True: 6, False: 52.3k]
  ------------------
  626|      6|    status_ = util::InternalError("no pieces are loaded.");
  627|      6|    return;
  628|      6|  }
  629|       |
  630|       |  // sort by sentencepiece since DoubleArray::build()
  631|       |  // only accepts sorted strings.
  632|  52.3k|  sort(pieces->begin(), pieces->end());
  633|       |
  634|       |  // Makes key/value/length set for DoubleArrayTrie.
  635|  52.3k|  std::vector<const char *> key(pieces->size());
  636|  52.3k|  std::vector<size_t> length(pieces->size());
  637|  52.3k|  std::vector<int> value(pieces->size());
  638|  7.89M|  for (size_t i = 0; i < pieces->size(); ++i) {
  ------------------
  |  Branch (638:22): [True: 7.83M, False: 52.3k]
  ------------------
  639|  7.83M|    key[i] = (*pieces)[i].first.data();  // sorted piece.
  640|  7.83M|    length[i] = (*pieces)[i].first.size();
  641|  7.83M|    value[i] = (*pieces)[i].second;  // vocab_id
  642|  7.83M|  }
  643|       |
  644|  52.3k|  trie_ = std::make_unique<Darts::DoubleArray>();
  645|  52.3k|  if (trie_->build(key.size(), const_cast<char **>(&key[0]),
  ------------------
  |  Branch (645:7): [True: 0, False: 52.3k]
  ------------------
  646|  52.3k|                   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|  52.3k|  const int kMaxTrieResultsSize = 1024;
  653|  52.3k|  std::vector<Darts::DoubleArray::result_pair_type> results(
  654|  52.3k|      kMaxTrieResultsSize);
  655|  52.3k|  trie_results_size_ = 0;
  656|  7.83M|  for (const auto &p : *pieces) {
  ------------------
  |  Branch (656:22): [True: 7.83M, False: 52.3k]
  ------------------
  657|  7.83M|    const int num_nodes = trie_->commonPrefixSearch(
  658|  7.83M|        p.first.data(), results.data(), results.size(), p.first.size());
  659|  7.83M|    trie_results_size_ = std::max(trie_results_size_, num_nodes);
  660|  7.83M|  }
  661|       |
  662|  52.3k|  pieces_.clear();
  663|       |
  664|  52.3k|  if (trie_results_size_ == 0)
  ------------------
  |  Branch (664:7): [True: 0, False: 52.3k]
  ------------------
  665|      0|    status_ = util::InternalError("no entry is found in the trie.");
  666|  52.3k|}
_ZN13sentencepiece7unigram5ModelD2Ev:
  686|  6.89k|Model::~Model() {}
unigram_model.cc:_ZN13sentencepiece7unigram12_GLOBAL__N_19LogSumExpEffb:
   50|  1.20G|inline float LogSumExp(float x, float y, bool init_mode) {
   51|  1.20G|  if (init_mode) {
  ------------------
  |  Branch (51:7): [True: 301M, False: 899M]
  ------------------
   52|   301M|    return y;
   53|   301M|  }
   54|   899M|  const float vmin = std::min(x, y);
   55|   899M|  const float vmax = std::max(x, y);
   56|   899M|  constexpr float kMinusLogEpsilon = 50;
   57|   899M|  if (vmax > vmin + kMinusLogEpsilon) {
  ------------------
  |  Branch (57:7): [True: 1.47M, False: 898M]
  ------------------
   58|  1.47M|    return vmax;
   59|   898M|  } else {
   60|   898M|    return vmax + log(std::exp(static_cast<double>(vmin - vmax)) + 1.0);
   61|   898M|  }
   62|   899M|}
unigram_model.cc:_ZZNK13sentencepiece7unigram5Model13PopulateNodesEPNS0_7LatticeEENK3$_0clEiPKc:
  562|   215M|  auto get_chars_length = [&lattice](int begin_pos, const char *end) {
  563|   215M|    int pos = begin_pos;
  564|  1.01G|    while (lattice->surface(pos) < end) ++pos;
  ------------------
  |  Branch (564:12): [True: 803M, False: 215M]
  ------------------
  565|   215M|    return pos - begin_pos;
  566|   215M|  };
unigram_model.cc:_ZZN13sentencepiece7unigram7Lattice5NBestEmbfEN20HypothesisComparatorclEPNS0_12_GLOBAL__N_110HypothesisES5_:
  388|  15.9M|    const bool operator()(Hypothesis *h1, Hypothesis *h2) {
  389|  15.9M|      return (h1->fx < h2->fx);
  390|  15.9M|    }

_ZN13sentencepiece7unigram5ModelC2Ev:
  130|  6.89k|  Model() {}
_ZNK13sentencepiece7unigram5Model9min_scoreEv:
  158|  4.33M|  float min_score() const { return min_score_; }

_ZN13sentencepiece7unigram12TrainerModelC2ERKNS_11TrainerSpecERKNS_14NormalizerSpecE:
  132|  6.89k|    : trainer_spec_(trainer_spec), normalizer_spec_(normalizer_spec) {}
_ZN13sentencepiece7unigram12TrainerModelD2Ev:
  134|  6.89k|TrainerModel::~TrainerModel() {}
_ZNK13sentencepiece7unigram12TrainerModel17GetSentencePiecesEv:
  136|  52.3k|const TrainerModel::SentencePieces &TrainerModel::GetSentencePieces() const {
  137|  52.3k|  return sentencepieces_;
  138|  52.3k|}
_ZN13sentencepiece7unigram12TrainerModel17SetSentencePiecesEONSt3__16vectorINS2_4pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEfEENS8_ISB_EEEE:
  140|  52.3k|util::Status TrainerModel::SetSentencePieces(SentencePieces &&sentencepieces) {
  141|  52.3k|  sentencepieces_ = std::move(sentencepieces);
  142|       |
  143|  52.3k|  min_score_ = FLT_MAX;
  144|  52.3k|  model_proto_data_.Clear();
  145|  52.3k|  model_proto_ = &model_proto_data_;
  146|  52.3k|  std::vector<std::pair<absl::string_view, int>> pieces;
  147|       |
  148|  7.89M|  for (size_t i = 0; i < sentencepieces_.size(); ++i) {
  ------------------
  |  Branch (148:22): [True: 7.83M, False: 52.3k]
  ------------------
  149|  7.83M|    const absl::string_view w = sentencepieces_[i].first;  // piece
  150|  7.83M|    const float score = sentencepieces_[i].second;         // score.
  151|  7.83M|    RET_CHECK(!std::isnan(score));
  ------------------
  |  |  321|  7.83M|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 7.83M, False: 0]
  |  |  ------------------
  |  |  322|  7.83M|  } else /* NOLINT */                                        \
  |  |  323|  7.83M|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  152|  7.83M|    pieces.emplace_back(w, i);
  153|  7.83M|    min_score_ = std::min(min_score_, score);
  154|  7.83M|    auto *piece = model_proto_data_.add_pieces();
  155|  7.83M|    piece->set_piece(w.data(), w.size());
  156|  7.83M|    piece->set_score(score);
  157|  7.83M|  }
  158|       |
  159|  52.3k|  BuildTrie(&pieces);
  160|  52.3k|  return status();
  161|  52.3k|}
_ZN13sentencepiece7unigram7Trainer22MakeSeedSentencePiecesEv:
  163|  6.80k|TrainerModel::SentencePieces Trainer::MakeSeedSentencePieces() {
  164|  6.80k|  return trainer_spec_.train_extremely_large_corpus()
  ------------------
  |  Branch (164:10): [True: 0, False: 6.80k]
  ------------------
  165|  6.80k|             ? MakeSeedSentencePiecesInternal<int64_t>()
  166|  6.80k|             : MakeSeedSentencePiecesInternal<int32_t>();
  167|  6.80k|}
_ZNK13sentencepiece7unigram7Trainer8RunEStepERKNS0_12TrainerModelEPfPl:
  359|  34.9k|                                     int64_t *num_tokens) const {
  360|  34.9k|  std::vector<std::vector<float>> expected(trainer_spec_.num_threads());
  361|  34.9k|  std::vector<float> objs(trainer_spec_.num_threads(), 0.0);
  362|  34.9k|  std::vector<int64_t> ntokens(trainer_spec_.num_threads(), 0.0);
  363|       |
  364|  34.9k|  auto pool = std::make_unique<ThreadPool>(trainer_spec_.num_threads());
  365|       |
  366|  34.9k|  int64_t all_sentence_freq = 0;
  367|  1.68M|  for (const auto &w : sentences_) {
  ------------------
  |  Branch (367:22): [True: 1.68M, False: 34.9k]
  ------------------
  368|  1.68M|    all_sentence_freq += w.second;
  369|  1.68M|  }
  370|       |
  371|       |  // Executes E step in parallel
  372|  69.8k|  for (int n = 0; n < trainer_spec_.num_threads(); ++n) {
  ------------------
  |  Branch (372:19): [True: 34.9k, False: 34.9k]
  ------------------
  373|  34.9k|    pool->Schedule([&, n]() {
  374|  34.9k|      Lattice lattice;
  375|  34.9k|      expected[n].resize(model.GetPieceSize(), 0.0);
  376|  34.9k|      for (size_t i = n; i < sentences_.size();
  377|  34.9k|           i += trainer_spec_.num_threads()) {
  378|  34.9k|        const std::string &w = sentences_[i].first;
  379|  34.9k|        const int64_t freq = sentences_[i].second;
  380|  34.9k|        lattice.SetSentence(w);
  381|  34.9k|        model.PopulateNodes(&lattice);
  382|  34.9k|        const float Z = lattice.PopulateMarginal(freq, &expected[n]);
  383|  34.9k|        ntokens[n] += lattice.Viterbi().first.size() * freq;
  384|  34.9k|        CHECK(!std::isnan(Z))
  385|  34.9k|            << "likelihood is NAN. Input sentence may be too long";
  386|  34.9k|        objs[n] -= Z / all_sentence_freq;
  387|  34.9k|      }
  388|  34.9k|    });
  389|  34.9k|  }
  390|  34.9k|  pool.reset(nullptr);
  391|       |
  392|       |  // Merges expectations
  393|  34.9k|  for (int n = 1; n < trainer_spec_.num_threads(); ++n) {
  ------------------
  |  Branch (393:19): [True: 0, False: 34.9k]
  ------------------
  394|      0|    objs[0] += objs[n];
  395|      0|    ntokens[0] += ntokens[n];
  396|      0|    for (size_t k = 0; k < expected[0].size(); ++k) {
  ------------------
  |  Branch (396:24): [True: 0, False: 0]
  ------------------
  397|      0|      expected[0][k] += expected[n][k];
  398|      0|    }
  399|      0|  }
  400|       |
  401|  34.9k|  *obj = objs[0];
  402|  34.9k|  *num_tokens = ntokens[0];
  403|  34.9k|  CHECK(!std::isnan(*obj));
  ------------------
  |  |   58|  34.9k|#define CHECK(condition) ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   27|  69.8k|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  180|  34.9k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  69.8k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  69.8k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 34.9k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  34.9k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 34.9k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  69.8k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 34.9k, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 34.9k]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 34.9k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  69.8k|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |   29|  69.8k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  404|       |
  405|  34.9k|  return expected[0];
  406|  34.9k|}
_ZNK13sentencepiece7unigram7Trainer8RunMStepERKNS0_12TrainerModelERKNSt3__16vectorIfNS5_9allocatorIfEEEE:
  409|  34.9k|    const TrainerModel &model, const std::vector<float> &expected) const {
  410|  34.9k|  const auto &sentencepieces = model.GetSentencePieces();
  411|  34.9k|  CHECK_EQ(sentencepieces.size(), expected.size());
  ------------------
  |  |  118|  34.9k|  ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   49|  34.9k|  ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  34.9k|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 34.9k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  34.9k|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  34.9k|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  34.9k|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  34.9k|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  34.9k|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  34.9k|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  412|  34.9k|  TrainerModel::SentencePieces new_sentencepieces;
  413|       |
  414|  34.9k|  float sum = 0.0;
  415|  5.70M|  for (size_t i = 0; i < expected.size(); ++i) {
  ------------------
  |  Branch (415:22): [True: 5.66M, False: 34.9k]
  ------------------
  416|  5.66M|    const float freq = expected[i];
  417|       |
  418|       |    // Filter infrequent sentencepieces here.
  419|  5.66M|    constexpr float kExpectedFrequencyThreshold = 0.5;
  420|  5.66M|    if (freq < kExpectedFrequencyThreshold) {
  ------------------
  |  Branch (420:9): [True: 1.22M, False: 4.43M]
  ------------------
  421|  1.22M|      continue;
  422|  1.22M|    }
  423|       |
  424|  4.43M|    new_sentencepieces.emplace_back(sentencepieces[i].first, freq);
  425|  4.43M|    sum += freq;
  426|  4.43M|  }
  427|       |
  428|       |  // Here we do not use the original EM, but use the
  429|       |  // Bayesianified/DPified EM algorithm.
  430|       |  // https://cs.stanford.edu/~pliang/papers/tutorial-acl2007-talk.pdf
  431|       |  // This modification will act as a sparse prior.
  432|  34.9k|  const float logsum = Digamma(sum);
  433|  4.43M|  for (auto &w : new_sentencepieces) {
  ------------------
  |  Branch (433:16): [True: 4.43M, False: 34.9k]
  ------------------
  434|  4.43M|    w.second = Digamma(w.second) - logsum;
  435|  4.43M|  }
  436|       |
  437|  34.9k|  return new_sentencepieces;
  438|  34.9k|}
_ZNK13sentencepiece7unigram7Trainer19PruneSentencePiecesERKNS0_12TrainerModelE:
  441|  10.6k|    const TrainerModel &model) const {
  442|  10.6k|  const auto &sentencepieces = model.GetSentencePieces();
  443|       |
  444|  10.6k|  Lattice lattice;
  445|  10.6k|  std::vector<bool> always_keep(sentencepieces.size(), true);
  446|  10.6k|  std::vector<std::vector<int>> alternatives(sentencepieces.size());
  447|       |
  448|       |  // First, segments the current sentencepieces to know
  449|       |  // how each sentencepiece is resegmented if this sentencepiece is removed
  450|       |  // from the vocabulary.
  451|       |  // To do so, we take the second best segmentation of sentencepiece[i].
  452|       |  // alternatives[i] stores the sequence of second best sentencepieces.
  453|  1.92M|  for (size_t i = 0; i < sentencepieces.size(); ++i) {
  ------------------
  |  Branch (453:22): [True: 1.91M, False: 10.6k]
  ------------------
  454|  1.91M|    const auto &w = sentencepieces[i];
  455|  1.91M|    lattice.SetSentence(w.first);
  456|  1.91M|    model.PopulateNodes(&lattice);
  457|  1.91M|    const auto nbests = lattice.NBest(2, false, 0.0);
  458|  1.91M|    if (nbests.size() == 1) {
  ------------------
  |  Branch (458:9): [True: 332k, False: 1.57M]
  ------------------
  459|       |      // No second-best result is found. always keep this sentencepiece.
  460|   332k|      always_keep[i] = true;
  461|   332k|      continue;
  462|  1.57M|    } else if (nbests[0].first.size() >= 2) {
  ------------------
  |  Branch (462:16): [True: 39.6k, False: 1.53M]
  ------------------
  463|       |      // Can safely remove this sentencepiece if its Viterbi path is split.
  464|  39.6k|      always_keep[i] = false;
  465|  1.53M|    } else if (nbests[0].first.size() == 1) {
  ------------------
  |  Branch (465:16): [True: 1.53M, False: 0]
  ------------------
  466|  1.53M|      always_keep[i] = true;
  467|  5.38M|      for (const auto *node : nbests[1].first) {
  ------------------
  |  Branch (467:29): [True: 5.38M, False: 1.53M]
  ------------------
  468|  5.38M|        alternatives[i].push_back(node->id);
  469|  5.38M|      }
  470|  1.53M|    }
  471|  1.91M|  }
  472|       |
  473|       |  // Second, segment all sentences to compute token frequencies
  474|       |  // with a unigram language model using the Viterbi path.
  475|  10.6k|  std::vector<float> freq(sentencepieces.size(), 0.0);
  476|  10.6k|  {
  477|  10.6k|    std::vector<std::vector<float>> freqs(trainer_spec_.num_threads());
  478|       |
  479|  10.6k|    auto pool = std::make_unique<ThreadPool>(trainer_spec_.num_threads());
  480|  21.3k|    for (int n = 0; n < trainer_spec_.num_threads(); ++n) {
  ------------------
  |  Branch (480:21): [True: 10.6k, False: 10.6k]
  ------------------
  481|  10.6k|      freqs[n].resize(sentencepieces.size(), 0.0);
  482|       |
  483|  10.6k|      pool->Schedule([&, n]() {
  484|  10.6k|        Lattice lattice;
  485|  10.6k|        for (size_t i = n; i < sentences_.size();
  486|  10.6k|             i += trainer_spec_.num_threads()) {
  487|  10.6k|          const auto &w = sentences_[i];
  488|  10.6k|          lattice.SetSentence(w.first);
  489|  10.6k|          model.PopulateNodes(&lattice);
  490|  10.6k|          for (const auto *node : lattice.Viterbi().first) {
  491|  10.6k|            if (node->id >= 0) {
  492|  10.6k|              freqs[n][node->id] += w.second;
  493|  10.6k|            }
  494|  10.6k|          }
  495|  10.6k|        }
  496|  10.6k|      });
  497|  10.6k|    }
  498|  10.6k|    pool.reset(nullptr);
  499|       |
  500|  21.3k|    for (int n = 0; n < trainer_spec_.num_threads(); ++n) {
  ------------------
  |  Branch (500:21): [True: 10.6k, False: 10.6k]
  ------------------
  501|  1.92M|      for (size_t i = 0; i < sentencepieces.size(); ++i) {
  ------------------
  |  Branch (501:26): [True: 1.91M, False: 10.6k]
  ------------------
  502|  1.91M|        freq[i] += freqs[n][i];
  503|  1.91M|      }
  504|  10.6k|    }
  505|  10.6k|  }
  506|       |
  507|  10.6k|  const float sum = std::accumulate(freq.begin(), freq.end(), 0.0);
  508|  10.6k|  const float logsum = std::log(static_cast<double>(sum));
  509|  10.6k|  std::vector<std::pair<int, float>> candidates;
  510|  10.6k|  TrainerModel::SentencePieces new_sentencepieces;
  511|       |
  512|       |  // Finally, computes how likely the LM likelihood is reduced if
  513|       |  // the sentencepiece[i] is removed from the vocabulary.
  514|       |  // Since the exact computation of loss is difficult, we compute the
  515|       |  // loss approximately by assuming that all sentencepiece[i] in the sentences
  516|       |  // are replaced with alternatives[i] when sentencepiece[i] is removed.
  517|  1.92M|  for (size_t i = 0; i < sentencepieces.size(); ++i) {
  ------------------
  |  Branch (517:22): [True: 1.91M, False: 10.6k]
  ------------------
  518|  1.91M|    if (freq[i] == 0 || !always_keep[i]) {
  ------------------
  |  Branch (518:9): [True: 86.2k, False: 1.82M]
  |  Branch (518:9): [True: 86.2k, False: 1.82M]
  |  Branch (518:25): [True: 1, False: 1.82M]
  ------------------
  519|       |      // not found in Viterbi path. Can remove this entry safely.
  520|  86.2k|      continue;
  521|  1.82M|    } else if (alternatives[i].empty()) {
  ------------------
  |  Branch (521:16): [True: 330k, False: 1.49M]
  ------------------
  522|       |      // no alternatives. Keeps this entry.
  523|   330k|      new_sentencepieces.push_back(sentencepieces[i]);
  524|  1.49M|    } else {
  525|       |      // The logprob with the sentencepiece[i].
  526|  1.49M|      const float logprob_sp = std::log(static_cast<double>(freq[i])) - logsum;
  527|       |
  528|       |      // After removing the sentencepiece[i], its frequency freq[i] is
  529|       |      // re-assigned to alternatives.
  530|       |      // new_sum = current_sum - freq[i] + freq[i] * alternatives[i].size()
  531|       |      //         = current_sum + freq[i] * (alternatives[i] - 1)
  532|  1.49M|      const float logsum_alt = std::log(
  533|  1.49M|          static_cast<double>(sum + freq[i] * (alternatives[i].size() - 1)));
  534|       |
  535|       |      // The frequencies of altenatives are increased by freq[i].
  536|  1.49M|      float logprob_alt = 0.0;
  537|  5.27M|      for (const int n : alternatives[i]) {
  ------------------
  |  Branch (537:24): [True: 5.27M, False: 1.49M]
  ------------------
  538|  5.27M|        logprob_alt +=
  539|  5.27M|            (std::log(static_cast<double>(freq[n] + freq[i])) - logsum_alt);
  540|  5.27M|      }
  541|       |
  542|       |      // loss: the diff of likelihood after removing the sentencepieces[i].
  543|  1.49M|      float F = freq[i] / sum;  // normalized token frequency
  544|  1.49M|      const float loss = F * (logprob_sp - logprob_alt);
  545|  1.49M|      candidates.emplace_back(i, loss);
  546|  1.49M|    }
  547|  1.91M|  }
  548|       |
  549|  10.6k|  const int pruned_size =
  550|  10.6k|      std::max<int>(desired_vocab_size_,
  551|  10.6k|                    trainer_spec_.shrinking_factor() * sentencepieces.size());
  552|       |
  553|       |  // Keeps trainer_spec_.shrinking_factor * sentencepieces.size() pieces.
  554|       |  // shrinking_factor is 0.75 by default.
  555|  1.13M|  for (const auto &w : Sorted(candidates)) {
  ------------------
  |  Branch (555:22): [True: 1.13M, False: 615]
  ------------------
  556|  1.13M|    if (new_sentencepieces.size() == static_cast<size_t>(pruned_size)) {
  ------------------
  |  Branch (556:9): [True: 10.0k, False: 1.12M]
  ------------------
  557|  10.0k|      break;
  558|  10.0k|    }
  559|  1.12M|    new_sentencepieces.emplace_back(sentencepieces[w.first]);
  560|  1.12M|  }
  561|       |
  562|  10.6k|  return new_sentencepieces;
  563|  10.6k|}
_ZNK13sentencepiece7unigram7Trainer22FinalizeSentencePiecesERKNS0_12TrainerModelE:
  566|  6.79k|    const TrainerModel &model) const {
  567|  6.79k|  const auto &sentencepieces = model.GetSentencePieces();
  568|  6.79k|  absl::flat_hash_map<std::string, float> final_sentencepieces;
  569|  6.79k|  absl::flat_hash_map<std::string, float> sp(sentencepieces.begin(),
  570|  6.79k|                                             sentencepieces.end());
  571|       |
  572|       |  // required_chars_ must be included in the final sentencepieces.
  573|  6.79k|  float min_score_penalty = 0.0;
  574|  6.79k|  constexpr float kMinScorePenaltyDelta = 0.0001;
  575|   187k|  for (const auto &w : Sorted(required_chars_)) {
  ------------------
  |  Branch (575:22): [True: 187k, False: 6.79k]
  ------------------
  576|   187k|    const std::string s = string_util::UnicodeCharToUTF8(w.first);
  577|   187k|    if (port::ContainsKey(sp, s)) {
  ------------------
  |  Branch (577:9): [True: 148k, False: 38.4k]
  ------------------
  578|   148k|      final_sentencepieces[s] = sp[s];
  579|   148k|    } else {
  580|       |      // Add penalty to avoid required pieces from having the same score.
  581|       |      // Since the required_chars_ is sorted, frequent pieces have
  582|       |      // less penalties.
  583|  38.4k|      final_sentencepieces[s] = model.min_score() + min_score_penalty;
  584|  38.4k|      min_score_penalty += kMinScorePenaltyDelta;
  585|  38.4k|    }
  586|   187k|  }
  587|       |
  588|  6.79k|  const int vocab_size_size = trainer_spec_.vocab_size() - meta_pieces_.size();
  589|  6.79k|  CHECK_GT(vocab_size_size, 0);
  ------------------
  |  |  128|  6.79k|  ABSL_LOG_INTERNAL_CHECK_GT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   59|  6.79k|  ABSL_LOG_INTERNAL_CHECK_OP(Check_GT, >, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  6.79k|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 6.79k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  6.79k|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  6.79k|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  6.79k|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  6.79k|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  6.79k|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  6.79k|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  590|       |
  591|       |  // Then keeps sentencepieces with higher scores.
  592|   158k|  for (const auto &w : Sorted(sentencepieces)) {
  ------------------
  |  Branch (592:22): [True: 158k, False: 3.70k]
  ------------------
  593|   158k|    if (port::ContainsKey(final_sentencepieces, w.first)) {
  ------------------
  |  Branch (593:9): [True: 95.4k, False: 63.3k]
  ------------------
  594|  95.4k|      continue;
  595|  95.4k|    }
  596|  63.3k|    if (static_cast<size_t>(vocab_size_size) == final_sentencepieces.size()) {
  ------------------
  |  Branch (596:9): [True: 3.09k, False: 60.2k]
  ------------------
  597|  3.09k|      break;
  598|  3.09k|    }
  599|  60.2k|    final_sentencepieces[w.first] = w.second;
  600|  60.2k|  }
  601|       |
  602|  6.79k|  return Sorted(final_sentencepieces);
  603|  6.79k|}
_ZN13sentencepiece7unigram7Trainer5TrainEv:
  605|  6.89k|util::Status Trainer::Train() {
  606|  6.89k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  6.89k|  do {                                 \
  |  |   45|  6.89k|    const auto _status = expr;         \
  |  |   46|  6.89k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 2, False: 6.89k]
  |  |  ------------------
  |  |   47|  6.89k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 6.89k]
  |  |  ------------------
  ------------------
  607|       |
  608|  6.89k|  RET_CHECK_EQ(TrainerSpec::UNIGRAM, trainer_spec_.model_type());
  ------------------
  |  |  327|  6.89k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|  6.89k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 6.89k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  6.89k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  6.89k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  609|  6.89k|  RET_CHECK(normalizer_spec_.escape_whitespaces());
  ------------------
  |  |  321|  6.89k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 6.89k, False: 0]
  |  |  ------------------
  |  |  322|  6.89k|  } else /* NOLINT */                                        \
  |  |  323|  6.89k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  610|       |
  611|  6.89k|  TrainerModel model(trainer_spec_, normalizer_spec_);
  612|       |
  613|  6.89k|  RETURN_IF_ERROR(model.status());
  ------------------
  |  |   44|  6.89k|  do {                                 \
  |  |   45|  6.89k|    const auto _status = expr;         \
  |  |   46|  6.89k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 6.89k]
  |  |  ------------------
  |  |   47|  6.89k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 6.89k]
  |  |  ------------------
  ------------------
  614|  6.89k|  RETURN_IF_ERROR(LoadSentences());
  ------------------
  |  |   44|  6.89k|  do {                                 \
  |  |   45|  6.89k|    const auto _status = expr;         \
  |  |   46|  6.89k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 82, False: 6.81k]
  |  |  ------------------
  |  |   47|  6.89k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 6.81k]
  |  |  ------------------
  ------------------
  615|  6.81k|  RET_CHECK(!required_chars_.empty());
  ------------------
  |  |  321|  6.81k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 6.80k, False: 10]
  |  |  ------------------
  |  |  322|  6.80k|  } else /* NOLINT */                                        \
  |  |  323|  6.81k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|     10|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|     10|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  616|       |
  617|  6.80k|  auto seed_sentencepieces = MakeSeedSentencePieces();
  618|  6.80k|  RET_CHECK(!seed_sentencepieces.empty());
  ------------------
  |  |  321|  6.80k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 6.80k, False: 0]
  |  |  ------------------
  |  |  322|  6.80k|  } else /* NOLINT */                                        \
  |  |  323|  6.80k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  619|       |
  620|  6.80k|  RETURN_IF_ERROR(model.SetSentencePieces(std::move(seed_sentencepieces)));
  ------------------
  |  |   44|  6.80k|  do {                                 \
  |  |   45|  6.80k|    const auto _status = expr;         \
  |  |   46|  6.80k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 6.80k]
  |  |  ------------------
  |  |   47|  6.80k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 6.80k]
  |  |  ------------------
  ------------------
  621|       |
  622|  6.80k|  if (trainer_spec_.split_by_whitespace()) {
  ------------------
  |  Branch (622:7): [True: 6.16k, False: 638]
  ------------------
  623|  6.16k|    SplitSentencesByWhitespace();
  624|  6.16k|  }
  625|       |
  626|  20.4k|  LOG(INFO) << "Using " << sentences_.size() << " sentences for EM training";
  ------------------
  |  |  218|  6.80k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  6.80k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  6.80k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  13.6k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  13.6k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 6.80k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  6.80k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 6.80k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  6.80k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 6.80k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  6.80k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  27.2k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  27.2k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  627|       |
  628|  6.80k|  desired_vocab_size_ = static_cast<size_t>(trainer_spec_.vocab_size() * 1.1);
  629|       |
  630|  17.4k|  while (true) {
  ------------------
  |  Branch (630:10): [True: 17.4k, Folded]
  ------------------
  631|       |    // Sub-EM iteration.
  632|  52.3k|    for (int iter = 0; iter < trainer_spec_.num_sub_iterations(); ++iter) {
  ------------------
  |  Branch (632:24): [True: 34.9k, False: 17.4k]
  ------------------
  633|       |      // Executes E step
  634|  34.9k|      float objective = 0.0;
  635|  34.9k|      int64_t num_tokens = 0;
  636|  34.9k|      const auto expected = RunEStep(model, &objective, &num_tokens);
  637|       |
  638|       |      // Executes M step.
  639|  34.9k|      auto new_sentencepieces = RunMStep(model, expected);
  640|  34.9k|      RETURN_IF_ERROR(model.SetSentencePieces(std::move(new_sentencepieces)));
  ------------------
  |  |   44|  34.9k|  do {                                 \
  |  |   45|  34.9k|    const auto _status = expr;         \
  |  |   46|  34.9k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 6, False: 34.9k]
  |  |  ------------------
  |  |   47|  34.9k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 34.9k]
  |  |  ------------------
  ------------------
  641|       |
  642|   104k|      LOG(INFO) << "EM sub_iter=" << iter << " size=" << model.GetPieceSize()
  ------------------
  |  |  218|  34.9k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  34.9k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  34.9k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  69.8k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  69.8k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 34.9k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  34.9k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 34.9k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  34.9k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 34.9k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  34.9k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|   384k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|   384k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  643|   104k|                << " obj=" << objective << " num_tokens=" << num_tokens
  644|   104k|                << " num_tokens/piece="
  645|   104k|                << 1.0 * num_tokens / model.GetPieceSize();
  646|  34.9k|    }  // end of Sub EM iteration
  647|       |
  648|       |    // Stops the iteration when the size of sentences reaches to the
  649|       |    // desired symbol size.
  650|  17.4k|    if (model.GetPieceSize() <= desired_vocab_size_) {
  ------------------
  |  Branch (650:9): [True: 6.79k, False: 10.6k]
  ------------------
  651|  6.79k|      break;
  652|  6.79k|    }
  653|       |
  654|       |    // Prunes pieces.
  655|  10.6k|    auto new_sentencepieces = PruneSentencePieces(model);
  656|  10.6k|    RETURN_IF_ERROR(model.SetSentencePieces(std::move(new_sentencepieces)));
  ------------------
  |  |   44|  10.6k|  do {                                 \
  |  |   45|  10.6k|    const auto _status = expr;         \
  |  |   46|  10.6k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 10.6k]
  |  |  ------------------
  |  |   47|  10.6k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 10.6k]
  |  |  ------------------
  ------------------
  657|  10.6k|  }  // end of EM iteration
  658|       |
  659|       |  // Finally, adjusts the size of sentencepices to be |vocab_size|.
  660|  6.79k|  final_pieces_ = FinalizeSentencePieces(model);
  661|       |
  662|  6.79k|  return Save();
  663|  6.80k|}
unigram_model_trainer.cc:_ZN13sentencepiece7unigram12_GLOBAL__N_17DigammaEd:
   46|  4.47M|double Digamma(double x) {
   47|  4.47M|  double result = 0.0;
   48|  26.3M|  for (; x < 7; ++x) result -= 1 / x;
  ------------------
  |  Branch (48:10): [True: 21.8M, False: 4.47M]
  ------------------
   49|  4.47M|  x -= 1.0 / 2.0;
   50|  4.47M|  const double xx = 1.0 / x;
   51|  4.47M|  const double xx2 = xx * xx;
   52|  4.47M|  const double xx4 = xx2 * xx2;
   53|  4.47M|  result += std::log(x) + (1.0 / 24.0) * xx2 - (7.0 / 960.0) * xx4 +
   54|  4.47M|            (31.0 / 8064.0) * xx4 * xx2 - (127.0 / 30720.0) * xx4 * xx4;
   55|  4.47M|  return result;
   56|  4.47M|}
unigram_model_trainer.cc:_ZN13sentencepiece7unigram12_GLOBAL__N_120BoundedPriorityQueueC2Em:
   72|  6.80k|  explicit BoundedPriorityQueue(size_t size) : max_capacity_(size) {}
unigram_model_trainer.cc:_ZN13sentencepiece7unigram12_GLOBAL__N_120BoundedPriorityQueue4PushERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEl:
   74|  6.73M|  void Push(const std::string &key, int64_t score) {
   75|  6.73M|    auto &current_score = data_[key];  // initializes with 0 if not exists.
   76|  6.73M|    if (score > current_score) {
  ------------------
  |  Branch (76:9): [True: 1.95M, False: 4.77M]
  ------------------
   77|  1.95M|      current_score = score;
   78|  1.95M|    }
   79|       |    // Run GC when the size exceeds 8 * max_capacity_
   80|  6.73M|    if (data_.size() > 8 * max_capacity_) {
  ------------------
  |  Branch (80:9): [True: 0, False: 6.73M]
  ------------------
   81|      0|      Gc();
   82|      0|    }
   83|  6.73M|  }
unigram_model_trainer.cc:_ZN13sentencepiece7unigram12_GLOBAL__N_120BoundedPriorityQueue4SortERNSt3__16vectorINS3_4pairINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElEENS9_ISC_EEEE:
  115|  6.80k|  void Sort(std::vector<std::pair<std::string, int64_t>> &agenda) {
  116|  6.80k|    std::sort(
  117|  6.80k|        agenda.begin(), agenda.end(), [](const auto &lhs, const auto &rhs) {
  118|       |          // Sort by score, length, and dictionary order.
  119|  6.80k|          return std::forward_as_tuple(rhs.second, rhs.first.size(),
  120|  6.80k|                                       lhs.first) <
  121|  6.80k|                 std::forward_as_tuple(lhs.second, lhs.first.size(), rhs.first);
  122|  6.80k|        });
  123|  6.80k|  }
unigram_model_trainer.cc:_ZZN13sentencepiece7unigram12_GLOBAL__N_120BoundedPriorityQueue4SortERNSt3__16vectorINS3_4pairINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElEENS9_ISC_EEEEENKUlRKT_RKT0_E_clISC_SC_EEDaSI_SL_:
  117|  20.0M|        agenda.begin(), agenda.end(), [](const auto &lhs, const auto &rhs) {
  118|       |          // Sort by score, length, and dictionary order.
  119|  20.0M|          return std::forward_as_tuple(rhs.second, rhs.first.size(),
  120|  20.0M|                                       lhs.first) <
  121|  20.0M|                 std::forward_as_tuple(lhs.second, lhs.first.size(), rhs.first);
  122|  20.0M|        });
unigram_model_trainer.cc:_ZN13sentencepiece7unigram12_GLOBAL__N_120BoundedPriorityQueue3GetEv:
   85|  6.80k|  std::vector<std::pair<std::string, int64_t>> Get() {
   86|  6.80k|    std::vector<std::pair<std::string, int64_t>> results;
   87|  6.80k|    results.reserve(data_.size());
   88|  1.76M|    for (auto &it : data_) results.emplace_back(std::move(it));
  ------------------
  |  Branch (88:19): [True: 1.76M, False: 6.80k]
  ------------------
   89|  6.80k|    data_.clear();
   90|       |
   91|  6.80k|    Sort(results);
   92|       |
   93|  6.80k|    if (results.size() > max_capacity_) {
  ------------------
  |  Branch (93:9): [True: 0, False: 6.80k]
  ------------------
   94|      0|      results.resize(max_capacity_);
   95|      0|    }
   96|       |
   97|  6.80k|    return results;
   98|  6.80k|  }
unigram_model_trainer.cc:_ZN13sentencepiece7unigram12_GLOBAL__N_19ToLogProbINSt3__111__wrap_iterIPNS3_4pairINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEEEEEEvT_SF_:
   59|  6.80k|void ToLogProb(IT begin, IT end) {
   60|  6.80k|  float sum = 0.0;
   61|  1.95M|  for (auto it = begin; it != end; ++it) {
  ------------------
  |  Branch (61:25): [True: 1.94M, False: 6.80k]
  ------------------
   62|  1.94M|    sum += it->second;
   63|  1.94M|  }
   64|  6.80k|  float logsum = std::log(static_cast<double>(sum));
   65|  1.95M|  for (auto it = begin; it != end; ++it) {
  ------------------
  |  Branch (65:25): [True: 1.94M, False: 6.80k]
  ------------------
   66|  1.94M|    it->second = std::log(static_cast<double>(it->second)) - logsum;
   67|  1.94M|  }
   68|  6.80k|}
_ZN13sentencepiece7unigram7Trainer30MakeSeedSentencePiecesInternalIiEENSt3__16vectorINS3_4pairINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEENS9_ISC_EEEEv:
  171|  6.80k|TrainerModel::SentencePieces Trainer::MakeSeedSentencePiecesInternal() {
  172|  6.80k|  if (sentences_.empty() || required_chars_.empty()) {
  ------------------
  |  Branch (172:7): [True: 0, False: 6.80k]
  |  Branch (172:29): [True: 0, False: 6.80k]
  ------------------
  173|      0|    return {};
  174|      0|  }
  175|       |
  176|       |  // Pretokenizer applied only in training time.
  177|       |  // Pretokenizer is used as a constraint of piece extractions.
  178|  6.80k|  const auto *pretokenizer = SentencePieceTrainer::GetPretokenizerForTraining();
  179|       |
  180|  6.80k|  auto pretokenize_or_rewrite = [&](std::pair<std::string, int64_t> *w) {
  181|  6.80k|    if (pretokenizer) {
  182|  6.80k|      std::vector<char32> chars;
  183|  6.80k|      for (const auto &w : pretokenizer->PreTokenize(w->first)) {
  184|  6.80k|        for (const auto &c : string_util::UTF8ToUnicodeText(w)) {
  185|  6.80k|          chars.push_back(c);
  186|  6.80k|        }
  187|  6.80k|        chars.push_back(kSentenceBoundary);
  188|  6.80k|      }
  189|  6.80k|      return chars;
  190|  6.80k|    } else if (!trainer_spec_.pretokenization_delimiter().empty()) {
  191|       |      // When delimiter is specified, tokenize the input with the delimiter.
  192|       |      // For EM training, we assume that the delimiter doesn't exist and
  193|       |      // rewrite the original sentence.
  194|  6.80k|      std::vector<char32> chars;
  195|  6.80k|      absl::string_view delimiter = trainer_spec_.pretokenization_delimiter();
  196|  6.80k|      for (const auto &w : absl::StrSplit(w->first, delimiter)) {
  197|  6.80k|        for (const auto &c : string_util::UTF8ToUnicodeText(w)) {
  198|  6.80k|          chars.push_back(c);
  199|  6.80k|        }
  200|  6.80k|        chars.push_back(kSentenceBoundary);
  201|  6.80k|      }
  202|       |      // Removes the delimiter.
  203|  6.80k|      w->first = absl::StrReplaceAll(w->first, {{delimiter, ""}});
  204|  6.80k|      return chars;
  205|  6.80k|    }
  206|  6.80k|    return string_util::UTF8ToUnicodeText(w->first);
  207|  6.80k|  };
  208|       |
  209|       |  // Merges all sentences into one array with 0x0000 delimiter.
  210|  6.80k|  std::vector<char32> array;
  211|  6.80k|  absl::flat_hash_map<std::string, int64_t> all_chars;
  212|       |
  213|  6.80k|  const bool is_tsv = trainer_spec_.input_format() == "tsv";
  214|       |
  215|  41.4k|  for (auto &w : sentences_) {
  ------------------
  |  Branch (215:16): [True: 41.4k, False: 6.80k]
  ------------------
  216|  41.4k|    const auto ut = pretokenize_or_rewrite(&w);
  217|  6.30M|    for (const auto &c : ut) {
  ------------------
  |  Branch (217:24): [True: 6.30M, False: 41.4k]
  ------------------
  218|  6.30M|      array.push_back(c);
  219|  6.30M|      if (c != kUNKChar && c != kSentenceBoundary) {
  ------------------
  |  Branch (219:11): [True: 6.02M, False: 279k]
  |  Branch (219:28): [True: 6.02M, False: 0]
  ------------------
  220|  6.02M|        all_chars[string_util::UnicodeCharToUTF8(c)] += w.second;
  221|  6.02M|      }
  222|  6.30M|    }
  223|  41.4k|    array.push_back(kSentenceBoundary);  // sentence boundary marker.
  224|       |
  225|       |    // Naive workaround to over-sample the input.
  226|       |    // In TSV mode, the frequency field is not used to extract the seed piece.
  227|       |    // we can at least extract all pieces by copying the input because
  228|       |    // the occurrence gets at least larger than or equals to 2.
  229|  41.4k|    if (is_tsv) {
  ------------------
  |  Branch (229:9): [True: 0, False: 41.4k]
  ------------------
  230|      0|      for (const auto &c : ut) array.push_back(c);
  ------------------
  |  Branch (230:26): [True: 0, False: 0]
  ------------------
  231|      0|      array.push_back(kSentenceBoundary);
  232|      0|    }
  233|  41.4k|  }
  234|       |
  235|       |  // all_chars must be included in the seed sentencepieces.
  236|  6.80k|  TrainerModel::SentencePieces seed_sentencepieces;
  237|   187k|  for (const auto &it : Sorted(all_chars)) {
  ------------------
  |  Branch (237:23): [True: 187k, False: 6.80k]
  ------------------
  238|   187k|    seed_sentencepieces.emplace_back(it);
  239|   187k|  }
  240|       |
  241|  6.80k|  if (!trainer_spec_.seed_sentencepieces_file().empty()) {
  ------------------
  |  Branch (241:7): [True: 0, False: 6.80k]
  ------------------
  242|      0|    auto seed_sentencepieces_file = sentencepiece::filesystem::NewReadableFile(
  243|      0|        trainer_spec_.seed_sentencepieces_file());
  244|      0|    std::string line;
  245|      0|    int64_t freq = 1;
  246|      0|    int skipped_sentencepieces = 0;
  247|      0|    while (seed_sentencepieces_file->ReadLine(&line)) {
  ------------------
  |  Branch (247:12): [True: 0, False: 0]
  ------------------
  248|      0|      const std::vector<std::string> fields = absl::StrSplit(line, '\t');
  249|      0|      if (fields.size() < 2) {
  ------------------
  |  Branch (249:11): [True: 0, False: 0]
  ------------------
  250|      0|        LOG(ERROR) << "Format error: must be <piece> <tab> <freq>";
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  251|      0|        return {};
  252|      0|      }
  253|      0|      const auto &seed_sentencepiece = fields[0];
  254|      0|      if (!absl::SimpleAtoi(fields[1], &freq)) {
  ------------------
  |  Branch (254:11): [True: 0, False: 0]
  ------------------
  255|      0|        LOG(ERROR) << "Could not parse the frequency; line: " << line;
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  256|      0|        return {};
  257|      0|      }
  258|      0|      const UnicodeText uw = string_util::UTF8ToUnicodeText(seed_sentencepiece);
  259|      0|      if (!IsValidSentencePiece(uw)) {
  ------------------
  |  Branch (259:11): [True: 0, False: 0]
  ------------------
  260|      0|        ++skipped_sentencepieces;
  261|      0|        continue;
  262|      0|      }
  263|       |      // Initialise score of a piece by character coverage.
  264|      0|      seed_sentencepieces.emplace_back(seed_sentencepiece, freq * uw.size());
  265|      0|      if (seed_sentencepieces.size() % 1000000 == 0) {
  ------------------
  |  Branch (265:11): [True: 0, False: 0]
  ------------------
  266|      0|        LOG(INFO) << "loaded " << seed_sentencepieces.size()
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  267|      0|                  << " seed sentencepieces";
  268|      0|      }
  269|      0|    }
  270|       |
  271|      0|    LOG(INFO) << "skipped " << skipped_sentencepieces << " seed sentencepieces";
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  272|       |
  273|       |    // Take highest scoring pieces as initial vocab.
  274|      0|    seed_sentencepieces = Sorted(seed_sentencepieces);
  275|      0|    seed_sentencepieces.resize(std::min<size_t>(
  276|      0|        trainer_spec_.seed_sentencepiece_size(), seed_sentencepieces.size()));
  277|       |
  278|      0|    LOG(INFO) << "Initialized " << seed_sentencepieces.size()
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  279|      0|              << " seed sentencepieces from file.";
  280|  6.80k|  } else {
  281|  6.80k|    CHECK_LE(array.size(),
  ------------------
  |  |  122|      0|  ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   53|  6.80k|  ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  6.80k|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 6.80k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  6.80k|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  6.80k|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  6.80k|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  6.80k|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  6.80k|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  6.80k|    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|  6.80k|  ABSL_LOG_INTERNAL_CHECK(::absl::implicit_cast<const char* absl_nonnull>(     \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   84|  6.80k|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   76|      0|                              absl_log_internal_check_op_result))              \
  |  |  |  |  |  |   77|      0|      .InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  282|      0|             static_cast<size_t>(std::numeric_limits<node_int_type>::max()))
  283|      0|        << "Input corpus too large, try with train_extremely_large_corpus=true";
  284|  6.80k|    const node_int_type n = array.size();
  285|       |
  286|  6.80k|    std::vector<node_int_type> SA(n);  // suffix array
  287|  6.80k|    std::vector<node_int_type> L(n);   // left boundaries of internal node
  288|  6.80k|    std::vector<node_int_type> R(n);   // right boundaries of internal node
  289|  6.80k|    std::vector<node_int_type> D(n);   // depths of internal node
  290|       |
  291|       |    // Makes a suffix array to extract all sub strings occurring
  292|       |    // more than 2 times in the sentence.
  293|  6.80k|    constexpr node_int_type kAlphabetSize = 0x110000;  // All UCS4 range.
  294|  6.80k|    node_int_type node_num = 0;
  295|  20.4k|    LOG(INFO) << "Making suffix array...";
  ------------------
  |  |  218|  6.80k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  6.80k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  6.80k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  13.6k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  13.6k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 6.80k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  6.80k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 6.80k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  6.80k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 6.80k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  6.80k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  13.6k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  13.6k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  296|  6.80k|    CHECK_EQ(0, esaxx(array.begin(), SA.begin(), L.begin(), R.begin(),
  ------------------
  |  |  118|  6.80k|  ABSL_LOG_INTERNAL_CHECK_EQ_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   49|  6.80k|  ABSL_LOG_INTERNAL_CHECK_OP(Check_EQ, ==, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  6.80k|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 6.80k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  6.80k|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  6.80k|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  6.80k|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  6.80k|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  6.80k|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  6.80k|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  297|  6.80k|                      D.begin(), n, kAlphabetSize, node_num));
  298|       |
  299|  20.4k|    LOG(INFO) << "Extracting frequent sub strings... node_num=" << node_num;
  ------------------
  |  |  218|  6.80k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  6.80k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  6.80k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  13.6k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  13.6k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 6.80k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  6.80k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 6.80k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  6.80k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 6.80k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  6.80k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  20.4k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  20.4k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  300|       |
  301|  6.80k|    BoundedPriorityQueue queue(
  302|  6.80k|        static_cast<size_t>(trainer_spec_.seed_sentencepiece_size()));
  303|       |
  304|       |    // split candidate frequent piece into the actual piece.
  305|  6.80k|    auto split_into_pieces =
  306|  6.80k|        [&](absl::string_view w) -> std::vector<absl::string_view> {
  307|  6.80k|      if (trainer_spec_.split_by_whitespace()) {
  308|  6.80k|        return SplitIntoWords(w, trainer_spec_.treat_whitespace_as_suffix(),
  309|  6.80k|                              trainer_spec_.allow_whitespace_only_pieces());
  310|  6.80k|      }
  311|  6.80k|      return {w};
  312|  6.80k|    };
  313|       |
  314|  3.79M|    for (node_int_type i = 0; i < node_num; ++i) {
  ------------------
  |  Branch (314:31): [True: 3.79M, False: 6.80k]
  ------------------
  315|  3.79M|      const node_int_type offset = SA[L[i]];
  316|  3.79M|      const node_int_type len = D[i];
  317|  3.79M|      if (len <= 1 || offset >= array.size() || offset + len >= array.size()) {
  ------------------
  |  Branch (317:11): [True: 106k, False: 3.68M]
  |  Branch (317:23): [True: 0, False: 3.68M]
  |  Branch (317:49): [True: 69.4k, False: 3.61M]
  ------------------
  318|   175k|        continue;
  319|   175k|      }
  320|  3.61M|      const char32 *begin = &array[offset];
  321|  3.61M|      const char32 *end = &array[offset + len];
  322|  3.61M|      const uint64_t freq = R[i] - L[i];
  323|       |
  324|       |      // Split by kSentenceBoundary, as some frequent phrases may cross
  325|       |      // the sentence boundary.
  326|  8.50M|      while (begin < end) {
  ------------------
  |  Branch (326:14): [True: 4.89M, False: 3.61M]
  ------------------
  327|  4.89M|        const char32 *delim = std::find(begin, end, kSentenceBoundary);
  328|  4.89M|        const UnicodeText uw(begin, delim);
  329|  4.89M|        begin = delim + 1;
  330|  4.89M|        if (uw.size() <= 1) continue;
  ------------------
  |  Branch (330:13): [True: 50.1k, False: 4.84M]
  ------------------
  331|       |
  332|  4.84M|        const std::string w = string_util::UnicodeTextToUTF8(uw);
  333|  11.0M|        for (absl::string_view piece : split_into_pieces(w)) {
  ------------------
  |  Branch (333:38): [True: 11.0M, False: 4.84M]
  ------------------
  334|  11.0M|          const UnicodeText pw = string_util::UTF8ToUnicodeText(piece);
  335|  11.0M|          if (pw.size() <= 1 || !IsValidSentencePiece(pw)) {
  ------------------
  |  Branch (335:15): [True: 180k, False: 10.8M]
  |  Branch (335:33): [True: 4.15M, False: 6.73M]
  ------------------
  336|  4.33M|            continue;
  337|  4.33M|          }
  338|  6.73M|          const uint64_t score = freq * pw.size();
  339|  6.73M|          queue.Push(std::string(piece), score);
  340|  6.73M|        }
  341|  4.84M|      }
  342|  3.61M|    }
  343|       |
  344|  1.76M|    for (auto &[w, score] : queue.Get()) {
  ------------------
  |  Branch (344:27): [True: 1.76M, False: 6.80k]
  ------------------
  345|  1.76M|      CHECK(!port::ContainsKey(all_chars, w));
  ------------------
  |  |   58|  1.76M|#define CHECK(condition) ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   27|  3.52M|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  180|  1.76M|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  3.52M|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  3.52M|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1.76M, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  1.76M|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1.76M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  3.52M|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 1.76M, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 1.76M]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 1.76M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  3.52M|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |   29|  3.52M|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  346|  1.76M|      seed_sentencepieces.emplace_back(std::move(w), score);
  347|  1.76M|    }
  348|  6.80k|  }
  349|       |
  350|  6.80k|  ToLogProb(seed_sentencepieces.begin(), seed_sentencepieces.end());
  351|       |
  352|  20.4k|  LOG(INFO) << "Initialized " << seed_sentencepieces.size()
  ------------------
  |  |  218|  6.80k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  6.80k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  6.80k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  13.6k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  13.6k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 6.80k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  6.80k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 6.80k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  6.80k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 6.80k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  6.80k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  27.2k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  27.2k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  353|  20.4k|            << " seed sentencepieces";
  354|       |
  355|  6.80k|  return seed_sentencepieces;
  356|  6.80k|}
_ZZN13sentencepiece7unigram7Trainer30MakeSeedSentencePiecesInternalIiEENSt3__16vectorINS3_4pairINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEENS9_ISC_EEEEvENKUlPNS5_ISB_lEEE_clESG_:
  180|  41.4k|  auto pretokenize_or_rewrite = [&](std::pair<std::string, int64_t> *w) {
  181|  41.4k|    if (pretokenizer) {
  ------------------
  |  Branch (181:9): [True: 0, False: 41.4k]
  ------------------
  182|      0|      std::vector<char32> chars;
  183|      0|      for (const auto &w : pretokenizer->PreTokenize(w->first)) {
  ------------------
  |  Branch (183:26): [True: 0, False: 0]
  ------------------
  184|      0|        for (const auto &c : string_util::UTF8ToUnicodeText(w)) {
  ------------------
  |  Branch (184:28): [True: 0, False: 0]
  ------------------
  185|      0|          chars.push_back(c);
  186|      0|        }
  187|      0|        chars.push_back(kSentenceBoundary);
  188|      0|      }
  189|      0|      return chars;
  190|  41.4k|    } else if (!trainer_spec_.pretokenization_delimiter().empty()) {
  ------------------
  |  Branch (190:16): [True: 0, False: 41.4k]
  ------------------
  191|       |      // When delimiter is specified, tokenize the input with the delimiter.
  192|       |      // For EM training, we assume that the delimiter doesn't exist and
  193|       |      // rewrite the original sentence.
  194|      0|      std::vector<char32> chars;
  195|      0|      absl::string_view delimiter = trainer_spec_.pretokenization_delimiter();
  196|      0|      for (const auto &w : absl::StrSplit(w->first, delimiter)) {
  ------------------
  |  Branch (196:26): [True: 0, False: 0]
  ------------------
  197|      0|        for (const auto &c : string_util::UTF8ToUnicodeText(w)) {
  ------------------
  |  Branch (197:28): [True: 0, False: 0]
  ------------------
  198|      0|          chars.push_back(c);
  199|      0|        }
  200|      0|        chars.push_back(kSentenceBoundary);
  201|      0|      }
  202|       |      // Removes the delimiter.
  203|      0|      w->first = absl::StrReplaceAll(w->first, {{delimiter, ""}});
  204|      0|      return chars;
  205|      0|    }
  206|  41.4k|    return string_util::UTF8ToUnicodeText(w->first);
  207|  41.4k|  };
_ZZN13sentencepiece7unigram7Trainer30MakeSeedSentencePiecesInternalIiEENSt3__16vectorINS3_4pairINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEENS9_ISC_EEEEvENKUlNS3_17basic_string_viewIcS8_EEE_clESG_:
  306|  4.84M|        [&](absl::string_view w) -> std::vector<absl::string_view> {
  307|  4.84M|      if (trainer_spec_.split_by_whitespace()) {
  ------------------
  |  Branch (307:11): [True: 4.71M, False: 127k]
  ------------------
  308|  4.71M|        return SplitIntoWords(w, trainer_spec_.treat_whitespace_as_suffix(),
  309|  4.71M|                              trainer_spec_.allow_whitespace_only_pieces());
  310|  4.71M|      }
  311|   127k|      return {w};
  312|  4.84M|    };
unigram_model_trainer.cc:_ZZNK13sentencepiece7unigram7Trainer8RunEStepERKNS0_12TrainerModelEPfPlENK3$_0clEv:
  373|  34.9k|    pool->Schedule([&, n]() {
  374|  34.9k|      Lattice lattice;
  375|  34.9k|      expected[n].resize(model.GetPieceSize(), 0.0);
  376|  1.72M|      for (size_t i = n; i < sentences_.size();
  ------------------
  |  Branch (376:26): [True: 1.68M, False: 34.9k]
  ------------------
  377|  1.68M|           i += trainer_spec_.num_threads()) {
  378|  1.68M|        const std::string &w = sentences_[i].first;
  379|  1.68M|        const int64_t freq = sentences_[i].second;
  380|  1.68M|        lattice.SetSentence(w);
  381|  1.68M|        model.PopulateNodes(&lattice);
  382|  1.68M|        const float Z = lattice.PopulateMarginal(freq, &expected[n]);
  383|  1.68M|        ntokens[n] += lattice.Viterbi().first.size() * freq;
  384|  3.37M|        CHECK(!std::isnan(Z))
  ------------------
  |  |   58|  1.68M|#define CHECK(condition) ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  180|  1.68M|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  3.37M|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  3.37M|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1.68M, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  1.68M|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1.68M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  3.37M|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 1.68M, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 1.68M]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 1.68M]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |   29|  1.68M|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   84|  1.68M|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  385|  3.37M|            << "likelihood is NAN. Input sentence may be too long";
  386|  1.68M|        objs[n] -= Z / all_sentence_freq;
  387|  1.68M|      }
  388|  34.9k|    });
unigram_model_trainer.cc:_ZZNK13sentencepiece7unigram7Trainer19PruneSentencePiecesERKNS0_12TrainerModelEENK3$_0clEv:
  483|  10.6k|      pool->Schedule([&, n]() {
  484|  10.6k|        Lattice lattice;
  485|   703k|        for (size_t i = n; i < sentences_.size();
  ------------------
  |  Branch (485:28): [True: 692k, False: 10.6k]
  ------------------
  486|   692k|             i += trainer_spec_.num_threads()) {
  487|   692k|          const auto &w = sentences_[i];
  488|   692k|          lattice.SetSentence(w.first);
  489|   692k|          model.PopulateNodes(&lattice);
  490|  15.6M|          for (const auto *node : lattice.Viterbi().first) {
  ------------------
  |  Branch (490:33): [True: 15.6M, False: 692k]
  ------------------
  491|  15.6M|            if (node->id >= 0) {
  ------------------
  |  Branch (491:17): [True: 15.6M, False: 0]
  ------------------
  492|  15.6M|              freqs[n][node->id] += w.second;
  493|  15.6M|            }
  494|  15.6M|          }
  495|   692k|        }
  496|  10.6k|      });

_ZN13sentencepiece7unigram7TrainerC2ERKNS_11TrainerSpecERKNS_14NormalizerSpecES7_:
   68|  6.89k|      : TrainerInterface::TrainerInterface(trainer_spec, normalizer_spec,
   69|  6.89k|                                           denormalizer_spec) {}

_ZN13sentencepiece11string_util10DecodeUTF8EPKcS2_Pm:
   59|   350M|char32 DecodeUTF8(const char *begin, const char *end, size_t *mblen) {
   60|   350M|  const size_t len = end - begin;
   61|       |
   62|   350M|  if (static_cast<unsigned char>(begin[0]) < 0x80) {
  ------------------
  |  Branch (62:7): [True: 253M, False: 96.9M]
  ------------------
   63|   253M|    *mblen = 1;
   64|   253M|    return static_cast<unsigned char>(begin[0]);
   65|   253M|  } else if (len >= 2 && (begin[0] & 0xE0) == 0xC0) {
  ------------------
  |  Branch (65:14): [True: 96.9M, False: 18.0k]
  |  Branch (65:26): [True: 5.49M, False: 91.4M]
  ------------------
   66|  5.49M|    const char32 cp = (((begin[0] & 0x1F) << 6) | ((begin[1] & 0x3F)));
   67|  5.49M|    if (IsTrailByte(begin[1]) && cp >= 0x0080 && IsValidCodepoint(cp)) {
  ------------------
  |  Branch (67:9): [True: 5.07M, False: 419k]
  |  Branch (67:34): [True: 5.06M, False: 6.50k]
  |  Branch (67:50): [True: 5.06M, False: 0]
  ------------------
   68|  5.06M|      *mblen = 2;
   69|  5.06M|      return cp;
   70|  5.06M|    }
   71|  91.4M|  } else if (len >= 3 && (begin[0] & 0xF0) == 0xE0) {
  ------------------
  |  Branch (71:14): [True: 91.4M, False: 30.5k]
  |  Branch (71:26): [True: 89.7M, False: 1.70M]
  ------------------
   72|  89.7M|    const char32 cp = (((begin[0] & 0x0F) << 12) | ((begin[1] & 0x3F) << 6) |
   73|  89.7M|                       ((begin[2] & 0x3F)));
   74|  89.7M|    if (IsTrailByte(begin[1]) && IsTrailByte(begin[2]) && cp >= 0x0800 &&
  ------------------
  |  Branch (74:9): [True: 89.4M, False: 240k]
  |  Branch (74:34): [True: 89.4M, False: 24.8k]
  |  Branch (74:59): [True: 89.4M, False: 366]
  ------------------
   75|  89.4M|        IsValidCodepoint(cp)) {
  ------------------
  |  Branch (75:9): [True: 89.4M, False: 2.30k]
  ------------------
   76|  89.4M|      *mblen = 3;
   77|  89.4M|      return cp;
   78|  89.4M|    }
   79|  89.7M|  } else if (len >= 4 && (begin[0] & 0xf8) == 0xF0) {
  ------------------
  |  Branch (79:14): [True: 1.69M, False: 40.9k]
  |  Branch (79:26): [True: 169k, False: 1.52M]
  ------------------
   80|   169k|    const char32 cp = (((begin[0] & 0x07) << 18) | ((begin[1] & 0x3F) << 12) |
   81|   169k|                       ((begin[2] & 0x3F) << 6) | ((begin[3] & 0x3F)));
   82|   169k|    if (IsTrailByte(begin[1]) && IsTrailByte(begin[2]) &&
  ------------------
  |  Branch (82:9): [True: 114k, False: 55.1k]
  |  Branch (82:34): [True: 100k, False: 13.6k]
  ------------------
   83|   100k|        IsTrailByte(begin[3]) && cp >= 0x10000 && IsValidCodepoint(cp)) {
  ------------------
  |  Branch (83:9): [True: 94.2k, False: 6.12k]
  |  Branch (83:34): [True: 93.9k, False: 333]
  |  Branch (83:51): [True: 88.2k, False: 5.71k]
  ------------------
   84|  88.2k|      *mblen = 4;
   85|  88.2k|      return cp;
   86|  88.2k|    }
   87|   169k|  }
   88|       |
   89|       |  // Invalid UTF-8.
   90|  2.33M|  *mblen = 1;
   91|  2.33M|  return kUnicodeError;
   92|   350M|}
_ZN13sentencepiece11string_util19IsStructurallyValidENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
   94|   405k|bool IsStructurallyValid(absl::string_view str) {
   95|   405k|  const char *begin = str.data();
   96|   405k|  const char *end = str.data() + str.size();
   97|   405k|  size_t mblen = 0;
   98|  1.58M|  while (begin < end) {
  ------------------
  |  Branch (98:10): [True: 1.17M, False: 405k]
  ------------------
   99|  1.17M|    const char32 c = DecodeUTF8(begin, end, &mblen);
  100|  1.17M|    if (c == kUnicodeError && mblen != 3) return false;
  ------------------
  |  Branch (100:9): [True: 282k, False: 897k]
  |  Branch (100:31): [True: 0, False: 282k]
  ------------------
  101|  1.17M|    if (!IsValidCodepoint(c)) return false;
  ------------------
  |  Branch (101:9): [True: 0, False: 1.17M]
  ------------------
  102|  1.17M|    begin += mblen;
  103|  1.17M|  }
  104|   405k|  return true;
  105|   405k|}
_ZN13sentencepiece11string_util10EncodeUTF8EjPc:
  107|   331M|size_t EncodeUTF8(char32 c, char *output) {
  108|   331M|  if (c <= 0x7F) {
  ------------------
  |  Branch (108:7): [True: 239M, False: 91.3M]
  ------------------
  109|   239M|    *output = static_cast<char>(c);
  110|   239M|    return 1;
  111|   239M|  }
  112|       |
  113|  91.3M|  if (c <= 0x7FF) {
  ------------------
  |  Branch (113:7): [True: 4.58M, False: 86.7M]
  ------------------
  114|  4.58M|    output[1] = 0x80 | (c & 0x3F);
  115|  4.58M|    c >>= 6;
  116|  4.58M|    output[0] = 0xC0 | c;
  117|  4.58M|    return 2;
  118|  4.58M|  }
  119|       |
  120|       |  // if `c` is out-of-range, convert it to REPLACEMENT CHARACTER (U+FFFD).
  121|       |  // This treatment is the same as the original runetochar.
  122|  86.7M|  if (c > 0x10FFFF) c = kUnicodeError;
  ------------------
  |  Branch (122:7): [True: 0, False: 86.7M]
  ------------------
  123|       |
  124|  86.7M|  if (c <= 0xFFFF) {
  ------------------
  |  Branch (124:7): [True: 86.6M, False: 86.3k]
  ------------------
  125|  86.6M|    output[2] = 0x80 | (c & 0x3F);
  126|  86.6M|    c >>= 6;
  127|  86.6M|    output[1] = 0x80 | (c & 0x3F);
  128|  86.6M|    c >>= 6;
  129|  86.6M|    output[0] = 0xE0 | c;
  130|  86.6M|    return 3;
  131|  86.6M|  }
  132|       |
  133|  86.3k|  output[3] = 0x80 | (c & 0x3F);
  134|  86.3k|  c >>= 6;
  135|  86.3k|  output[2] = 0x80 | (c & 0x3F);
  136|  86.3k|  c >>= 6;
  137|  86.3k|  output[1] = 0x80 | (c & 0x3F);
  138|  86.3k|  c >>= 6;
  139|  86.3k|  output[0] = 0xF0 | c;
  140|       |
  141|  86.3k|  return 4;
  142|  86.7M|}
_ZN13sentencepiece11string_util17UnicodeCharToUTF8Ej:
  144|  6.22M|std::string UnicodeCharToUTF8(const char32 c) { return UnicodeTextToUTF8({c}); }
_ZN13sentencepiece11string_util17UTF8ToUnicodeTextENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  146|  11.2M|UnicodeText UTF8ToUnicodeText(absl::string_view utf8) {
  147|  11.2M|  UnicodeText uc;
  148|  11.2M|  const char *begin = utf8.data();
  149|  11.2M|  const char *end = utf8.data() + utf8.size();
  150|   350M|  while (begin < end) {
  ------------------
  |  Branch (150:10): [True: 339M, False: 11.2M]
  ------------------
  151|   339M|    size_t mblen;
  152|   339M|    const char32 c = DecodeUTF8(begin, end, &mblen);
  153|   339M|    uc.push_back(c);
  154|   339M|    begin += mblen;
  155|   339M|  }
  156|  11.2M|  return uc;
  157|  11.2M|}
_ZN13sentencepiece11string_util17UnicodeTextToUTF8ERKNSt3__16vectorIjNS1_9allocatorIjEEEE:
  159|  12.2M|std::string UnicodeTextToUTF8(const UnicodeText &utext) {
  160|  12.2M|  char buf[8];
  161|  12.2M|  std::string result;
  162|   331M|  for (const char32 c : utext) {
  ------------------
  |  Branch (162:23): [True: 331M, False: 12.2M]
  ------------------
  163|   331M|    const size_t mblen = EncodeUTF8(c, buf);
  164|   331M|    result.append(buf, mblen);
  165|   331M|  }
  166|  12.2M|  return result;
  167|  12.2M|}

_ZN13sentencepiece4util13StatusBuilderC2ENS0_10StatusCodeE:
  304|  5.23k|  explicit StatusBuilder(StatusCode code) : code_(code) {}
_ZNK13sentencepiece4util13StatusBuildercvNS0_6StatusEEv:
  313|  5.23k|  operator Status() const { return Status(code_, os_.str()); }
_ZN13sentencepiece4util8OkStatusEv:
  273|   318k|inline Status OkStatus() { return Status(); }
_ZN13sentencepiece11string_util10OneCharLenEPKc:
  106|   441M|inline size_t OneCharLen(const char *src) {
  107|   441M|  return "\1\1\1\1\1\1\1\1\1\1\1\1\2\2\3\4"[(*src & 0xFF) >> 4];
  108|   441M|}
_ZN13sentencepiece4util13StatusBuilderlsIA2_cEERS1_RKT_:
  308|  5.23k|  StatusBuilder &operator<<(const T &value) {
  309|  5.23k|    os_ << value;
  310|  5.23k|    return *this;
  311|  5.23k|  }
_ZN13sentencepiece4util13StatusBuilderlsIiEERS1_RKT_:
  308|  5.32k|  StatusBuilder &operator<<(const T &value) {
  309|  5.32k|    os_ << value;
  310|  5.32k|    return *this;
  311|  5.32k|  }
_ZN13sentencepiece4util13StatusBuilderlsIA4_cEERS1_RKT_:
  308|  5.23k|  StatusBuilder &operator<<(const T &value) {
  309|  5.23k|    os_ << value;
  310|  5.23k|    return *this;
  311|  5.23k|  }
_ZN13sentencepiece4util13StatusBuilderlsIA3_cEERS1_RKT_:
  308|  5.32k|  StatusBuilder &operator<<(const T &value) {
  309|  5.32k|    os_ << value;
  310|  5.32k|    return *this;
  311|  5.32k|  }
_ZN13sentencepiece4util13StatusBuilderlsIA29_cEERS1_RKT_:
  308|    101|  StatusBuilder &operator<<(const T &value) {
  309|    101|    os_ << value;
  310|    101|    return *this;
  311|    101|  }
_ZN13sentencepiece10ThreadPoolC2Ei:
  355|  55.6k|  explicit ThreadPool(int num_threads) {
  356|  55.6k|    threads_.reserve(num_threads);
  357|   111k|    for (int i = 0; i < num_threads; ++i) {
  ------------------
  |  Branch (357:21): [True: 55.6k, False: 55.6k]
  ------------------
  358|  55.6k|      threads_.push_back(std::thread(&ThreadPool::WorkLoop, this));
  359|  55.6k|    }
  360|  55.6k|  }
_ZN13sentencepiece10ThreadPoolD2Ev:
  365|  55.6k|  ~ThreadPool() {
  366|  55.6k|    {
  367|  55.6k|      absl::MutexLock l(mu_);
  368|   111k|      for (size_t i = 0; i < threads_.size(); i++) {
  ------------------
  |  Branch (368:26): [True: 55.6k, False: 55.6k]
  ------------------
  369|  55.6k|        queue_.push(nullptr);  // Shutdown signal.
  370|  55.6k|      }
  371|  55.6k|    }
  372|  55.6k|    for (auto &thread : threads_) thread.join();
  ------------------
  |  Branch (372:23): [True: 55.6k, False: 55.6k]
  ------------------
  373|  55.6k|  }
_ZN13sentencepiece10ThreadPool8ScheduleEN4absl12lts_2026010712AnyInvocableIFvvEEE:
  375|  55.6k|  void Schedule(absl::AnyInvocable<void()> func) {
  376|  55.6k|    absl::MutexLock l(mu_);
  377|  55.6k|    queue_.push(std::move(func));
  378|  55.6k|  }
_ZNK13sentencepiece10ThreadPool13WorkAvailableEv:
  381|   111k|  bool WorkAvailable() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
  382|   111k|    return !queue_.empty();
  383|   111k|  }
_ZN13sentencepiece10ThreadPool8WorkLoopEv:
  385|  55.6k|  void WorkLoop() {
  386|   111k|    while (true) {
  ------------------
  |  Branch (386:12): [True: 111k, Folded]
  ------------------
  387|   111k|      absl::AnyInvocable<void()> func;
  388|   111k|      {
  389|   111k|        absl::MutexLock l(mu_);
  390|   111k|        mu_.Await(absl::Condition(this, &ThreadPool::WorkAvailable));
  391|   111k|        func = std::move(queue_.front());
  392|   111k|        queue_.pop();
  393|   111k|      }
  394|   111k|      if (func == nullptr) {  // Shutdown signal.
  ------------------
  |  Branch (394:11): [True: 55.6k, False: 55.6k]
  ------------------
  395|  55.6k|        break;
  396|  55.6k|      }
  397|  55.6k|      func();
  398|  55.6k|    }
  399|  55.6k|  }
_ZN13sentencepiece11string_util11IsTrailByteEc:
  112|   185M|inline bool IsTrailByte(char x) { return static_cast<signed char>(x) < -0x40; }
_ZN13sentencepiece11string_util16IsValidCodepointEj:
  114|   143M|inline bool IsValidCodepoint(char32 c) {
  115|   143M|  return (static_cast<uint32_t>(c) < 0xD800) || (c >= 0xE000 && c <= 0x10FFFF);
  ------------------
  |  Branch (115:10): [True: 67.7M, False: 76.1M]
  |  Branch (115:50): [True: 76.1M, False: 2.30k]
  |  Branch (115:65): [True: 76.1M, False: 5.71k]
  ------------------
  116|   143M|}
_ZN13sentencepiece11string_util10DecodeUTF8ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPm:
  124|  9.62M|inline char32 DecodeUTF8(absl::string_view input, size_t *mblen) {
  125|  9.62M|  return DecodeUTF8(input.data(), input.data() + input.size(), mblen);
  126|  9.62M|}
_ZN13sentencepiece11string_util17IsValidDecodeUTF8ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPm:
  128|  9.62M|inline bool IsValidDecodeUTF8(absl::string_view input, size_t *mblen) {
  129|  9.62M|  const char32 c = DecodeUTF8(input, mblen);
  130|  9.62M|  return c != kUnicodeError || *mblen == 3;
  ------------------
  |  Branch (130:10): [True: 7.28M, False: 2.33M]
  |  Branch (130:32): [True: 0, False: 2.33M]
  ------------------
  131|  9.62M|}
_ZN13sentencepiece4util13InternalErrorENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  276|      6|  inline util::Status FUNC##Error(absl::string_view str) { \
  277|      6|    return util::Status(StatusCode::k##FUNC, str.data());  \
  278|      6|  }                                                        \
_ZN13sentencepiece4util13StatusBuilderlsIA26_cEERS1_RKT_:
  308|     30|  StatusBuilder &operator<<(const T &value) {
  309|     30|    os_ << value;
  310|     30|    return *this;
  311|     30|  }
_ZN13sentencepiece4util13StatusBuilderlsIA5_cEERS1_RKT_:
  308|     91|  StatusBuilder &operator<<(const T &value) {
  309|     91|    os_ << value;
  310|     91|    return *this;
  311|     91|  }
_ZN13sentencepiece4util13StatusBuilderlsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERS1_RKT_:
  308|  5.08k|  StatusBuilder &operator<<(const T &value) {
  309|  5.08k|    os_ << value;
  310|  5.08k|    return *this;
  311|  5.08k|  }
_ZN13sentencepiece4util13StatusBuilderlsIA84_cEERS1_RKT_:
  308|      7|  StatusBuilder &operator<<(const T &value) {
  309|      7|    os_ << value;
  310|      7|    return *this;
  311|      7|  }
_ZN13sentencepiece6random16ReservoirSamplerINSt3__14pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEEEC2EPNS2_6vectorISA_NS7_ISA_EEEEmm:
  208|  1.46k|      : sampled_(sampled), size_(size), gen_(std::seed_seq{seed}) {}
_ZN13sentencepiece6random16ReservoirSamplerINSt3__14pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEEED2Ev:
  209|  1.46k|  virtual ~ReservoirSampler() {}
_ZN13sentencepiece6random16ReservoirSamplerINSt3__14pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEEE3AddERKSA_:
  211|  10.5k|  void Add(const T &item) {
  212|  10.5k|    if (size_ == 0) return;
  ------------------
  |  Branch (212:9): [True: 0, False: 10.5k]
  ------------------
  213|       |
  214|  10.5k|    ++total_;
  215|  10.5k|    if (sampled_->size() < size_) {
  ------------------
  |  Branch (215:9): [True: 10.5k, False: 0]
  ------------------
  216|  10.5k|      sampled_->push_back(item);
  217|  10.5k|    } else {
  218|      0|      const auto n = absl::Uniform<uint64_t>(gen_, 0, total_ - 1);
  219|      0|      if (n < sampled_->size()) (*sampled_)[n] = item;
  ------------------
  |  Branch (219:11): [True: 0, False: 0]
  ------------------
  220|      0|    }
  221|  10.5k|  }
_ZNK13sentencepiece6random16ReservoirSamplerINSt3__14pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEEE10total_sizeEv:
  223|  22.4k|  uint64_t total_size() const { return total_; }
_ZN13sentencepiece4util13StatusBuilderlsIA25_cEERS1_RKT_:
  308|  5.20k|  StatusBuilder &operator<<(const T &value) {
  309|  5.20k|    os_ << value;
  310|  5.20k|    return *this;
  311|  5.20k|  }
_ZN13sentencepiece4util13StatusBuilderlsIA61_cEERS1_RKT_:
  308|  5.08k|  StatusBuilder &operator<<(const T &value) {
  309|  5.08k|    os_ << value;
  310|  5.08k|    return *this;
  311|  5.08k|  }
_ZN13sentencepiece6random16ReservoirSamplerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPNS2_6vectorIS8_NS6_IS8_EEEEm:
  205|  10.1k|      : sampled_(sampled), size_(size) {}
_ZN13sentencepiece6random16ReservoirSamplerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEED2Ev:
  209|  10.1k|  virtual ~ReservoirSampler() {}
_ZN13sentencepiece6random16ReservoirSamplerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE3AddERKS8_:
  211|  65.5k|  void Add(const T &item) {
  212|  65.5k|    if (size_ == 0) return;
  ------------------
  |  Branch (212:9): [True: 65.5k, False: 0]
  ------------------
  213|       |
  214|      0|    ++total_;
  215|      0|    if (sampled_->size() < size_) {
  ------------------
  |  Branch (215:9): [True: 0, False: 0]
  ------------------
  216|      0|      sampled_->push_back(item);
  217|      0|    } else {
  218|      0|      const auto n = absl::Uniform<uint64_t>(gen_, 0, total_ - 1);
  219|      0|      if (n < sampled_->size()) (*sampled_)[n] = item;
  ------------------
  |  Branch (219:11): [True: 0, False: 0]
  ------------------
  220|      0|    }
  221|      0|  }
_ZN13sentencepiece4util13StatusBuilderlsIA20_cEERS1_RKT_:
  308|     46|  StatusBuilder &operator<<(const T &value) {
  309|     46|    os_ << value;
  310|     46|    return *this;
  311|     46|  }
_ZN13sentencepiece4util13StatusBuilderlsIA49_cEERS1_RKT_:
  308|     91|  StatusBuilder &operator<<(const T &value) {
  309|     91|    os_ << value;
  310|     91|    return *this;
  311|     91|  }
_ZN13sentencepiece4port11ContainsKeyIN4absl12lts_2026010713flat_hash_mapIjlNS3_13hash_internal4HashIjEENSt3__18equal_toIjEENS8_9allocatorINS8_4pairIKjlEEEEEEjEEbRKT_RKT0_:
  147|  9.63M|bool ContainsKey(const Collection &collection, const Key &key) {
  148|  9.63M|  return collection.find(key) != collection.end();
  149|  9.63M|}
_ZN13sentencepiece4util13StatusBuilderlsIA97_cEERS1_RKT_:
  308|     91|  StatusBuilder &operator<<(const T &value) {
  309|     91|    os_ << value;
  310|     91|    return *this;
  311|     91|  }
_ZN13sentencepiece4util13StatusBuilderlsImEERS1_RKT_:
  308|     91|  StatusBuilder &operator<<(const T &value) {
  309|     91|    os_ << value;
  310|     91|    return *this;
  311|     91|  }
_ZN13sentencepiece4util13StatusBuilderlsIA57_cEERS1_RKT_:
  308|     91|  StatusBuilder &operator<<(const T &value) {
  309|     91|    os_ << value;
  310|     91|    return *this;
  311|     91|  }
_ZN13sentencepiece4port11ContainsKeyIN4absl12lts_2026010713flat_hash_mapINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEElNS3_18container_internal10StringHashENSC_8StringEqENS9_INS5_4pairIKSB_lEEEEEESB_EEbRKT_RKT0_:
  147|  1.76M|bool ContainsKey(const Collection &collection, const Key &key) {
  148|  1.76M|  return collection.find(key) != collection.end();
  149|  1.76M|}
_ZN13sentencepiece4port11ContainsKeyIN4absl12lts_2026010713flat_hash_mapINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEfNS3_18container_internal10StringHashENSC_8StringEqENS9_INS5_4pairIKSB_fEEEEEESB_EEbRKT_RKT0_:
  147|   346k|bool ContainsKey(const Collection &collection, const Key &key) {
  148|   346k|  return collection.find(key) != collection.end();
  149|   346k|}
_ZN13sentencepiece4port15FindWithDefaultIN4absl12lts_2026010713flat_hash_mapIjlNS3_13hash_internal4HashIjEENSt3__18equal_toIjEENS8_9allocatorINS8_4pairIKjlEEEEEEEERKNT_10value_type11second_typeERKSH_RKNSI_10first_typeESL_:
  166|  1.38M|    const typename Collection::value_type::second_type &value) {
  167|  1.38M|  if (const auto it = collection.find(key); it != collection.end()) {
  ------------------
  |  Branch (167:45): [True: 1.32M, False: 64.1k]
  ------------------
  168|  1.32M|    return it->second;
  169|  1.32M|  }
  170|  64.1k|  return value;
  171|  1.38M|}
_ZN13sentencepiece4port11InsertOrDieIN4absl12lts_2026010713flat_hash_mapImPNS_3bpe7Trainer6SymbolENS3_13hash_internal4HashImEENSt3__18equal_toImEENSC_9allocatorINSC_4pairIKmS8_EEEEEEEEvPT_RKNSL_10value_type10first_typeERKNSN_11second_typeE:
  191|   359k|                 const typename Collection::value_type::second_type &data) {
  192|   719k|  CHECK(InsertIfNotPresent(collection, key, data)) << "duplicate key";
  ------------------
  |  |   58|   359k|#define CHECK(condition) ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  180|   359k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|   719k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|   719k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 359k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|   359k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 359k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|   719k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 359k, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 359k]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 359k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |   29|   359k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   84|   359k|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  193|   359k|}
_ZN13sentencepiece4port18InsertIfNotPresentIN4absl12lts_2026010713flat_hash_mapImPNS_3bpe7Trainer6SymbolENS3_13hash_internal4HashImEENSt3__18equal_toImEENSC_9allocatorINSC_4pairIKmS8_EEEEEEEEbPT_RKNSL_10value_type10first_typeERKNSN_11second_typeE:
  183|   359k|    const typename Collection::value_type::second_type &value) {
  184|   359k|  return InsertIfNotPresent(collection,
  185|   359k|                            typename Collection::value_type(key, value));
  186|   359k|}
_ZN13sentencepiece4port18InsertIfNotPresentIN4absl12lts_2026010713flat_hash_mapImPNS_3bpe7Trainer6SymbolENS3_13hash_internal4HashImEENSt3__18equal_toImEENSC_9allocatorINSC_4pairIKmS8_EEEEEEEEbPT_RKNSL_10value_typeE:
  175|   359k|                        const typename Collection::value_type &vt) {
  176|   359k|  return collection->insert(vt).second;
  177|   359k|}
_ZN13sentencepiece4port17STLDeleteElementsINS_3bpe7Trainer6SymbolEEEvPNSt3__16vectorIPT_NS5_9allocatorIS8_EEEE:
  345|  1.79k|void STLDeleteElements(std::vector<T *> *vec) {
  346|   359k|  for (auto item : *vec) {
  ------------------
  |  Branch (346:18): [True: 359k, False: 1.79k]
  ------------------
  347|   359k|    delete item;
  348|   359k|  }
  349|  1.79k|  vec->clear();
  350|  1.79k|}
_ZN13sentencepiece4port15FindWithDefaultIN4absl12lts_2026010713flat_hash_mapIjNS_14unicode_script10ScriptTypeENS3_13hash_internal4HashIjEENSt3__18equal_toIjEENSA_9allocatorINSA_4pairIKjS6_EEEEEEEERKNT_10value_type11second_typeERKSJ_RKNSK_10first_typeESN_:
  166|  32.6M|    const typename Collection::value_type::second_type &value) {
  167|  32.6M|  if (const auto it = collection.find(key); it != collection.end()) {
  ------------------
  |  Branch (167:45): [True: 31.2M, False: 1.40M]
  ------------------
  168|  31.2M|    return it->second;
  169|  31.2M|  }
  170|  1.40M|  return value;
  171|  32.6M|}
_ZN13sentencepiece11string_util9DecodePODIjEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_:
   70|  20.2k|inline bool DecodePOD(absl::string_view str, T *result) {
   71|  20.2k|  static_assert(std::is_trivially_copyable<T>::value,
   72|  20.2k|                "T must be trivially copyable");
   73|  20.2k|  if (sizeof(*result) != str.size()) {
  ------------------
  |  Branch (73:7): [True: 0, False: 20.2k]
  ------------------
   74|      0|    return false;
   75|      0|  }
   76|  20.2k|  std::memcpy(result, str.data(), sizeof(T));
   77|  20.2k|  return true;
   78|  20.2k|}

_ZN13sentencepiece4word7Trainer5TrainEv:
   28|  1.17k|util::Status Trainer::Train() {
   29|  1.17k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  1.17k|  do {                                 \
  |  |   45|  1.17k|    const auto _status = expr;         \
  |  |   46|  1.17k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 2, False: 1.17k]
  |  |  ------------------
  |  |   47|  1.17k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 1.17k]
  |  |  ------------------
  ------------------
   30|       |
   31|  1.17k|  RET_CHECK(normalizer_spec_.escape_whitespaces());
  ------------------
  |  |  321|  1.17k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 1.17k, False: 0]
  |  |  ------------------
  |  |  322|  1.17k|  } else /* NOLINT */                                        \
  |  |  323|  1.17k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   32|  1.17k|  RET_CHECK_EQ(TrainerSpec::WORD, trainer_spec_.model_type());
  ------------------
  |  |  327|  1.17k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  321|  1.17k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 1.17k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  322|  1.17k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  1.17k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   33|       |
   34|  1.17k|  RETURN_IF_ERROR(LoadSentences());
  ------------------
  |  |   44|  1.17k|  do {                                 \
  |  |   45|  1.17k|    const auto _status = expr;         \
  |  |   46|  1.17k|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 3, False: 1.16k]
  |  |  ------------------
  |  |   47|  1.17k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 1.16k]
  |  |  ------------------
  ------------------
   35|       |
   36|  1.16k|  absl::flat_hash_map<std::string, uint64_t> freq;
   37|  9.89k|  for (const auto &it : sentences_) {
  ------------------
  |  Branch (37:23): [True: 9.89k, False: 1.16k]
  ------------------
   38|   164k|    for (const auto &s : SplitIntoWords(it.first)) {
  ------------------
  |  Branch (38:24): [True: 164k, False: 9.89k]
  ------------------
   39|   164k|      freq[s] += it.second;
   40|   164k|    }
   41|  9.89k|  }
   42|       |
   43|  1.16k|  const int vocab_size = trainer_spec_.vocab_size() - meta_pieces_.size();
   44|  1.16k|  RET_CHECK_GE(vocab_size, 0);
  ------------------
  |  |  329|  1.16k|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  321|  1.16k|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (321:7): [True: 1.14k, False: 18]
  |  |  |  |  ------------------
  |  |  |  |  322|  1.14k|  } else /* NOLINT */                                        \
  |  |  |  |  323|  1.16k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  324|     18|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  325|     18|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   45|       |
   46|  1.14k|  uint64_t sum = 0;
   47|   102k|  for (const auto &it : freq) {
  ------------------
  |  Branch (47:23): [True: 102k, False: 1.14k]
  ------------------
   48|   102k|    sum += it.second;
   49|   102k|  }
   50|       |
   51|  1.14k|  const auto logsum = std::log(static_cast<float>(sum));
   52|       |
   53|  1.14k|  RET_CHECK(final_pieces_.empty());
  ------------------
  |  |  321|  1.14k|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 1.14k, False: 0]
  |  |  ------------------
  |  |  322|  1.14k|  } else /* NOLINT */                                        \
  |  |  323|  1.14k|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   54|  39.0k|  for (const auto &it : Sorted(freq)) {
  ------------------
  |  Branch (54:23): [True: 39.0k, False: 787]
  ------------------
   55|  39.0k|    if (it.first.find(kUNKStr) != std::string::npos) {
  ------------------
  |  Branch (55:9): [True: 9.07k, False: 29.9k]
  ------------------
   56|  9.07k|      continue;
   57|  9.07k|    }
   58|  29.9k|    if (!trainer_spec_.use_all_vocab() &&
  ------------------
  |  Branch (58:9): [True: 29.9k, False: 0]
  ------------------
   59|  29.9k|        final_pieces_.size() == static_cast<size_t>(vocab_size)) {
  ------------------
  |  Branch (59:9): [True: 362, False: 29.6k]
  ------------------
   60|    362|      break;
   61|    362|    }
   62|  29.6k|    final_pieces_.emplace_back(
   63|  29.6k|        it.first, std::log(static_cast<float>(it.second)) - logsum);
   64|  29.6k|  }
   65|       |
   66|  1.14k|  if (trainer_spec_.use_all_vocab()) {
  ------------------
  |  Branch (66:7): [True: 0, False: 1.14k]
  ------------------
   67|      0|    trainer_spec_.set_vocab_size(final_pieces_.size() + meta_pieces_.size());
   68|      0|  }
   69|       |
   70|  1.14k|  return Save();
   71|  1.14k|}

_ZN13sentencepiece4word7TrainerC2ERKNS_11TrainerSpecERKNS_14NormalizerSpecES7_:
   34|  1.17k|      : TrainerInterface::TrainerInterface(trainer_spec, normalizer_spec,
   35|  1.17k|                                           denormalizer_spec) {}

_ZN4absl12lts_2026010713base_internal16SchedulingHelperC2ENS1_14SchedulingModeE:
  118|      7|  explicit SchedulingHelper(base_internal::SchedulingMode mode) : mode_(mode) {
  119|      7|    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
  ------------------
  |  Branch (119:9): [True: 4, False: 3]
  ------------------
  120|      4|      guard_result_ = base_internal::SchedulingGuard::DisableRescheduling();
  121|      4|    }
  122|      7|  }
_ZN4absl12lts_2026010713base_internal16SchedulingHelperD2Ev:
  124|      7|  ~SchedulingHelper() {
  125|      7|    if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
  ------------------
  |  Branch (125:9): [True: 4, False: 3]
  ------------------
  126|      4|      base_internal::SchedulingGuard::EnableRescheduling(guard_result_);
  127|      4|    }
  128|      7|  }
_ZN4absl12lts_2026010713base_internal11ControlWordEPNS0_9once_flagE:
  194|   650k|    once_flag* absl_nonnull flag) {
  195|   650k|  return &flag->control_;
  196|   650k|}
_ZN4absl12lts_202601079call_onceIRFvvEJEEEvRNS0_9once_flagEOT_DpOT0_:
  214|  10.1k|    call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  215|  10.1k|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  216|  10.1k|  uint32_t s = once->load(std::memory_order_acquire);
  217|  10.1k|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  189|  10.1k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 10.1k]
  |  |  |  Branch (189:49): [Folded, False: 10.1k]
  |  |  |  Branch (189:58): [True: 1, False: 10.1k]
  |  |  ------------------
  ------------------
  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|  10.1k|}
_ZN4absl12lts_2026010713base_internal12CallOnceImplIRFvvEJEEEvPNSt3__16atomicIjEENS1_14SchedulingModeEOT_DpOT0_:
  155|      2|                 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|      2|  static const base_internal::SpinLockWaitTransition trans[] = {
  169|      2|      {kOnceInit, kOnceRunning, true},
  170|      2|      {kOnceRunning, kOnceWaiter, false},
  171|      2|      {kOnceDone, kOnceDone, true}};
  172|       |
  173|       |  // Must do this before potentially modifying control word's state.
  174|      2|  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|      2|  uint32_t old_control = kOnceInit;
  180|      2|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (180:7): [True: 2, False: 0]
  ------------------
  181|      2|                                       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|      2|                                  scheduling_mode) == kOnceInit) {
  184|      2|    std::invoke(std::forward<Callable>(fn), std::forward<Args>(args)...);
  185|      2|    old_control =
  186|      2|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  187|      2|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (187:9): [True: 0, False: 2]
  ------------------
  188|      0|      base_internal::SpinLockWake(control, true);
  189|      0|    }
  190|      2|  }  // else *control is already kOnceDone
  191|      2|}
mutex.cc:_ZN4absl12lts_2026010713base_internal16LowLevelCallOnceIZNS0_12_GLOBAL__N_115GetMutexGlobalsEvE3$_0JEEEvPNS0_9once_flagEOT_DpOT0_:
  200|  20.8k|                      Args&&... args) {
  201|  20.8k|  std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
  202|  20.8k|  uint32_t s = once->load(std::memory_order_acquire);
  203|  20.8k|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  189|  20.8k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 20.8k]
  |  |  |  Branch (189:49): [Folded, False: 20.8k]
  |  |  |  Branch (189:58): [True: 1, False: 20.8k]
  |  |  ------------------
  ------------------
  204|      1|    base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
  205|      1|                                std::forward<Callable>(fn),
  206|      1|                                std::forward<Args>(args)...);
  207|      1|  }
  208|  20.8k|}
mutex.cc:_ZN4absl12lts_2026010713base_internal12CallOnceImplIZNS0_12_GLOBAL__N_115GetMutexGlobalsEvE3$_0JEEEvPNSt3__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|}
sysinfo.cc:_ZN4absl12lts_2026010713base_internal16LowLevelCallOnceIZNS1_7NumCPUsEvE3$_0JEEEvPNS0_9once_flagEOT_DpOT0_:
  200|      2|                      Args&&... args) {
  201|      2|  std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
  202|      2|  uint32_t s = once->load(std::memory_order_acquire);
  203|      2|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  189|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 1]
  |  |  |  Branch (189:49): [Folded, False: 2]
  |  |  |  Branch (189:58): [True: 1, False: 1]
  |  |  ------------------
  ------------------
  204|      1|    base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
  205|      1|                                std::forward<Callable>(fn),
  206|      1|                                std::forward<Args>(args)...);
  207|      1|  }
  208|      2|}
sysinfo.cc:_ZN4absl12lts_2026010713base_internal12CallOnceImplIZNS1_7NumCPUsEvE3$_0JEEEvPNSt3__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|}
sysinfo.cc:_ZN4absl12lts_2026010713base_internal16LowLevelCallOnceIZNS1_19NominalCPUFrequencyEvE3$_0JEEEvPNS0_9once_flagEOT_DpOT0_:
  200|     18|                      Args&&... args) {
  201|     18|  std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
  202|     18|  uint32_t s = once->load(std::memory_order_acquire);
  203|     18|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  189|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 17]
  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  Branch (189:58): [True: 1, False: 17]
  |  |  ------------------
  ------------------
  204|      1|    base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
  205|      1|                                std::forward<Callable>(fn),
  206|      1|                                std::forward<Args>(args)...);
  207|      1|  }
  208|     18|}
sysinfo.cc:_ZN4absl12lts_2026010713base_internal12CallOnceImplIZNS1_19NominalCPUFrequencyEvE3$_0JEEEvPNSt3__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_202601079call_onceIRFvPFvPvEEJRS4_EEEvRNS0_9once_flagEOT_DpOT0_:
  214|     20|    call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  215|     20|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  216|     20|  uint32_t s = once->load(std::memory_order_acquire);
  217|     20|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  189|     20|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 19]
  |  |  |  Branch (189:49): [Folded, False: 20]
  |  |  |  Branch (189:58): [True: 1, False: 19]
  |  |  ------------------
  ------------------
  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|     20|}
_ZN4absl12lts_2026010713base_internal12CallOnceImplIRFvPFvPvEEJRS5_EEEvPNSt3__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_2026010713base_internal16LowLevelCallOnceIRFvvEJEEEvPNS0_9once_flagEOT_DpOT0_:
  200|      2|                      Args&&... args) {
  201|      2|  std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
  202|      2|  uint32_t s = once->load(std::memory_order_acquire);
  203|      2|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  189|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 1]
  |  |  |  Branch (189:49): [Folded, False: 2]
  |  |  |  Branch (189:58): [True: 1, False: 1]
  |  |  ------------------
  ------------------
  204|      1|    base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
  205|      1|                                std::forward<Callable>(fn),
  206|      1|                                std::forward<Args>(args)...);
  207|      1|  }
  208|      2|}
log_sink_set.cc:_ZN4absl12lts_202601079call_onceIZNS0_12log_internal12_GLOBAL__N_113StderrLogSink4SendERKNS0_8LogEntryEEUlvE_JEEEvRNS0_9once_flagEOT_DpOT0_:
  214|   619k|    call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  215|   619k|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  216|   619k|  uint32_t s = once->load(std::memory_order_acquire);
  217|   619k|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  189|   619k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 619k]
  |  |  |  Branch (189:49): [Folded, False: 619k]
  |  |  |  Branch (189:58): [True: 1, False: 619k]
  |  |  ------------------
  ------------------
  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|   619k|}
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_202601078bit_castIdmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  183|  2.54k|inline constexpr Dest bit_cast(const Source& source) {
  184|  2.54k|  return __builtin_bit_cast(Dest, source);
  185|  2.54k|}
_ZN4absl12lts_202601078bit_castIlmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  183|     39|inline constexpr Dest bit_cast(const Source& source) {
  184|     39|  return __builtin_bit_cast(Dest, source);
  185|     39|}

_Z49AbslInternalAnnotateIgnoreReadsBegin_lts_20260107v:
  328|     36|    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE {}
_Z47AbslInternalAnnotateIgnoreReadsEnd_lts_20260107v:
  332|     36|    ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE {}

_ZN4absl12lts_2026010713base_internal10CycleClock9FrequencyEv:
  134|     18|inline double CycleClock::Frequency() {
  135|     18|  return kFrequencyScale * base_internal::UnscaledCycleClock::Frequency();
  136|     18|}
_ZN4absl12lts_2026010713base_internal10CycleClock3NowEv:
  125|     59|inline int64_t CycleClock::Now() {
  126|     59|  auto fn = LoadCycleClockSource();
  127|     59|  if (fn == nullptr) {
  ------------------
  |  Branch (127:7): [True: 59, False: 0]
  ------------------
  128|     59|    return base_internal::UnscaledCycleClock::Now() >> kShift;
  129|     59|  }
  130|      0|  return fn() >> kShift;
  131|     59|}
_ZN4absl12lts_2026010713base_internal10CycleClock20LoadCycleClockSourceEv:
  107|     59|inline CycleClockSourceFunc CycleClock::LoadCycleClockSource() {
  108|       |#if !defined(__x86_64__)
  109|       |  // Optimize for the common case (no callback) by first doing a relaxed load;
  110|       |  // this is significantly faster on non-x86 platforms.
  111|       |  if (cycle_clock_source_.load(std::memory_order_relaxed) == nullptr) {
  112|       |    return nullptr;
  113|       |  }
  114|       |#endif  // !defined(__x86_64__)
  115|       |
  116|       |  // This corresponds to the store(std::memory_order_release) in
  117|       |  // CycleClockSource::Register, and makes sure that any updates made prior to
  118|       |  // registering the callback are visible to this thread before the callback
  119|       |  // is invoked.
  120|     59|  return cycle_clock_source_.load(std::memory_order_acquire);
  121|     59|}

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

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

_ZN4absl12lts_2026010713base_internal13LowLevelAlloc12DefaultArenaEv:
  299|      2|LowLevelAlloc::Arena *LowLevelAlloc::DefaultArena() {
  300|      2|  base_internal::LowLevelCallOnce(&create_globals_once, CreateGlobalArenas);
  301|      2|  return reinterpret_cast<LowLevelAlloc::Arena *>(&default_arena_storage);
  302|      2|}
_ZN4absl12lts_2026010713base_internal13LowLevelAlloc5ArenaC2Ej:
  380|      3|    : mu(base_internal::SCHEDULE_KERNEL_ONLY),
  381|      3|      allocation_count(0),
  382|      3|      flags(flags_value),
  383|      3|      pagesize(GetPageSize()),
  384|      3|      round_up(RoundedUpBlockSize()),
  385|      3|      min_size(2 * round_up),
  386|      3|      random(0) {
  387|      3|  freelist.header.size = 0;
  388|      3|  freelist.header.magic = Magic(kMagicUnallocated, &freelist.header);
  389|      3|  freelist.header.arena = this;
  390|      3|  freelist.levels = 0;
  391|      3|  memset(freelist.next, 0, sizeof(freelist.next));
  392|      3|}
_ZN4absl12lts_2026010713base_internal13LowLevelAlloc5AllocEm:
  646|      2|void *LowLevelAlloc::Alloc(size_t request) {
  647|      2|  void *result = DoAllocWithArena(request, DefaultArena());
  648|      2|  return result;
  649|      2|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internal12_GLOBAL__N_118CreateGlobalArenasEv:
  269|      1|void CreateGlobalArenas() {
  270|      1|  new (&default_arena_storage)
  271|      1|      LowLevelAlloc::Arena(LowLevelAlloc::kCallMallocHook);
  272|      1|  new (&unhooked_arena_storage) LowLevelAlloc::Arena(0);
  273|      1|#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
  274|      1|  new (&unhooked_async_sig_safe_arena_storage)
  275|      1|      LowLevelAlloc::Arena(LowLevelAlloc::kAsyncSignalSafe);
  276|      1|#endif
  277|      1|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internal12_GLOBAL__N_111GetPageSizeEv:
  356|      3|size_t GetPageSize() {
  357|       |#ifdef _WIN32
  358|       |  SYSTEM_INFO system_info;
  359|       |  GetSystemInfo(&system_info);
  360|       |  return std::max(system_info.dwPageSize, system_info.dwAllocationGranularity);
  361|       |#elif defined(__wasm__) || defined(__asmjs__) || defined(__hexagon__)
  362|       |  return static_cast<size_t>(getpagesize());
  363|       |#else
  364|       |  return static_cast<size_t>(sysconf(_SC_PAGESIZE));
  365|      3|#endif
  366|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internal12_GLOBAL__N_118RoundedUpBlockSizeEv:
  368|      3|size_t RoundedUpBlockSize() {
  369|       |  // Round up block sizes to a power of two close to the header size.
  370|      3|  size_t round_up = 16;
  371|      6|  while (round_up < sizeof(AllocList::Header)) {
  ------------------
  |  Branch (371:10): [True: 3, False: 3]
  ------------------
  372|      3|    round_up += round_up;
  373|      3|  }
  374|      3|  return round_up;
  375|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL5MagicEmPNS1_12_GLOBAL__N_19AllocList6HeaderE:
  351|     16|inline static uintptr_t Magic(uintptr_t magic, AllocList::Header *ptr) {
  352|     16|  return magic ^ reinterpret_cast<uintptr_t>(ptr);
  353|     16|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internal12_GLOBAL__N_19ArenaLockC2EPNS1_13LowLevelAlloc5ArenaE:
  313|      2|      : arena_(arena) {
  314|      2|#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
  315|      2|    if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
  ------------------
  |  Branch (315:9): [True: 0, False: 2]
  ------------------
  316|      0|      sigset_t all;
  317|      0|      sigfillset(&all);
  318|       |      mask_valid_ = pthread_sigmask(SIG_BLOCK, &all, &mask_) == 0;
  319|      0|    }
  320|      2|#endif
  321|      2|    arena_->mu.lock();
  322|      2|  }
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internal12_GLOBAL__N_19ArenaLock5LeaveEv:
  324|      2|  void Leave() ABSL_UNLOCK_FUNCTION() {
  325|      2|    arena_->mu.unlock();
  326|      2|#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
  327|      2|    if (mask_valid_) {
  ------------------
  |  Branch (327:9): [True: 0, False: 2]
  ------------------
  328|      0|      const int err = pthread_sigmask(SIG_SETMASK, &mask_, nullptr);
  329|      0|      if (err != 0) {
  ------------------
  |  Branch (329:11): [True: 0, False: 0]
  ------------------
  330|      0|        ABSL_RAW_LOG(FATAL, "pthread_sigmask failed: %d", err);
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  331|      0|      }
  332|      0|    }
  333|      2|#endif
  334|      2|    left_ = true;
  335|      2|  }
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internal12_GLOBAL__N_19ArenaLockD2Ev:
  323|      2|  ~ArenaLock() { ABSL_RAW_CHECK(left_, "haven't left Arena region"); }
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (189:49): [Folded, False: 2]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL13AddToFreelistEPvPNS1_13LowLevelAlloc5ArenaE:
  520|      3|    ABSL_EXCLUSIVE_LOCKS_REQUIRED(arena->mu) {
  521|      3|  AllocList *f = reinterpret_cast<AllocList *>(reinterpret_cast<char *>(v) -
  522|      3|                                               sizeof(f->header));
  523|      3|  ABSL_RAW_CHECK(f->header.magic == Magic(kMagicAllocated, &f->header),
  ------------------
  |  |   60|      3|  do {                                                                 \
  |  |   61|      3|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|      3|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 3]
  |  |  |  |  |  Branch (189:49): [Folded, False: 3]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      3|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 3]
  |  |  ------------------
  ------------------
  524|      3|                 "bad magic number in AddToFreelist()");
  525|      3|  ABSL_RAW_CHECK(f->header.arena == arena,
  ------------------
  |  |   60|      3|  do {                                                                 \
  |  |   61|      3|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|      3|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 3]
  |  |  |  |  |  Branch (189:49): [Folded, False: 3]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      3|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 3]
  |  |  ------------------
  ------------------
  526|      3|                 "bad arena pointer in AddToFreelist()");
  527|      3|  f->levels =
  528|      3|      LLA_SkiplistLevels(f->header.size, arena->min_size, &arena->random);
  529|      3|  AllocList *prev[kMaxLevel];
  530|      3|  LLA_SkiplistInsert(&arena->freelist, f, prev);
  531|      3|  f->header.magic = Magic(kMagicUnallocated, &f->header);
  532|      3|  Coalesce(f);        // maybe coalesce with successor
  533|      3|  Coalesce(prev[0]);  // maybe coalesce with predecessor
  534|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL18LLA_SkiplistLevelsEmmPj:
  143|      6|static int LLA_SkiplistLevels(size_t size, size_t base, uint32_t *random) {
  144|       |  // max_fit is the maximum number of levels that will fit in a node for the
  145|       |  // given size.   We can't return more than max_fit, no matter what the
  146|       |  // random number generator says.
  147|      6|  size_t max_fit = (size - offsetof(AllocList, next)) / sizeof(AllocList *);
  148|      6|  int level = IntLog2(size, base) + (random != nullptr ? Random(random) : 1);
  ------------------
  |  Branch (148:38): [True: 3, False: 3]
  ------------------
  149|      6|  if (static_cast<size_t>(level) > max_fit) level = static_cast<int>(max_fit);
  ------------------
  |  Branch (149:7): [True: 0, False: 6]
  ------------------
  150|      6|  if (level > kMaxLevel - 1) level = kMaxLevel - 1;
  ------------------
  |  Branch (150:7): [True: 0, False: 6]
  ------------------
  151|      6|  ABSL_RAW_CHECK(level >= 1, "block not big enough for even one level");
  ------------------
  |  |   60|      6|  do {                                                                 \
  |  |   61|      6|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|      6|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 6]
  |  |  |  |  |  Branch (189:49): [Folded, False: 6]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 6]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      6|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 6]
  |  |  ------------------
  ------------------
  152|      6|  return level;
  153|      6|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL7IntLog2Emm:
  113|      6|static int IntLog2(size_t size, size_t base) {
  114|      6|  int result = 0;
  115|     48|  for (size_t i = size; i > base; i >>= 1) {  // i == floor(size/2**result)
  ------------------
  |  Branch (115:25): [True: 42, False: 6]
  ------------------
  116|     42|    result++;
  117|     42|  }
  118|       |  //    floor(size / 2**result) <= base < floor(size / 2**(result-1))
  119|       |  // =>     log2(size/(base+1)) <= result < 1+log2(size/base)
  120|       |  // => result ~= log2(size/base)
  121|      6|  return result;
  122|      6|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL6RandomEPj:
  125|      3|static int Random(uint32_t *state) {
  126|      3|  uint32_t r = *state;
  127|      3|  int result = 1;
  128|      6|  while ((((r = r * 1103515245 + 12345) >> 30) & 1) == 0) {
  ------------------
  |  Branch (128:10): [True: 3, False: 3]
  ------------------
  129|      3|    result++;
  130|      3|  }
  131|      3|  *state = r;
  132|      3|  return result;
  133|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL18LLA_SkiplistInsertEPNS1_12_GLOBAL__N_19AllocListES4_PS4_:
  174|      3|                               AllocList **prev) {
  175|      3|  LLA_SkiplistSearch(head, e, prev);
  176|     39|  for (; head->levels < e->levels; head->levels++) {  // extend prev pointers
  ------------------
  |  Branch (176:10): [True: 36, False: 3]
  ------------------
  177|     36|    prev[head->levels] = head;                        // to all *e's levels
  178|     36|  }
  179|     39|  for (int i = 0; i != e->levels; i++) {  // add element to list
  ------------------
  |  Branch (179:19): [True: 36, False: 3]
  ------------------
  180|     36|    e->next[i] = prev[i]->next[i];
  181|     36|    prev[i]->next[i] = e;
  182|     36|  }
  183|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL18LLA_SkiplistSearchEPNS1_12_GLOBAL__N_19AllocListES4_PS4_:
  160|      5|                                     AllocList **prev) {
  161|      5|  AllocList *p = head;
  162|     29|  for (int level = head->levels - 1; level >= 0; level--) {
  ------------------
  |  Branch (162:38): [True: 24, False: 5]
  ------------------
  163|     24|    for (AllocList *n; (n = p->next[level]) != nullptr && n < e; p = n) {
  ------------------
  |  Branch (163:24): [True: 24, False: 0]
  |  Branch (163:59): [True: 0, False: 24]
  ------------------
  164|      0|    }
  165|     24|    prev[level] = p;
  166|     24|  }
  167|      5|  return (head->levels == 0) ? nullptr : prev[0]->next[0];
  ------------------
  |  Branch (167:10): [True: 3, False: 2]
  ------------------
  168|      5|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL8CoalesceEPNS1_12_GLOBAL__N_19AllocListE:
  500|      6|static void Coalesce(AllocList *a) {
  501|      6|  AllocList *n = a->next[0];
  502|      6|  if (n != nullptr && reinterpret_cast<char *>(a) + a->header.size ==
  ------------------
  |  Branch (502:7): [True: 3, False: 3]
  |  Branch (502:23): [True: 0, False: 3]
  ------------------
  503|      3|                          reinterpret_cast<char *>(n)) {
  504|      0|    LowLevelAlloc::Arena *arena = a->header.arena;
  505|      0|    arena->mu.AssertHeld();
  506|      0|    a->header.size += n->header.size;
  507|      0|    n->header.magic = 0;
  508|      0|    n->header.arena = nullptr;
  509|      0|    AllocList *prev[kMaxLevel];
  510|      0|    LLA_SkiplistDelete(&arena->freelist, n, prev);
  511|      0|    LLA_SkiplistDelete(&arena->freelist, a, prev);
  512|      0|    a->levels =
  513|      0|        LLA_SkiplistLevels(a->header.size, arena->min_size, &arena->random);
  514|      0|    LLA_SkiplistInsert(&arena->freelist, a, prev);
  515|      0|  }
  516|      6|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL18LLA_SkiplistDeleteEPNS1_12_GLOBAL__N_19AllocListES4_PS4_:
  189|      2|                               AllocList **prev) {
  190|      2|  AllocList *found = LLA_SkiplistSearch(head, e, prev);
  191|      2|  ABSL_RAW_CHECK(e == found, "element not in freelist");
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (189:49): [Folded, False: 2]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  192|     26|  for (int i = 0; i != e->levels && prev[i]->next[i] == e; i++) {
  ------------------
  |  Branch (192:19): [True: 24, False: 2]
  |  Branch (192:37): [True: 24, False: 0]
  ------------------
  193|     24|    prev[i]->next[i] = e->next[i];
  194|     24|  }
  195|     26|  while (head->levels > 0 && head->next[head->levels - 1] == nullptr) {
  ------------------
  |  Branch (195:10): [True: 24, False: 2]
  |  Branch (195:30): [True: 24, False: 0]
  ------------------
  196|     24|    head->levels--;  // reduce head->levels if level unused
  197|     24|  }
  198|      2|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL16DoAllocWithArenaEmPNS1_13LowLevelAlloc5ArenaE:
  553|      2|static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
  554|      2|  void *result = nullptr;
  555|      2|  if (request != 0) {
  ------------------
  |  Branch (555:7): [True: 2, False: 0]
  ------------------
  556|      2|    AllocList *s;  // will point to region that satisfies request
  557|      2|    ArenaLock section(arena);
  558|       |    // round up with header
  559|      2|    size_t req_rnd =
  560|      2|        RoundUp(CheckedAdd(request, sizeof(s->header)), arena->round_up);
  561|      3|    for (;;) {  // loop until we find a suitable region
  562|       |      // find the minimum levels that a block of this size must have
  563|      3|      int i = LLA_SkiplistLevels(req_rnd, arena->min_size, nullptr) - 1;
  564|      3|      if (i < arena->freelist.levels) {        // potential blocks exist
  ------------------
  |  Branch (564:11): [True: 2, False: 1]
  ------------------
  565|      2|        AllocList *before = &arena->freelist;  // predecessor of s
  566|      2|        while ((s = Next(i, before, arena)) != nullptr &&
  ------------------
  |  Branch (566:16): [True: 2, False: 0]
  ------------------
  567|      2|               s->header.size < req_rnd) {
  ------------------
  |  Branch (567:16): [True: 0, False: 2]
  ------------------
  568|      0|          before = s;
  569|      0|        }
  570|      2|        if (s != nullptr) {  // we found a region
  ------------------
  |  Branch (570:13): [True: 2, False: 0]
  ------------------
  571|      2|          break;
  572|      2|        }
  573|      2|      }
  574|       |      // we unlock before mmap() both because mmap() may call a callback hook,
  575|       |      // and because it may be slow.
  576|      1|      arena->mu.unlock();
  577|       |      // mmap generous 64K chunks to decrease
  578|       |      // the chances/impact of fragmentation:
  579|      1|      size_t new_pages_size = RoundUp(req_rnd, arena->pagesize * 16);
  580|      1|      void *new_pages;
  581|       |#ifdef _WIN32
  582|       |      new_pages = VirtualAlloc(nullptr, new_pages_size,
  583|       |                               MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
  584|       |      ABSL_RAW_CHECK(new_pages != nullptr, "VirtualAlloc failed");
  585|       |#else
  586|      1|#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
  587|      1|      if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
  ------------------
  |  Branch (587:11): [True: 0, False: 1]
  ------------------
  588|      0|        new_pages = base_internal::DirectMmap(nullptr, new_pages_size,
  589|      0|            PROT_WRITE|PROT_READ, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
  590|      1|      } else {
  591|      1|        new_pages = mmap(nullptr, new_pages_size, PROT_WRITE | PROT_READ,
  592|      1|                         MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
  593|      1|      }
  594|       |#else
  595|       |      new_pages = mmap(nullptr, new_pages_size, PROT_WRITE | PROT_READ,
  596|       |                       MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
  597|       |#endif  // ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
  598|      1|      if (new_pages == MAP_FAILED) {
  ------------------
  |  Branch (598:11): [True: 0, False: 1]
  ------------------
  599|      0|        ABSL_RAW_LOG(FATAL, "mmap error: %d", errno);
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  600|      0|      }
  601|       |
  602|      1|#ifdef __linux__
  603|       |#if defined(PR_SET_VMA) && defined(PR_SET_VMA_ANON_NAME)
  604|       |      // Attempt to name the allocated address range in /proc/$PID/smaps on
  605|       |      // Linux.
  606|       |      //
  607|       |      // This invocation of prctl() may fail if the Linux kernel was not
  608|       |      // configured with the CONFIG_ANON_VMA_NAME option.  This is OK since
  609|       |      // the naming of arenas is primarily a debugging aid.
  610|       |      prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, new_pages, new_pages_size,
  611|       |            "absl");
  612|       |#endif
  613|      1|#endif  // __linux__
  614|      1|#endif  // _WIN32
  615|      1|      arena->mu.lock();
  616|      1|      s = reinterpret_cast<AllocList *>(new_pages);
  617|      1|      s->header.size = new_pages_size;
  618|       |      // Pretend the block is allocated; call AddToFreelist() to free it.
  619|      1|      s->header.magic = Magic(kMagicAllocated, &s->header);
  620|      1|      s->header.arena = arena;
  621|      1|      AddToFreelist(&s->levels, arena);  // insert new region into free list
  622|      1|    }
  623|      2|    AllocList *prev[kMaxLevel];
  624|      2|    LLA_SkiplistDelete(&arena->freelist, s, prev);  // remove from free list
  625|       |    // s points to the first free region that's big enough
  626|      2|    if (CheckedAdd(req_rnd, arena->min_size) <= s->header.size) {
  ------------------
  |  Branch (626:9): [True: 2, False: 0]
  ------------------
  627|       |      // big enough to split
  628|      2|      AllocList *n =
  629|      2|          reinterpret_cast<AllocList *>(req_rnd + reinterpret_cast<char *>(s));
  630|      2|      n->header.size = s->header.size - req_rnd;
  631|      2|      n->header.magic = Magic(kMagicAllocated, &n->header);
  632|      2|      n->header.arena = arena;
  633|      2|      s->header.size = req_rnd;
  634|      2|      AddToFreelist(&n->levels, arena);
  635|      2|    }
  636|      2|    s->header.magic = Magic(kMagicAllocated, &s->header);
  637|      2|    ABSL_RAW_CHECK(s->header.arena == arena, "");
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (189:49): [Folded, False: 2]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  638|      2|    arena->allocation_count++;
  639|      2|    section.Leave();
  640|      2|    result = &s->levels;
  641|      2|  }
  642|      2|  ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(result, request);
  643|      2|  return result;
  644|      2|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL7RoundUpEmm:
  472|      3|static inline uintptr_t RoundUp(uintptr_t addr, uintptr_t align) {
  473|      3|  return CheckedAdd(addr, align - 1) & ~(align - 1);
  474|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL10CheckedAddEmm:
  464|      7|static inline uintptr_t CheckedAdd(uintptr_t a, uintptr_t b) {
  465|      7|  uintptr_t sum = a + b;
  466|      7|  ABSL_RAW_CHECK(sum >= a, "LowLevelAlloc arithmetic overflow");
  ------------------
  |  |   60|      7|  do {                                                                 \
  |  |   61|      7|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|      7|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 7]
  |  |  |  |  |  Branch (189:49): [Folded, False: 7]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 7]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      7|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 7]
  |  |  ------------------
  ------------------
  467|      7|  return sum;
  468|      7|}
low_level_alloc.cc:_ZN4absl12lts_2026010713base_internalL4NextEiPNS1_12_GLOBAL__N_19AllocListEPNS1_13LowLevelAlloc5ArenaE:
  481|      2|    ABSL_EXCLUSIVE_LOCKS_REQUIRED(arena->mu) {
  482|      2|  ABSL_RAW_CHECK(i < prev->levels, "too few levels in Next()");
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (189:49): [Folded, False: 2]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  483|      2|  AllocList *next = prev->next[i];
  484|      2|  if (next != nullptr) {
  ------------------
  |  Branch (484:7): [True: 2, False: 0]
  ------------------
  485|      2|    ABSL_RAW_CHECK(
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (189:49): [Folded, False: 2]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  486|      2|        next->header.magic == Magic(kMagicUnallocated, &next->header),
  487|      2|        "bad magic number in Next()");
  488|      2|    ABSL_RAW_CHECK(next->header.arena == arena, "bad arena pointer in Next()");
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (189:49): [Folded, False: 2]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      2|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 2]
  |  |  ------------------
  ------------------
  489|      2|    if (prev != &arena->freelist) {
  ------------------
  |  Branch (489:9): [True: 0, False: 2]
  ------------------
  490|      0|      ABSL_RAW_CHECK(prev < next, "unordered freelist");
  ------------------
  |  |   60|      0|  do {                                                                 \
  |  |   61|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  491|      0|      ABSL_RAW_CHECK(reinterpret_cast<char *>(prev) + prev->header.size <
  ------------------
  |  |   60|      0|  do {                                                                 \
  |  |   61|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  492|      0|                         reinterpret_cast<char *>(next),
  493|      0|                     "malformed freelist");
  494|      0|    }
  495|      2|  }
  496|      2|  return next;
  497|      2|}

_ZN4absl12lts_2026010713base_internal15SchedulingGuard13ScopedDisableC2Ev:
   83|     59|    ScopedDisable() { disabled = SchedulingGuard::DisableRescheduling(); }
_ZN4absl12lts_2026010713base_internal15SchedulingGuard13ScopedDisableD2Ev:
   84|     59|    ~ScopedDisable() { SchedulingGuard::EnableRescheduling(disabled); }
_ZN4absl12lts_2026010713base_internal15SchedulingGuard19DisableReschedulingEv:
  116|    105|inline bool SchedulingGuard::DisableRescheduling() {
  117|    105|  return false;
  118|    105|}
_ZN4absl12lts_2026010713base_internal15SchedulingGuard18EnableReschedulingEb:
  120|     63|inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */) {
  121|     63|  return;
  122|     63|}
_ZN4absl12lts_2026010713base_internal15SchedulingGuard12ScopedEnableC2Ev:
  125|     80|    : scheduling_disabled_depth_(0) {}
_ZN4absl12lts_2026010713base_internal15SchedulingGuard12ScopedEnableD2Ev:
  126|     80|inline SchedulingGuard::ScopedEnable::~ScopedEnable() {
  127|       |  ABSL_RAW_CHECK(scheduling_disabled_depth_ == 0, "disable unused warning");
  ------------------
  |  |   60|     80|  do {                                                                 \
  |  |   61|     80|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     80|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 80]
  |  |  |  |  |  Branch (189:49): [Folded, False: 80]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 80]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     80|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 80]
  |  |  ------------------
  ------------------
  128|     80|}

_ZN4absl12lts_2026010713base_internal8SpinLockC2Ev:
   62|      8|  constexpr SpinLock() : lockword_(kSpinLockCooperative) { RegisterWithTsan(); }
_ZN4absl12lts_2026010713base_internal8SpinLock16RegisterWithTsanEv:
  221|     11|  constexpr void RegisterWithTsan() {
  222|     11|#if ABSL_HAVE_BUILTIN(__builtin_is_constant_evaluated)
  223|     11|    if (!__builtin_is_constant_evaluated()) {
  ------------------
  |  Branch (223:9): [True: 11, Folded]
  ------------------
  224|     11|      ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
  225|     11|    }
  226|     11|#endif
  227|     11|  }
_ZN4absl12lts_2026010713base_internal14SpinLockHolderC2ERNS1_8SpinLockE:
  257|  10.1k|      : std::lock_guard<SpinLock>(l) {}
_ZN4absl12lts_2026010713base_internal8SpinLock4lockEv:
   98|  10.1k|  inline void lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
   99|  10.1k|    ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
  100|  10.1k|    if (!TryLockImpl()) {
  ------------------
  |  Branch (100:9): [True: 0, False: 10.1k]
  ------------------
  101|      0|      SlowLock();
  102|      0|    }
  103|  10.1k|    ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
  104|  10.1k|  }
_ZN4absl12lts_2026010713base_internal8SpinLock11TryLockImplEv:
  238|  10.1k|  inline bool TryLockImpl() {
  239|  10.1k|    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
  240|  10.1k|    return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0;
  241|  10.1k|  }
_ZN4absl12lts_2026010713base_internal8SpinLock15TryLockInternalEjj:
  282|  10.1k|                                          uint32_t wait_cycles) {
  283|  10.1k|  if ((lock_value & kSpinLockHeld) != 0) {
  ------------------
  |  Branch (283:7): [True: 0, False: 10.1k]
  ------------------
  284|      0|    return lock_value;
  285|      0|  }
  286|       |
  287|  10.1k|  uint32_t sched_disabled_bit = 0;
  288|  10.1k|  if ((lock_value & kSpinLockCooperative) == 0) {
  ------------------
  |  Branch (288:7): [True: 42, False: 10.1k]
  ------------------
  289|       |    // For non-cooperative locks we must make sure we mark ourselves as
  290|       |    // non-reschedulable before we attempt to CompareAndSwap.
  291|     42|    if (SchedulingGuard::DisableRescheduling()) {
  ------------------
  |  Branch (291:9): [True: 0, False: 42]
  ------------------
  292|      0|      sched_disabled_bit = kSpinLockDisabledScheduling;
  293|      0|    }
  294|     42|  }
  295|       |
  296|  10.1k|  if (!lockword_.compare_exchange_strong(
  ------------------
  |  Branch (296:7): [True: 0, False: 10.1k]
  ------------------
  297|  10.1k|          lock_value,
  298|  10.1k|          kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
  299|  10.1k|          std::memory_order_acquire, std::memory_order_relaxed)) {
  300|      0|    SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
  301|      0|  }
  302|       |
  303|  10.1k|  return lock_value;
  304|  10.1k|}
_ZN4absl12lts_2026010713base_internal8SpinLock6unlockEv:
  128|  10.1k|  inline void unlock() ABSL_UNLOCK_FUNCTION() {
  129|  10.1k|    ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
  130|  10.1k|    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
  131|  10.1k|    lock_value = lockword_.exchange(lock_value & kSpinLockCooperative,
  132|  10.1k|                                    std::memory_order_release);
  133|       |
  134|  10.1k|    if ((lock_value & kSpinLockDisabledScheduling) != 0) {
  ------------------
  |  Branch (134:9): [True: 0, False: 10.1k]
  ------------------
  135|      0|      SchedulingGuard::EnableRescheduling(true);
  136|      0|    }
  137|  10.1k|    if ((lock_value & kWaitTimeMask) != 0) {
  ------------------
  |  Branch (137:9): [True: 0, False: 10.1k]
  ------------------
  138|       |      // Collect contentionz profile info, and speed the wakeup of any waiter.
  139|       |      // The wait_cycles value indicates how long this thread spent waiting
  140|       |      // for the lock.
  141|      0|      SlowUnlock(lock_value);
  142|      0|    }
  143|  10.1k|    ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
  144|  10.1k|  }
_ZN4absl12lts_2026010713base_internal8SpinLockC2ENS1_14SchedulingModeE:
   67|      3|      : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {
  ------------------
  |  Branch (67:19): [True: 0, False: 3]
  ------------------
   68|      3|    RegisterWithTsan();
   69|      3|  }
_ZN4absl12lts_2026010713base_internal8SpinLock13IsCooperativeENS1_14SchedulingModeE:
  217|      3|  static constexpr bool IsCooperative(SchedulingMode scheduling_mode) {
  218|      3|    return scheduling_mode == SCHEDULE_COOPERATIVE_AND_KERNEL;
  219|      3|  }

_ZN4absl12lts_2026010713base_internal7NumCPUsEv:
  369|      2|int NumCPUs() {
  370|      2|  base_internal::LowLevelCallOnce(
  371|      2|      &init_num_cpus_once, []() { num_cpus = GetNumCPUs(); });
  372|      2|  return num_cpus;
  373|      2|}
_ZN4absl12lts_2026010713base_internal19NominalCPUFrequencyEv:
  381|     18|double NominalCPUFrequency() {
  382|     18|  base_internal::LowLevelCallOnce(
  383|     18|      &init_nominal_cpu_frequency_once,
  384|     18|      []() { nominal_cpu_frequency = GetNominalCPUFrequency(); });
  385|     18|  return nominal_cpu_frequency;
  386|     18|}
_ZN4absl12lts_2026010713base_internal6GetTIDEv:
  400|      1|pid_t GetTID() {
  401|       |  return static_cast<pid_t>(syscall(SYS_gettid));
  402|      1|}
_ZN4absl12lts_2026010713base_internal12GetCachedTIDEv:
  483|   619k|pid_t GetCachedTID() {
  484|   619k|#ifdef ABSL_HAVE_THREAD_LOCAL
  485|   619k|  static thread_local pid_t thread_id = GetTID();
  486|   619k|  return thread_id;
  487|       |#else
  488|       |  return GetTID();
  489|       |#endif  // ABSL_HAVE_THREAD_LOCAL
  490|   619k|}
sysinfo.cc:_ZZN4absl12lts_2026010713base_internal7NumCPUsEvENK3$_0clEv:
  371|      1|      &init_num_cpus_once, []() { num_cpus = GetNumCPUs(); });
sysinfo.cc:_ZN4absl12lts_2026010713base_internalL10GetNumCPUsEv:
  140|      1|static int GetNumCPUs() {
  141|       |#if defined(__myriad2__)
  142|       |  return 1;
  143|       |#elif defined(_WIN32)
  144|       |  const int hardware_concurrency = Win32NumCPUs();
  145|       |  return hardware_concurrency ? hardware_concurrency : 1;
  146|       |#elif defined(_AIX)
  147|       |  return sysconf(_SC_NPROCESSORS_ONLN);
  148|       |#else
  149|       |  // Other possibilities:
  150|       |  //  - Read /sys/devices/system/cpu/online and use cpumask_parse()
  151|       |  //  - sysconf(_SC_NPROCESSORS_ONLN)
  152|      1|  return static_cast<int>(std::thread::hardware_concurrency());
  153|      1|#endif
  154|      1|}
sysinfo.cc:_ZZN4absl12lts_2026010713base_internal19NominalCPUFrequencyEvENK3$_0clEv:
  384|      1|      []() { nominal_cpu_frequency = GetNominalCPUFrequency(); });
sysinfo.cc:_ZN4absl12lts_2026010713base_internalL22GetNominalCPUFrequencyEv:
  321|      1|static double GetNominalCPUFrequency() {
  322|      1|  long freq = 0;
  323|       |
  324|       |  // Google's production kernel has a patch to export the TSC
  325|       |  // frequency through sysfs. If the kernel is exporting the TSC
  326|       |  // frequency use that. There are issues where cpuinfo_max_freq
  327|       |  // cannot be relied on because the BIOS may be exporting an invalid
  328|       |  // p-state (on x86) or p-states may be used to put the processor in
  329|       |  // a new mode (turbo mode). Essentially, those frequencies cannot
  330|       |  // always be relied upon. The same reasons apply to /proc/cpuinfo as
  331|       |  // well.
  332|      1|  if (ReadLongFromFile("/sys/devices/system/cpu/cpu0/tsc_freq_khz", &freq)) {
  ------------------
  |  Branch (332:7): [True: 0, False: 1]
  ------------------
  333|      0|    return freq * 1e3;  // Value is kHz.
  334|      0|  }
  335|       |
  336|      1|#if defined(ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY)
  337|       |  // On these platforms, the TSC frequency is the nominal CPU
  338|       |  // frequency.  But without having the kernel export it directly
  339|       |  // though /sys/devices/system/cpu/cpu0/tsc_freq_khz, there is no
  340|       |  // other way to reliably get the TSC frequency, so we have to
  341|       |  // measure it ourselves.  Some CPUs abuse cpuinfo_max_freq by
  342|       |  // exporting "fake" frequencies for implementing new features. For
  343|       |  // example, Intel's turbo mode is enabled by exposing a p-state
  344|       |  // value with a higher frequency than that of the real TSC
  345|       |  // rate. Because of this, we prefer to measure the TSC rate
  346|       |  // ourselves on i386 and x86-64.
  347|      1|  return MeasureTscFrequency();
  348|       |#else
  349|       |
  350|       |  // If CPU scaling is in effect, we want to use the *maximum*
  351|       |  // frequency, not whatever CPU speed some random processor happens
  352|       |  // to be using now.
  353|       |  if (ReadLongFromFile("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq",
  354|       |                       &freq)) {
  355|       |    return freq * 1e3;  // Value is kHz.
  356|       |  }
  357|       |
  358|       |  return 1.0;
  359|       |#endif  // !ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
  360|      1|}
sysinfo.cc:_ZN4absl12lts_2026010713base_internalL16ReadLongFromFileEPKcPl:
  203|      1|static bool ReadLongFromFile(const char *file, long *value) {
  204|      1|  bool ret = false;
  205|      1|#if defined(_POSIX_C_SOURCE)
  206|      1|  const int file_mode = (O_RDONLY | O_CLOEXEC);
  207|       |#else
  208|       |  const int file_mode = O_RDONLY;
  209|       |#endif
  210|       |
  211|      1|  int fd = open(file, file_mode);
  212|      1|  if (fd != -1) {
  ------------------
  |  Branch (212:7): [True: 0, False: 1]
  ------------------
  213|      0|    char line[1024];
  214|      0|    char *err;
  215|      0|    memset(line, '\0', sizeof(line));
  216|      0|    ssize_t len;
  217|      0|    do {
  218|      0|      len = read(fd, line, sizeof(line) - 1);
  219|      0|    } while (len < 0 && errno == EINTR);
  ------------------
  |  Branch (219:14): [True: 0, False: 0]
  |  Branch (219:25): [True: 0, False: 0]
  ------------------
  220|      0|    if (len <= 0) {
  ------------------
  |  Branch (220:9): [True: 0, False: 0]
  ------------------
  221|      0|      ret = false;
  222|      0|    } else {
  223|      0|      const long temp_value = strtol(line, &err, 10);
  224|      0|      if (line[0] != '\0' && (*err == '\n' || *err == '\0')) {
  ------------------
  |  Branch (224:11): [True: 0, False: 0]
  |  Branch (224:31): [True: 0, False: 0]
  |  Branch (224:47): [True: 0, False: 0]
  ------------------
  225|      0|        *value = temp_value;
  226|      0|        ret = true;
  227|      0|      }
  228|      0|    }
  229|      0|    close(fd);
  230|      0|  }
  231|      1|  return ret;
  232|      1|}
sysinfo.cc:_ZN4absl12lts_2026010713base_internalL19MeasureTscFrequencyEv:
  302|      1|static double MeasureTscFrequency() {
  303|      1|  double last_measurement = -1.0;
  304|      1|  int sleep_nanoseconds = 1000000;  // 1 millisecond.
  305|      2|  for (int i = 0; i < 8; ++i) {
  ------------------
  |  Branch (305:19): [True: 2, False: 0]
  ------------------
  306|      2|    double measurement = MeasureTscFrequencyWithSleep(sleep_nanoseconds);
  307|      2|    if (measurement * 0.99 < last_measurement &&
  ------------------
  |  Branch (307:9): [True: 1, False: 1]
  ------------------
  308|      1|        last_measurement < measurement * 1.01) {
  ------------------
  |  Branch (308:9): [True: 1, False: 0]
  ------------------
  309|       |      // Use the current measurement if it is within 1% of the
  310|       |      // previous measurement.
  311|      1|      return measurement;
  312|      1|    }
  313|      1|    last_measurement = measurement;
  314|      1|    sleep_nanoseconds *= 2;
  315|      1|  }
  316|      0|  return last_measurement;
  317|      1|}
sysinfo.cc:_ZN4absl12lts_2026010713base_internalL28MeasureTscFrequencyWithSleepEi:
  287|      2|static double MeasureTscFrequencyWithSleep(int sleep_nanoseconds) {
  288|      2|  auto t0 = GetTimeTscPair();
  289|      2|  struct timespec ts;
  290|      2|  ts.tv_sec = 0;
  291|      2|  ts.tv_nsec = sleep_nanoseconds;
  292|      2|  while (nanosleep(&ts, &ts) != 0 && errno == EINTR) {}
  ------------------
  |  Branch (292:10): [True: 0, False: 2]
  |  Branch (292:38): [True: 0, False: 0]
  ------------------
  293|      2|  auto t1 = GetTimeTscPair();
  294|      2|  double elapsed_ticks = t1.tsc - t0.tsc;
  295|      2|  double elapsed_time = (t1.time - t0.time) * 1e-9;
  296|      2|  return elapsed_ticks / elapsed_time;
  297|      2|}
sysinfo.cc:_ZN4absl12lts_2026010713base_internalL14GetTimeTscPairEv:
  268|      4|static TimeTscPair GetTimeTscPair() {
  269|      4|  int64_t best_latency = std::numeric_limits<int64_t>::max();
  270|      4|  TimeTscPair best;
  271|     44|  for (int i = 0; i < 10; ++i) {
  ------------------
  |  Branch (271:19): [True: 40, False: 4]
  ------------------
  272|     40|    int64_t t0 = ReadMonotonicClockNanos();
  273|     40|    int64_t tsc = UnscaledCycleClockWrapperForInitializeFrequency::Now();
  274|     40|    int64_t t1 = ReadMonotonicClockNanos();
  275|     40|    int64_t latency = t1 - t0;
  276|     40|    if (latency < best_latency) {
  ------------------
  |  Branch (276:9): [True: 9, False: 31]
  ------------------
  277|      9|      best_latency = latency;
  278|      9|      best.time = t0;
  279|      9|      best.tsc = tsc;
  280|      9|    }
  281|     40|  }
  282|      4|  return best;
  283|      4|}
sysinfo.cc:_ZN4absl12lts_2026010713base_internalL23ReadMonotonicClockNanosEv:
  239|     80|static int64_t ReadMonotonicClockNanos() {
  240|     80|  struct timespec t;
  241|     80|#ifdef CLOCK_MONOTONIC_RAW
  242|     80|  int rc = clock_gettime(CLOCK_MONOTONIC_RAW, &t);
  243|       |#else
  244|       |  int rc = clock_gettime(CLOCK_MONOTONIC, &t);
  245|       |#endif
  246|     80|  if (rc != 0) {
  ------------------
  |  Branch (246:7): [True: 0, False: 80]
  ------------------
  247|      0|    ABSL_INTERNAL_LOG(
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  248|      0|        FATAL, "clock_gettime() failed: (" + std::to_string(errno) + ")");
  249|      0|  }
  250|     80|  return int64_t{t.tv_sec} * 1000000000 + t.tv_nsec;
  251|     80|}
_ZN4absl12lts_2026010713base_internal47UnscaledCycleClockWrapperForInitializeFrequency3NowEv:
  255|     40|  static int64_t Now() { return base_internal::UnscaledCycleClock::Now(); }

_ZN4absl12lts_2026010713base_internal24SetCurrentThreadIdentityEPNS1_14ThreadIdentityEPFvPvE:
   77|     20|                              ThreadIdentityReclaimerFunction reclaimer) {
   78|     20|  assert(CurrentThreadIdentityIfPresent() == nullptr);
   79|       |  // Associate our destructor.
   80|       |  // NOTE: This call to pthread_setspecific is currently the only immovable
   81|       |  // barrier to CurrentThreadIdentity() always being async signal safe.
   82|     20|#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
   83|       |  // NOTE: Not async-safe.  But can be open-coded.
   84|     20|  absl::call_once(init_thread_identity_key_once, AllocateThreadIdentityKey,
   85|     20|                  reclaimer);
   86|       |
   87|       |#if defined(__wasi__) || defined(__EMSCRIPTEN__) || defined(__MINGW32__) || \
   88|       |    defined(__hexagon__)
   89|       |  // Emscripten, WASI and MinGW pthread implementations does not support
   90|       |  // signals. See
   91|       |  // https://kripken.github.io/emscripten-site/docs/porting/pthreads.html for
   92|       |  // more information.
   93|       |  pthread_setspecific(thread_identity_pthread_key,
   94|       |                      reinterpret_cast<void*>(identity));
   95|       |#else
   96|       |  // We must mask signals around the call to setspecific as with current glibc,
   97|       |  // a concurrent getspecific (needed for GetCurrentThreadIdentityIfPresent())
   98|       |  // may zero our value.
   99|       |  //
  100|       |  // While not officially async-signal safe, getspecific within a signal handler
  101|       |  // is otherwise OK.
  102|     20|  sigset_t all_signals;
  103|     20|  sigset_t curr_signals;
  104|     20|  sigfillset(&all_signals);
  105|     20|  pthread_sigmask(SIG_SETMASK, &all_signals, &curr_signals);
  106|     20|  pthread_setspecific(thread_identity_pthread_key,
  107|     20|                      reinterpret_cast<void*>(identity));
  108|     20|  pthread_sigmask(SIG_SETMASK, &curr_signals, nullptr);
  109|     20|#endif  // !__EMSCRIPTEN__ && !__MINGW32__
  110|       |
  111|       |#elif ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS
  112|       |  // NOTE: Not async-safe.  But can be open-coded.
  113|       |  absl::call_once(init_thread_identity_key_once, AllocateThreadIdentityKey,
  114|       |                  reclaimer);
  115|       |  pthread_setspecific(thread_identity_pthread_key,
  116|       |                      reinterpret_cast<void*>(identity));
  117|       |  thread_identity_ptr = identity;
  118|       |#elif ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
  119|       |  thread_local std::unique_ptr<ThreadIdentity, ThreadIdentityReclaimerFunction>
  120|       |      holder(identity, reclaimer);
  121|       |  thread_identity_ptr = identity;
  122|       |#else
  123|       |#error Unimplemented ABSL_THREAD_IDENTITY_MODE
  124|       |#endif
  125|     20|}
_ZN4absl12lts_2026010713base_internal26ClearCurrentThreadIdentityEv:
  139|     19|void ClearCurrentThreadIdentity() {
  140|       |#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
  141|       |    ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
  142|       |  thread_identity_ptr = nullptr;
  143|       |#elif ABSL_THREAD_IDENTITY_MODE == \
  144|       |    ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
  145|       |  // pthread_setspecific expected to clear value on destruction
  146|       |  assert(CurrentThreadIdentityIfPresent() == nullptr);
  147|     19|#endif
  148|     19|}
_ZN4absl12lts_2026010713base_internal30CurrentThreadIdentityIfPresentEv:
  151|     41|ThreadIdentity* CurrentThreadIdentityIfPresent() {
  152|     41|  bool initialized = pthread_key_initialized.load(std::memory_order_acquire);
  153|     41|  if (!initialized) {
  ------------------
  |  Branch (153:7): [True: 1, False: 40]
  ------------------
  154|      1|    return nullptr;
  155|      1|  }
  156|     40|  return reinterpret_cast<ThreadIdentity*>(
  157|     40|      pthread_getspecific(thread_identity_pthread_key));
  158|     41|}
thread_identity.cc:_ZN4absl12lts_2026010713base_internal12_GLOBAL__N_125AllocateThreadIdentityKeyEPFvPvE:
   46|      1|void AllocateThreadIdentityKey(ThreadIdentityReclaimerFunction reclaimer) {
   47|      1|  pthread_key_create(&thread_identity_pthread_key, reclaimer);
   48|      1|  pthread_key_initialized.store(true, std::memory_order_release);
   49|      1|}

_ZN4absl12lts_2026010713base_internal14PerThreadSynch15thread_identityEv:
   61|     18|  ThreadIdentity* thread_identity() {
   62|     18|    return reinterpret_cast<ThreadIdentity*>(this);
   63|     18|  }

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

_ZN4absl12lts_2026010713base_internal18UnscaledCycleClock9FrequencyEv:
   57|     18|double UnscaledCycleClock::Frequency() {
   58|     18|  return base_internal::NominalCPUFrequency();
   59|     18|}

_ZN4absl12lts_2026010713base_internal18UnscaledCycleClock3NowEv:
   82|     99|inline int64_t UnscaledCycleClock::Now() {
   83|     99|  uint64_t low, high;
   84|     99|  __asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
   85|     99|  return static_cast<int64_t>((high << 32) | low);
   86|     99|}

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

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|   619k|  T& operator*() { return *get(); }
log_sink_set.cc:_ZN4absl12lts_2026010712NoDestructorINS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSetEE3getEv:
  139|   619k|  T* absl_nonnull get() { return impl_.get(); }
log_sink_set.cc:_ZN4absl12lts_2026010712NoDestructorINS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSetEE13PlacementImpl3getEv:
  166|   619k|    T* absl_nonnull get() {
  167|   619k|      return std::launder(reinterpret_cast<T*>(&space_));
  168|   619k|    }

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

log_sink_set.cc:_ZN4absl12lts_2026010716cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_EC2ESD_:
   49|   619k|  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|   619k|    ::new (GetCallbackBuffer()) Callback(std::move(callback));
   54|   619k|    is_callback_engaged_ = true;
   55|   619k|  }
log_sink_set.cc:_ZN4absl12lts_2026010716cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E17GetCallbackBufferEv:
   72|  1.85M|  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|   619k|  bool IsCallbackEngaged() const { return is_callback_engaged_; }
log_sink_set.cc:_ZN4absl12lts_2026010716cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E14InvokeCallbackEv:
   85|   619k|  void InvokeCallback() ABSL_NO_THREAD_SAFETY_ANALYSIS {
   86|   619k|    std::move(GetCallback())();
   87|   619k|  }
log_sink_set.cc:_ZN4absl12lts_2026010716cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E11GetCallbackEv:
   74|  1.23M|  Callback& GetCallback() {
   75|  1.23M|    return *reinterpret_cast<Callback*>(GetCallbackBuffer());
   76|  1.23M|  }
log_sink_set.cc:_ZN4absl12lts_2026010716cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E15DestroyCallbackEv:
   80|   619k|  void DestroyCallback() {
   81|   619k|    is_callback_engaged_ = false;
   82|   619k|    GetCallback().~Callback();
   83|   619k|  }

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

_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNSt3__19allocatorIPNS0_7LogSinkEEEmEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS8_XT_EE4typeEv:
  249|  1.23M|  constexpr const ElemT<I>& get() const& {
  250|  1.23M|    return StorageT<I>::get();
  251|  1.23M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEELb0EE3getEv:
   91|  1.23M|  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|   619k|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|   619k|                                             std::forward<First>(first),
  241|   619k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEENS5_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJS9_jEEENS5_10in_place_tEDpOT_:
  126|  1.23M|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|  1.23M|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIPNS0_7LogSinkEEELm0ENS2_10StorageTagIJS8_mEEELb1EEC2IS8_EENS4_10in_place_tEOT_:
  102|   619k|  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|   619k|      : value(std::forward<V>(v)) {}
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNSt3__19allocatorIPNS0_7LogSinkEEEmEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS8_XT_EE4typeEv:
  244|   619k|  constexpr ElemT<I>& get() & {
  245|   619k|    return StorageT<I>::get();
  246|   619k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEELb0EE3getEv:
   92|   619k|  constexpr T& get() & { return value; }

_ZN4absl12lts_2026010718container_internal8AllocateILm8ENSt3__19allocatorIcEEEEPvPT0_m:
   62|   247k|void* Allocate(Alloc* alloc, size_t n) {
   63|   247k|  static_assert(Alignment > 0, "");
   64|   247k|  assert(n && "n must be positive");
   65|   247k|  using M = AlignedType<Alignment>;
   66|   247k|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   67|   247k|  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|   247k|  A my_mem_alloc(*alloc);
   72|   247k|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   73|       |  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   74|   247k|         "allocator does not respect alignment");
   75|   247k|  return p;
   76|   247k|}
_ZN4absl12lts_2026010718container_internal10DeallocateILm8ENSt3__19allocatorIcEEEEvPT0_Pvm:
   93|   247k|void Deallocate(Alloc* alloc, void* p, size_t n) {
   94|   247k|  static_assert(Alignment > 0, "");
   95|   247k|  assert(n && "n must be positive");
   96|   247k|  using M = AlignedType<Alignment>;
   97|   247k|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   98|   247k|  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|   247k|  A my_mem_alloc(*alloc);
  103|   247k|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
  104|   247k|                 (n + sizeof(M) - 1) / sizeof(M));
  105|   247k|}

_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl18MaskEmptyOrDeletedEv:
  319|   125k|  NonIterableBitMaskType MaskEmptyOrDeleted() const {
  320|   125k|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  321|   125k|    return NonIterableBitMaskType(static_cast<uint16_t>(
  322|   125k|        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))));
  323|   125k|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl37ConvertSpecialToEmptyAndFullToDeletedEPNS1_6ctrl_tE:
  334|     28|  void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
  335|       |    // Take advantage of the fact that kEmpty is already the smallest signed
  336|       |    // char value, and using a saturated subtraction will not affect it.
  337|       |    // All special values have the MSB set, so after an AND with MSBS, we
  338|       |    // are left with -128 for special values and 0 for full. After applying
  339|       |    // subs 2, we arrive at the result of -128(kEmpty) for special and
  340|       |    // -2(kDeleted) for full.
  341|     28|    auto msbs = _mm_set1_epi8(static_cast<char>(-128));
  342|     28|    auto twos = _mm_set1_epi8(static_cast<char>(2));
  343|     28|    auto res = _mm_subs_epi8(_mm_and_si128(msbs, ctrl), twos);
  344|     28|    _mm_storeu_si128(reinterpret_cast<__m128i*>(dst), res);
  345|     28|  }
_ZN4absl12lts_2026010718container_internal17GroupPortableImplC2EPKNS1_6ctrl_tE:
  439|  10.4k|      : ctrl(little_endian::Load64(pos)) {}
_ZNK4absl12lts_2026010718container_internal17GroupPortableImpl8MaskFullEv:
  467|  10.4k|  auto MaskFull() const {
  468|  10.4k|    return BitMaskType((ctrl ^ kMsbs8Bytes) & kMsbs8Bytes);
  469|  10.4k|  }
_ZN4absl12lts_2026010718container_internal7IsEmptyENS1_6ctrl_tE:
  220|  82.3k|inline bool IsEmpty(ctrl_t c) { return c == ctrl_t::kEmpty; }
_ZN4absl12lts_2026010718container_internal6IsFullENS1_6ctrl_tE:
  221|  3.90M|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|  3.90M|  return static_cast<std::underlying_type_t<ctrl_t>>(c) >= 0;
  226|  3.90M|}
_ZN4absl12lts_2026010718container_internal9IsDeletedENS1_6ctrl_tE:
  227|    331|inline bool IsDeleted(ctrl_t c) { return c == ctrl_t::kDeleted; }
_ZN4absl12lts_2026010718container_internal20_mm_cmpgt_epi8_fixedEDv2_xS2_:
  264|   125k|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|   125k|  return _mm_cmpgt_epi8(a, b);
  273|   125k|}
_ZNK4absl12lts_2026010718container_internal18NonIterableBitMaskItLi16ELi0EE13TrailingZerosEv:
   95|  47.7k|  uint32_t TrailingZeros() const {
   96|  47.7k|    return container_internal::TrailingZeros(mask_) >> Shift;
   97|  47.7k|  }
_ZNK4absl12lts_2026010718container_internal18NonIterableBitMaskItLi16ELi0EE12LeadingZerosEv:
  100|  47.7k|  uint32_t LeadingZeros() const {
  101|  47.7k|    constexpr int total_significant_bits = SignificantBits << Shift;
  102|  47.7k|    constexpr int extra_bits = sizeof(T) * 8 - total_significant_bits;
  103|  47.7k|    return static_cast<uint32_t>(
  104|  47.7k|               countl_zero(static_cast<T>(mask_ << extra_bits))) >>
  105|  47.7k|           Shift;
  106|  47.7k|  }
_ZN4absl12lts_2026010718container_internal7BitMaskImLi8ELi3ELb0EEC2Em:
  133|  20.8k|  explicit BitMask(T mask) : Base(mask) {
  134|  20.8k|    if (Shift == 3 && !NullifyBitsOnIteration) {
  ------------------
  |  Branch (134:9): [True: 0, Folded]
  |  Branch (134:23): [True: 0, Folded]
  ------------------
  135|       |      ABSL_SWISSTABLE_ASSERT(this->mask_ == (this->mask_ & kMsbs8Bytes));
  ------------------
  |  |   58|  20.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  136|  20.8k|    }
  137|  20.8k|  }
_ZN4absl12lts_2026010718container_internal18NonIterableBitMaskImLi8ELi3EEC2Em:
   85|  20.8k|  explicit NonIterableBitMask(T mask) : mask_(mask) {}
_ZNK4absl12lts_2026010718container_internal7BitMaskImLi8ELi3ELb0EE5beginEv:
  153|  10.4k|  BitMask begin() const { return *this; }
_ZNK4absl12lts_2026010718container_internal7BitMaskImLi8ELi3ELb0EE3endEv:
  154|  10.4k|  BitMask end() const { return BitMask(0); }
_ZN4absl12lts_2026010718container_internalneERKNS1_7BitMaskImLi8ELi3ELb0EEES5_:
  160|  49.7k|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  161|  49.7k|    return a.mask_ != b.mask_;
  162|  49.7k|  }
_ZNK4absl12lts_2026010718container_internal7BitMaskImLi8ELi3ELb0EEdeEv:
  151|  39.3k|  uint32_t operator*() const { return Base::LowestBitSet(); }
_ZNK4absl12lts_2026010718container_internal18NonIterableBitMaskImLi8ELi3EE12LowestBitSetEv:
   90|  39.3k|  uint32_t LowestBitSet() const {
   91|  39.3k|    return container_internal::TrailingZeros(mask_) >> Shift;
   92|  39.3k|  }
_ZN4absl12lts_2026010718container_internal13TrailingZerosImEEjT_:
   63|  39.3k|uint32_t TrailingZeros(T x) {
   64|  39.3k|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  270|  39.3k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
   65|  39.3k|  return static_cast<uint32_t>(countr_zero(x));
   66|  39.3k|}
_ZN4absl12lts_2026010718container_internal7BitMaskImLi8ELi3ELb0EEppEv:
  143|  39.3k|  BitMask& operator++() {
  144|  39.3k|    if (Shift == 3 && NullifyBitsOnIteration) {
  ------------------
  |  Branch (144:9): [True: 0, Folded]
  |  Branch (144:23): [Folded, False: 0]
  ------------------
  145|      0|      this->mask_ &= kMsbs8Bytes;
  146|      0|    }
  147|  39.3k|    this->mask_ &= (this->mask_ - 1);
  148|  39.3k|    return *this;
  149|  39.3k|  }

_ZNK4absl12lts_2026010718container_internal20HashtablezInfoHandle9IsSampledEv:
  220|   235k|  inline bool IsSampled() const { return false; }
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle20RecordStorageChangedEmm:
  221|  5.89k|  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle12RecordRehashEm:
  222|     11|  inline void RecordRehash(size_t /*total_probe_length*/) {}
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle24RecordClearedReservationEv:
  224|  2.23k|  inline void RecordClearedReservation() {}
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle16RecordInsertMissEmm:
  226|  3.66M|                               size_t /*distance_from_desired*/) {}
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle11RecordEraseEv:
  227|  56.8k|  inline void RecordErase() {}

_ZNK4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE14GetIsAllocatedEv:
  372|   619k|  bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
_ZNK4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE21GetSizeAndIsAllocatedEv:
  366|  1.23M|  const SizeType<A>& GetSizeAndIsAllocated() const {
  367|  1.23M|    return metadata_.template get<1>();
  368|  1.23M|  }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE14GetInlinedDataEv:
  396|   619k|  ABSL_ATTRIBUTE_NO_SANITIZE_CFI Pointer<A> GetInlinedData() {
  397|   619k|    return reinterpret_cast<Pointer<A>>(data_.inlined.inlined_data);
  398|   619k|  }
_ZNK4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE7GetSizeEv:
  370|   619k|  SizeType<A> GetSize() const { return GetSizeAndIsAllocated() >> 1; }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEEC2Ev:
  337|   619k|  Storage() : metadata_(A(), /* size and is_allocated */ 0u) {}
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEED2Ev:
  342|   619k|  ~Storage() {
  343|       |    // Fast path: if we are empty and not allocated, there's nothing to do.
  344|   619k|    if (GetSizeAndIsAllocated() == 0) {
  ------------------
  |  Branch (344:9): [True: 619k, False: 0]
  ------------------
  345|   619k|      return;
  346|   619k|    }
  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|   619k|  SizeType<A>& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }

_ZN4absl12lts_2026010718container_internal42GrowSooTableToNextCapacityAndPrepareInsertILm8ELb1EEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEEb:
 1759|      1|    absl::FunctionRef<size_t(size_t)> get_hash, bool force_sampling) {
 1760|      1|  AssertSoo(common, policy);
 1761|      1|  if (ABSL_PREDICT_FALSE(force_sampling)) {
  ------------------
  |  |  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]
  |  |  ------------------
  ------------------
 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|      1|  ABSL_SWISSTABLE_ASSERT(common.size() == policy.soo_capacity());
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1767|      1|  static constexpr size_t kNewCapacity = NextCapacity(SooCapacity());
 1768|      1|  const size_t slot_size = policy.slot_size;
 1769|      1|  void* alloc = policy.get_char_alloc(common);
 1770|      1|  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|      1|  const auto [new_ctrl, new_slots] = AllocBackingArray(
 1778|      1|      common, policy, kNewCapacity, /*has_infoz=*/false, alloc);
 1779|       |
 1780|      1|  PrepareInsertCommon(common);
 1781|      1|  ABSL_SWISSTABLE_ASSERT(common.size() == 2);
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1782|      1|  GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(kNewCapacity - 2);
 1783|      1|  common.generate_new_seed(/*has_infoz=*/false);
 1784|      1|  const h2_t soo_slot_h2 = H2(policy.hash_slot(
 1785|      1|      policy.hash_fn(common), common.soo_data(), common.seed().seed()));
 1786|      1|  const size_t new_hash = get_hash(common.seed().seed());
 1787|       |
 1788|      1|  const size_t offset = Resize1To3NewOffset(new_hash, common.seed());
 1789|      1|  InitializeThreeElementsControlBytes(soo_slot_h2, H2(new_hash), offset,
 1790|      1|                                      new_ctrl);
 1791|       |
 1792|      1|  SanitizerPoisonMemoryRegion(new_slots, slot_size * kNewCapacity);
 1793|      1|  void* target_slot = SlotAddress(new_slots, SooSlotIndex(), slot_size);
 1794|      1|  SanitizerUnpoisonMemoryRegion(target_slot, slot_size);
 1795|      1|  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|      1|    static_assert(SooSlotIndex() == 1);
 1800|      1|    static_assert(SooSlotMemcpySize > 0);
 1801|      1|    static_assert(SooSlotMemcpySize <= MaxSooSlotSize());
 1802|      1|    ABSL_SWISSTABLE_ASSERT(SooSlotMemcpySize <= 2 * slot_size);
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1803|      1|    ABSL_SWISSTABLE_ASSERT(SooSlotMemcpySize >= slot_size);
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1804|      1|    void* next_slot = SlotAddress(target_slot, 1, slot_size);
 1805|      1|    SanitizerUnpoisonMemoryRegion(next_slot, SooSlotMemcpySize - slot_size);
 1806|      1|    std::memcpy(target_slot, common.soo_data(), SooSlotMemcpySize);
 1807|      1|    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|      1|  common.set_control(new_ctrl);
 1813|      1|  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|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1818|      1|  SanitizerUnpoisonMemoryRegion(SlotAddress(new_slots, offset, slot_size),
 1819|      1|                                slot_size);
 1820|      1|  return offset;
 1821|      1|}
_ZN4absl12lts_2026010718container_internal42GrowSooTableToNextCapacityAndPrepareInsertILm16ELb1EEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEEb:
 1759|  11.7k|    absl::FunctionRef<size_t(size_t)> get_hash, bool force_sampling) {
 1760|  11.7k|  AssertSoo(common, policy);
 1761|  11.7k|  if (ABSL_PREDICT_FALSE(force_sampling)) {
  ------------------
  |  |  189|  11.7k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 11.7k]
  |  |  |  Branch (189:49): [Folded, False: 11.7k]
  |  |  |  Branch (189:58): [True: 0, False: 11.7k]
  |  |  ------------------
  ------------------
 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|  11.7k|  ABSL_SWISSTABLE_ASSERT(common.size() == policy.soo_capacity());
  ------------------
  |  |   62|  11.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1767|  11.7k|  static constexpr size_t kNewCapacity = NextCapacity(SooCapacity());
 1768|  11.7k|  const size_t slot_size = policy.slot_size;
 1769|  11.7k|  void* alloc = policy.get_char_alloc(common);
 1770|  11.7k|  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|  11.7k|  const auto [new_ctrl, new_slots] = AllocBackingArray(
 1778|  11.7k|      common, policy, kNewCapacity, /*has_infoz=*/false, alloc);
 1779|       |
 1780|  11.7k|  PrepareInsertCommon(common);
 1781|  11.7k|  ABSL_SWISSTABLE_ASSERT(common.size() == 2);
  ------------------
  |  |   62|  11.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1782|  11.7k|  GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(kNewCapacity - 2);
 1783|  11.7k|  common.generate_new_seed(/*has_infoz=*/false);
 1784|  11.7k|  const h2_t soo_slot_h2 = H2(policy.hash_slot(
 1785|  11.7k|      policy.hash_fn(common), common.soo_data(), common.seed().seed()));
 1786|  11.7k|  const size_t new_hash = get_hash(common.seed().seed());
 1787|       |
 1788|  11.7k|  const size_t offset = Resize1To3NewOffset(new_hash, common.seed());
 1789|  11.7k|  InitializeThreeElementsControlBytes(soo_slot_h2, H2(new_hash), offset,
 1790|  11.7k|                                      new_ctrl);
 1791|       |
 1792|  11.7k|  SanitizerPoisonMemoryRegion(new_slots, slot_size * kNewCapacity);
 1793|  11.7k|  void* target_slot = SlotAddress(new_slots, SooSlotIndex(), slot_size);
 1794|  11.7k|  SanitizerUnpoisonMemoryRegion(target_slot, slot_size);
 1795|  11.7k|  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|  11.7k|    static_assert(SooSlotIndex() == 1);
 1800|  11.7k|    static_assert(SooSlotMemcpySize > 0);
 1801|  11.7k|    static_assert(SooSlotMemcpySize <= MaxSooSlotSize());
 1802|  11.7k|    ABSL_SWISSTABLE_ASSERT(SooSlotMemcpySize <= 2 * slot_size);
  ------------------
  |  |   62|  11.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1803|  11.7k|    ABSL_SWISSTABLE_ASSERT(SooSlotMemcpySize >= slot_size);
  ------------------
  |  |   62|  11.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1804|  11.7k|    void* next_slot = SlotAddress(target_slot, 1, slot_size);
 1805|  11.7k|    SanitizerUnpoisonMemoryRegion(next_slot, SooSlotMemcpySize - slot_size);
 1806|  11.7k|    std::memcpy(target_slot, common.soo_data(), SooSlotMemcpySize);
 1807|  11.7k|    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|  11.7k|  common.set_control(new_ctrl);
 1813|  11.7k|  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|  11.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1818|  11.7k|  SanitizerUnpoisonMemoryRegion(SlotAddress(new_slots, offset, slot_size),
 1819|  11.7k|                                slot_size);
 1820|  11.7k|  return offset;
 1821|  11.7k|}
_ZN4absl12lts_2026010718container_internal13HashtableSize8NextSeedEv:
  137|  56.2k|uint16_t HashtableSize::NextSeed() {
  138|  56.2k|  static_assert(PerTableSeed::kBitCount == 16);
  139|  56.2k|  thread_local uint16_t seed =
  140|  56.2k|      static_cast<uint16_t>(reinterpret_cast<uintptr_t>(&seed));
  141|  56.2k|  seed += uint16_t{0xad53};
  142|  56.2k|  return seed;
  143|  56.2k|}
_ZN4absl12lts_2026010718container_internal37ConvertDeletedToEmptyAndFullToDeletedEPNS1_6ctrl_tEm:
  283|     11|void ConvertDeletedToEmptyAndFullToDeleted(ctrl_t* ctrl, size_t capacity) {
  284|     11|  ABSL_SWISSTABLE_ASSERT(ctrl[capacity] == ctrl_t::kSentinel);
  ------------------
  |  |   62|     11|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  285|     11|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |   62|     11|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  286|     39|  for (ctrl_t* pos = ctrl; pos < ctrl + capacity; pos += Group::kWidth) {
  ------------------
  |  Branch (286:28): [True: 28, False: 11]
  ------------------
  287|     28|    Group{pos}.ConvertSpecialToEmptyAndFullToDeleted(pos);
  288|     28|  }
  289|       |  // Copy the cloned ctrl bytes.
  290|     11|  std::memcpy(ctrl + capacity + 1, ctrl, NumClonedBytes());
  291|     11|  ctrl[capacity] = ctrl_t::kSentinel;
  292|     11|}
_ZN4absl12lts_2026010718container_internal20IterateOverFullSlotsERKNS1_12CommonFieldsEmNS0_11FunctionRefIFvPKNS1_6ctrl_tEPvEEE:
  295|  37.9k|                          absl::FunctionRef<void(const ctrl_t*, void*)> cb) {
  296|  37.9k|  IterateOverFullSlotsImpl(c, slot_size, cb);
  297|  37.9k|}
_ZN4absl12lts_2026010718container_internal18EraseMetaOnlyLargeERNS1_12CommonFieldsEPKNS1_6ctrl_tEm:
  631|  56.8k|void EraseMetaOnlyLarge(CommonFields& c, const ctrl_t* ctrl, size_t slot_size) {
  632|  56.8k|  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   62|  56.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  633|  56.8k|  ABSL_SWISSTABLE_ASSERT(IsFull(*ctrl) && "erasing a dangling iterator");
  ------------------
  |  |   62|  56.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  634|  56.8k|  c.decrement_size();
  635|  56.8k|  c.infoz().RecordErase();
  636|       |
  637|  56.8k|  size_t index = static_cast<size_t>(ctrl - c.control());
  638|       |
  639|  56.8k|  if (WasNeverFull(c, index)) {
  ------------------
  |  Branch (639:7): [True: 47.1k, False: 9.71k]
  ------------------
  640|  47.1k|    SetCtrl(c, index, ctrl_t::kEmpty, slot_size);
  641|  47.1k|    c.growth_info().OverwriteFullAsEmpty();
  642|  47.1k|    return;
  643|  47.1k|  }
  644|       |
  645|  9.71k|  c.growth_info().OverwriteFullAsDeleted();
  646|  9.71k|  SetCtrlInLargeTable(c, index, ctrl_t::kDeleted, slot_size);
  647|  9.71k|}
_ZN4absl12lts_2026010718container_internal17ClearBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPvbb:
  651|  5.89k|                       bool reuse, bool soo_enabled) {
  652|  5.89k|  if (reuse) {
  ------------------
  |  Branch (652:7): [True: 3.66k, False: 2.23k]
  ------------------
  653|  3.66k|    c.set_size_to_zero();
  654|  3.66k|    ABSL_SWISSTABLE_ASSERT(!soo_enabled || c.capacity() > SooCapacity());
  ------------------
  |  |   62|  3.66k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  655|  3.66k|    ResetCtrl(c, policy.slot_size);
  656|  3.66k|    ResetGrowthLeft(c);
  657|  3.66k|    c.infoz().RecordStorageChanged(0, c.capacity());
  658|  3.66k|  } else {
  659|       |    // We need to record infoz before calling dealloc, which will unregister
  660|       |    // infoz.
  661|  2.23k|    c.infoz().RecordClearedReservation();
  662|  2.23k|    c.infoz().RecordStorageChanged(0, soo_enabled ? SooCapacity() : 0);
  ------------------
  |  Branch (662:39): [True: 0, False: 2.23k]
  ------------------
  663|  2.23k|    c.infoz().Unregister();
  664|  2.23k|    (*policy.dealloc)(alloc, c.capacity(), c.control(), policy.slot_size,
  665|  2.23k|                      policy.slot_align, c.has_infoz());
  666|  2.23k|    c = soo_enabled ? CommonFields{soo_tag_t{}} : CommonFields{non_soo_tag_t{}};
  ------------------
  |  Branch (666:9): [True: 0, False: 2.23k]
  ------------------
  667|  2.23k|  }
  668|  5.89k|}
_ZN4absl12lts_2026010718container_internal24PrepareInsertSmallNonSooERNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEE:
 1524|  78.2k|    absl::FunctionRef<size_t(size_t)> get_hash) {
 1525|  78.2k|  ABSL_SWISSTABLE_ASSERT(common.is_small());
  ------------------
  |  |   62|  78.2k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1526|  78.2k|  ABSL_SWISSTABLE_ASSERT(!policy.soo_enabled);
  ------------------
  |  |   62|  78.2k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1527|  78.2k|  if (common.capacity() == 1) {
  ------------------
  |  Branch (1527:7): [True: 37.8k, False: 40.4k]
  ------------------
 1528|  37.8k|    if (common.empty()) {
  ------------------
  |  Branch (1528:9): [True: 132, False: 37.6k]
  ------------------
 1529|    132|      IncrementSmallSizeNonSoo(common, policy);
 1530|    132|      return {SooControl(), common.slot_array()};
 1531|  37.6k|    } else {
 1532|  37.6k|      return Grow1To3AndPrepareInsert(common, policy, get_hash);
 1533|  37.6k|    }
 1534|  37.8k|  }
 1535|       |
 1536|       |  // Growing from 0 to 1 capacity.
 1537|  40.4k|  ABSL_SWISSTABLE_ASSERT(common.capacity() == 0);
  ------------------
  |  |   62|  40.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1538|  40.4k|  constexpr size_t kNewCapacity = 1;
 1539|       |
 1540|  40.4k|  common.set_capacity(kNewCapacity);
 1541|  40.4k|  HashtablezInfoHandle infoz;
 1542|  40.4k|  const bool should_sample =
 1543|  40.4k|      policy.is_hashtablez_eligible && ShouldSampleNextTable();
  ------------------
  |  Branch (1543:7): [True: 40.4k, False: 0]
  |  Branch (1543:40): [True: 0, False: 40.4k]
  ------------------
 1544|  40.4k|  if (ABSL_PREDICT_FALSE(should_sample)) {
  ------------------
  |  |  189|  40.4k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 40.4k]
  |  |  |  Branch (189:49): [Folded, False: 40.4k]
  |  |  |  Branch (189:58): [True: 0, False: 40.4k]
  |  |  ------------------
  ------------------
 1545|      0|    infoz = ForcedTrySample(policy.slot_size, policy.key_size,
 1546|      0|                            policy.value_size, policy.soo_capacity());
 1547|      0|  }
 1548|  40.4k|  const bool has_infoz = infoz.IsSampled();
 1549|  40.4k|  void* alloc = policy.get_char_alloc(common);
 1550|       |
 1551|  40.4k|  const auto [new_ctrl, new_slots] =
 1552|  40.4k|      AllocBackingArray(common, policy, kNewCapacity, has_infoz, alloc);
 1553|  40.4k|  common.set_control(new_ctrl);
 1554|  40.4k|  common.set_slots(new_slots);
 1555|       |
 1556|  40.4k|  static_assert(NextCapacity(0) == 1);
 1557|  40.4k|  PrepareInsertCommon(common);
 1558|       |
 1559|  40.4k|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  189|  40.4k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 40.4k]
  |  |  |  Branch (189:49): [Folded, False: 40.4k]
  |  |  |  Branch (189:58): [True: 0, False: 40.4k]
  |  |  ------------------
  ------------------
 1560|      0|    common.generate_new_seed(/*has_infoz=*/true);
 1561|      0|    ReportSingleGroupTableGrowthToInfoz(common, infoz,
 1562|      0|                                        get_hash(common.seed().seed()));
 1563|      0|  }
 1564|  40.4k|  return {SooControl(), new_slots};
 1565|  78.2k|}
_ZN4absl12lts_2026010718container_internal19GetRefForEmptyClassERNS1_12CommonFieldsE:
 1731|   297k|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|   297k|  return &common;
 1737|   297k|}
_ZN4absl12lts_2026010718container_internal45ReserveEmptyNonAllocatedTableToFitBucketCountERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1748|  6.79k|    size_t bucket_count) {
 1749|  6.79k|  size_t new_capacity = NormalizeCapacity(bucket_count);
 1750|  6.79k|  ValidateMaxSize(CapacityToGrowth(new_capacity), policy.slot_size);
 1751|  6.79k|  ResizeEmptyNonAllocatedTableImpl(common, policy, new_capacity,
 1752|  6.79k|                                   /*force_infoz=*/false);
 1753|  6.79k|}
_ZN4absl12lts_2026010718container_internal18PrepareInsertLargeERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_18NonIterableBitMaskItLi16ELi0EEENS1_8FindInfoE:
 1992|  3.81M|                          FindInfo target_group) {
 1993|       |  // NOLINTNEXTLINE(misc-static-assert)
 1994|       |  ABSL_SWISSTABLE_ASSERT(!SwisstableGenerationsEnabled());
  ------------------
  |  |   62|  3.81M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1995|  3.81M|  return PrepareInsertLargeImpl(common, policy, hash, mask_empty, target_group);
 1996|  3.81M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119Resize1To3NewOffsetEmNS1_12PerTableSeedE:
  106|  49.4k|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|  49.4k|  static_assert(SooSlotIndex() == 1);
  110|  49.4k|  return SingleGroupTableH1(hash, seed) & 2;
  111|  49.4k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_118SingleGroupTableH1EmNS1_12PerTableSeedE:
  101|   129k|size_t SingleGroupTableH1(size_t hash, PerTableSeed seed) {
  102|   129k|  return hash ^ seed.seed();
  103|   129k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_111SlotAddressEPvmm:
  115|  2.93M|inline void* SlotAddress(void* slot_array, size_t slot, size_t slot_size) {
  116|  2.93M|  return static_cast<void*>(static_cast<char*>(slot_array) +
  117|  2.93M|                            (slot * slot_size));
  118|  2.93M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119PrepareInsertCommonERNS1_12CommonFieldsE:
  334|  3.90M|void PrepareInsertCommon(CommonFields& common) {
  335|  3.90M|  common.increment_size();
  336|  3.90M|  common.maybe_increment_generation_on_insert();
  337|  3.90M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_135InitializeThreeElementsControlBytesEhhmPNS1_6ctrl_tE:
  556|  49.4k|    h2_t orig_h2, h2_t new_h2, size_t new_offset, ctrl_t* new_ctrl) {
  557|  49.4k|  static constexpr size_t kNewCapacity = NextCapacity(SooCapacity());
  558|  49.4k|  static_assert(kNewCapacity == 3);
  559|  49.4k|  static_assert(is_single_group(kNewCapacity));
  560|  49.4k|  static_assert(SooSlotIndex() == 1);
  561|  49.4k|  ABSL_SWISSTABLE_ASSERT(new_offset == 0 || new_offset == 2);
  ------------------
  |  |   62|  49.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  562|       |
  563|  49.4k|  static constexpr uint64_t kEmptyXorSentinel =
  564|  49.4k|      static_cast<uint8_t>(ctrl_t::kEmpty) ^
  565|  49.4k|      static_cast<uint8_t>(ctrl_t::kSentinel);
  566|  49.4k|  static constexpr uint64_t kEmpty64 = static_cast<uint8_t>(ctrl_t::kEmpty);
  567|  49.4k|  static constexpr size_t kMirroredSooSlotIndex =
  568|  49.4k|      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|  49.4k|  static constexpr uint64_t kFirstCtrlBytesWithZeroes =
  573|  49.4k|      k8EmptyBytes ^ (kEmpty64 << (8 * SooSlotIndex())) ^
  574|  49.4k|      (kEmptyXorSentinel << (8 * kNewCapacity)) ^
  575|  49.4k|      (kEmpty64 << (8 * kMirroredSooSlotIndex));
  576|       |
  577|  49.4k|  const uint64_t soo_h2 = static_cast<uint64_t>(orig_h2);
  578|  49.4k|  const uint64_t new_h2_xor_empty =
  579|  49.4k|      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|  49.4k|  uint64_t first_ctrl_bytes =
  585|  49.4k|      ((soo_h2 << (8 * SooSlotIndex())) | kFirstCtrlBytesWithZeroes) |
  586|  49.4k|      (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|  49.4k|  first_ctrl_bytes ^= (new_h2_xor_empty << (8 * new_offset));
  594|  49.4k|  size_t new_mirrored_offset = new_offset + kNewCapacity + 1;
  595|  49.4k|  first_ctrl_bytes ^= (new_h2_xor_empty << (8 * new_mirrored_offset));
  596|       |
  597|       |  // Fill last bytes with kEmpty.
  598|  49.4k|  std::memset(new_ctrl + kNewCapacity, static_cast<int8_t>(ctrl_t::kEmpty),
  599|  49.4k|              Group::kWidth);
  600|       |  // Overwrite the first 8 bytes with first_ctrl_bytes.
  601|  49.4k|  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|  49.4k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_112WasNeverFullERNS1_12CommonFieldsEm:
  512|  56.8k|bool WasNeverFull(CommonFields& c, size_t index) {
  513|  56.8k|  if (is_single_group(c.capacity())) {
  ------------------
  |  Branch (513:7): [True: 2.18k, False: 54.6k]
  ------------------
  514|  2.18k|    return true;
  515|  2.18k|  }
  516|  54.6k|  const size_t index_before = (index - Group::kWidth) & c.capacity();
  517|  54.6k|  const auto empty_after = Group(c.control() + index).MaskEmpty();
  518|  54.6k|  const auto empty_before = Group(c.control() + index_before).MaskEmpty();
  519|       |
  520|       |  // We count how many consecutive non empties we have to the right and to the
  521|       |  // left of `it`. If the sum is >= kWidth then there is at least one probe
  522|       |  // window that might have seen a full group.
  523|  54.6k|  return empty_before && empty_after &&
  ------------------
  |  Branch (523:10): [True: 50.7k, False: 3.90k]
  |  Branch (523:26): [True: 47.7k, False: 2.96k]
  ------------------
  524|  47.7k|         static_cast<size_t>(empty_after.TrailingZeros()) +
  ------------------
  |  Branch (524:10): [True: 44.9k, False: 2.84k]
  ------------------
  525|  47.7k|                 empty_before.LeadingZeros() <
  526|  47.7k|             Group::kWidth;
  527|  56.8k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_17SetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  356|  3.63M|                    size_t slot_size) {
  357|       |  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   62|  3.63M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  358|  3.63M|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  359|  3.63M|  ctrl_t* ctrl = c.control();
  360|  3.63M|  ctrl[i] = h;
  361|  3.63M|  ctrl[((i - NumClonedBytes()) & c.capacity()) +
  362|  3.63M|       (NumClonedBytes() & c.capacity())] = h;
  363|  3.63M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119DoSanitizeOnSetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  341|  3.90M|                                size_t slot_size) {
  342|  3.90M|  ABSL_SWISSTABLE_ASSERT(i < c.capacity());
  ------------------
  |  |   62|  3.90M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  343|  3.90M|  auto* slot_i = static_cast<const char*>(c.slot_array()) + i * slot_size;
  344|  3.90M|  if (IsFull(h)) {
  ------------------
  |  Branch (344:7): [True: 3.84M, False: 56.8k]
  ------------------
  345|  3.84M|    SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
  346|  3.84M|  } else {
  347|  56.8k|    SanitizerPoisonMemoryRegion(slot_i, slot_size);
  348|  56.8k|  }
  349|  3.90M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119SetCtrlInLargeTableERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  389|   191k|                                size_t slot_size) {
  390|       |  ABSL_SWISSTABLE_ASSERT(c.capacity() >= Group::kWidth - 1);
  ------------------
  |  |   62|   191k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  391|   191k|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  392|   191k|  ctrl_t* ctrl = c.control();
  393|   191k|  ctrl[i] = h;
  394|   191k|  ctrl[((i - NumClonedBytes()) & c.capacity()) + NumClonedBytes()] = h;
  395|   191k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_19ResetCtrlERNS1_12CommonFieldsEm:
  531|  10.4k|void ResetCtrl(CommonFields& common, size_t slot_size) {
  532|  10.4k|  const size_t capacity = common.capacity();
  533|  10.4k|  ctrl_t* ctrl = common.control();
  534|  10.4k|  static constexpr size_t kTwoGroupCapacity = 2 * Group::kWidth - 1;
  535|  10.4k|  if (ABSL_PREDICT_TRUE(capacity <= kTwoGroupCapacity)) {
  ------------------
  |  |  190|  10.4k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 6.22k, False: 4.24k]
  |  |  |  Branch (190:48): [Folded, False: 10.4k]
  |  |  |  Branch (190:57): [True: 6.22k, False: 4.24k]
  |  |  ------------------
  ------------------
  536|  6.22k|    if (IsSmallCapacity(capacity)) return;
  ------------------
  |  Branch (536:9): [True: 132, False: 6.08k]
  ------------------
  537|  6.08k|    std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
  538|  6.08k|    std::memset(ctrl + capacity, static_cast<int8_t>(ctrl_t::kEmpty),
  539|  6.08k|                Group::kWidth);
  540|  6.08k|    if (capacity == kTwoGroupCapacity) {
  ------------------
  |  Branch (540:9): [True: 2.53k, False: 3.55k]
  ------------------
  541|  2.53k|      std::memset(ctrl + Group::kWidth, static_cast<int8_t>(ctrl_t::kEmpty),
  542|  2.53k|                  Group::kWidth);
  543|  2.53k|    }
  544|  6.08k|  } else {
  545|  4.24k|    std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty),
  546|  4.24k|                capacity + 1 + NumClonedBytes());
  547|  4.24k|  }
  548|  10.3k|  ctrl[capacity] = ctrl_t::kSentinel;
  549|  10.3k|  SanitizerPoisonMemoryRegion(common.slot_array(), slot_size * capacity);
  550|  10.3k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_115ResetGrowthLeftERNS1_12CommonFieldsE:
  305|  3.67k|void ResetGrowthLeft(CommonFields& common) {
  306|  3.67k|  ResetGrowthLeft(common.growth_info(), common.capacity(), common.size());
  307|  3.67k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_115ResetGrowthLeftERNS1_10GrowthInfoEmm:
  301|   154k|void ResetGrowthLeft(GrowthInfo& growth_info, size_t capacity, size_t size) {
  302|   154k|  growth_info.InitGrowthLeftNoDeleted(CapacityToGrowth(capacity) - size);
  303|   154k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117AllocBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmbPv:
  764|   247k|                                   void* alloc) {
  765|   247k|  RawHashSetLayout layout(new_capacity, policy.slot_size, policy.slot_align,
  766|   247k|                          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|   247k|  constexpr size_t kDefaultAlignment = BackingArrayAlignment(alignof(size_t));
  770|   247k|  char* mem = static_cast<char*>(
  771|   247k|      ABSL_PREDICT_TRUE(
  ------------------
  |  |  190|   247k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 247k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 247k]
  |  |  |  Branch (190:57): [True: 247k, False: 0]
  |  |  ------------------
  ------------------
  772|   247k|          policy.alloc ==
  773|   247k|          (&AllocateBackingArray<kDefaultAlignment, std::allocator<char>>))
  774|   247k|          ? AllocateBackingArray<kDefaultAlignment, std::allocator<char>>(
  775|   247k|                alloc, layout.alloc_size())
  776|   247k|          : policy.alloc(alloc, layout.alloc_size()));
  777|   247k|  const GenerationType old_generation = common.generation();
  778|   247k|  common.set_generation_ptr(
  779|   247k|      reinterpret_cast<GenerationType*>(mem + layout.generation_offset()));
  780|   247k|  common.set_generation(NextGeneration(old_generation));
  781|       |
  782|   247k|  return {reinterpret_cast<ctrl_t*>(mem + layout.control_offset()),
  783|   247k|          mem + layout.slot_offset()};
  784|   247k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_19AssertSooERNS1_12CommonFieldsERKNS1_15PolicyFunctionsE:
  890|  11.7k|               [[maybe_unused]] const PolicyFunctions& policy) {
  891|  11.7k|  ABSL_SWISSTABLE_ASSERT(policy.soo_enabled);
  ------------------
  |  |   62|  11.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  892|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() == policy.soo_capacity());
  ------------------
  |  |   62|  11.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  893|  11.7k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_124IncrementSmallSizeNonSooERNS1_12CommonFieldsERKNS1_15PolicyFunctionsE:
 1380|    132|                              const PolicyFunctions& __restrict policy) {
 1381|       |  ABSL_SWISSTABLE_ASSERT(common.is_small());
  ------------------
  |  |   62|    132|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1382|    132|  common.increment_size();
 1383|    132|  SanitizerUnpoisonMemoryRegion(common.slot_array(), policy.slot_size);
 1384|    132|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_124Grow1To3AndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEE:
 1398|  37.6k|    absl::FunctionRef<size_t(size_t)> get_hash) {
 1399|       |  // TODO(b/413062340): Refactor to reuse more code with
 1400|       |  // GrowSooTableToNextCapacityAndPrepareInsert.
 1401|  37.6k|  ABSL_SWISSTABLE_ASSERT(common.capacity() == 1);
  ------------------
  |  |   62|  37.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1402|  37.6k|  ABSL_SWISSTABLE_ASSERT(!common.empty());
  ------------------
  |  |   62|  37.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1403|  37.6k|  ABSL_SWISSTABLE_ASSERT(!policy.soo_enabled);
  ------------------
  |  |   62|  37.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1404|  37.6k|  constexpr size_t kOldCapacity = 1;
 1405|  37.6k|  constexpr size_t kNewCapacity = NextCapacity(kOldCapacity);
 1406|  37.6k|  ctrl_t* old_ctrl = common.control();
 1407|  37.6k|  void* old_slots = common.slot_array();
 1408|       |
 1409|  37.6k|  const size_t slot_size = policy.slot_size;
 1410|  37.6k|  const size_t slot_align = policy.slot_align;
 1411|  37.6k|  void* alloc = policy.get_char_alloc(common);
 1412|  37.6k|  HashtablezInfoHandle infoz = common.infoz();
 1413|  37.6k|  const bool has_infoz = infoz.IsSampled();
 1414|  37.6k|  common.set_capacity(kNewCapacity);
 1415|       |
 1416|  37.6k|  const auto [new_ctrl, new_slots] =
 1417|  37.6k|      AllocBackingArray(common, policy, kNewCapacity, has_infoz, alloc);
 1418|  37.6k|  common.set_control(new_ctrl);
 1419|  37.6k|  common.set_slots(new_slots);
 1420|  37.6k|  SanitizerPoisonMemoryRegion(new_slots, kNewCapacity * slot_size);
 1421|       |
 1422|  37.6k|  if (ABSL_PREDICT_TRUE(!has_infoz)) {
  ------------------
  |  |  190|  37.6k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 37.6k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 37.6k]
  |  |  |  Branch (190:57): [True: 37.6k, False: 0]
  |  |  ------------------
  ------------------
 1423|       |    // When we're sampled, we already have a seed.
 1424|  37.6k|    common.generate_new_seed(/*has_infoz=*/false);
 1425|  37.6k|  }
 1426|  37.6k|  const size_t new_hash = get_hash(common.seed().seed());
 1427|  37.6k|  h2_t new_h2 = H2(new_hash);
 1428|  37.6k|  size_t orig_hash =
 1429|  37.6k|      policy.hash_slot(policy.hash_fn(common), old_slots, common.seed().seed());
 1430|  37.6k|  size_t offset = Resize1To3NewOffset(new_hash, common.seed());
 1431|  37.6k|  InitializeThreeElementsControlBytes(H2(orig_hash), new_h2, offset, new_ctrl);
 1432|       |
 1433|  37.6k|  void* old_element_target = NextSlot(new_slots, slot_size);
 1434|  37.6k|  SanitizerUnpoisonMemoryRegion(old_element_target, slot_size);
 1435|  37.6k|  policy.transfer_n(&common, old_element_target, old_slots, 1);
 1436|       |
 1437|  37.6k|  void* new_element_target_slot = SlotAddress(new_slots, offset, slot_size);
 1438|  37.6k|  SanitizerUnpoisonMemoryRegion(new_element_target_slot, slot_size);
 1439|       |
 1440|  37.6k|  policy.dealloc(alloc, kOldCapacity, old_ctrl, slot_size, slot_align,
 1441|  37.6k|                 has_infoz);
 1442|  37.6k|  PrepareInsertCommon(common);
 1443|  37.6k|  ABSL_SWISSTABLE_ASSERT(common.size() == 2);
  ------------------
  |  |   62|  37.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1444|  37.6k|  GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(kNewCapacity - 2);
 1445|       |
 1446|  37.6k|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  189|  37.6k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 37.6k]
  |  |  |  Branch (189:49): [Folded, False: 37.6k]
  |  |  |  Branch (189:58): [True: 0, False: 37.6k]
  |  |  ------------------
  ------------------
 1447|      0|    ReportSingleGroupTableGrowthToInfoz(common, infoz, new_hash);
 1448|      0|  }
 1449|  37.6k|  return {new_ctrl + offset, new_element_target_slot};
 1450|  37.6k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_18NextSlotEPvmm:
  122|   399k|inline void* NextSlot(void* slot, size_t slot_size, size_t i = 1) {
  123|   399k|  return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(slot) +
  124|   399k|                                 slot_size * i);
  125|   399k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_125SetCtrlInSingleGroupTableERKNS1_12CommonFieldsEmhm:
  382|  79.8k|                                      size_t slot_size) {
  383|  79.8k|  SetCtrlInSingleGroupTable(c, i, static_cast<ctrl_t>(h), slot_size);
  384|  79.8k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_125SetCtrlInSingleGroupTableERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  372|  79.8k|                                      size_t slot_size) {
  373|  79.8k|  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   62|  79.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  374|       |  ABSL_SWISSTABLE_ASSERT(is_single_group(c.capacity()));
  ------------------
  |  |   62|  79.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  375|  79.8k|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  376|  79.8k|  ctrl_t* ctrl = c.control();
  377|  79.8k|  ctrl[i] = h;
  378|  79.8k|  ctrl[i + c.capacity() + 1] = h;
  379|  79.8k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_115ValidateMaxSizeEmm:
   69|  6.79k|void ValidateMaxSize(size_t size, size_t slot_size) {
   70|  6.79k|  if (IsAboveValidSize(size, slot_size)) {
  ------------------
  |  Branch (70:7): [True: 0, False: 6.79k]
  ------------------
   71|      0|    HashTableSizeOverflow();
   72|      0|  }
   73|  6.79k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_132ResizeEmptyNonAllocatedTableImplERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmb:
  838|  6.79k|                                      size_t new_capacity, bool force_infoz) {
  839|  6.79k|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(new_capacity));
  ------------------
  |  |   62|  6.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  840|  6.79k|  ABSL_SWISSTABLE_ASSERT(new_capacity > policy.soo_capacity());
  ------------------
  |  |   62|  6.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  841|  6.79k|  ABSL_SWISSTABLE_ASSERT(!force_infoz || policy.soo_enabled);
  ------------------
  |  |   62|  6.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  842|  6.79k|  ABSL_SWISSTABLE_ASSERT(common.capacity() <= policy.soo_capacity());
  ------------------
  |  |   62|  6.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  843|  6.79k|  ABSL_SWISSTABLE_ASSERT(common.empty());
  ------------------
  |  |   62|  6.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  844|  6.79k|  const size_t slot_size = policy.slot_size;
  845|  6.79k|  HashtablezInfoHandle infoz;
  846|  6.79k|  const bool should_sample =
  847|  6.79k|      policy.is_hashtablez_eligible && (force_infoz || ShouldSampleNextTable());
  ------------------
  |  Branch (847:7): [True: 6.79k, False: 0]
  |  Branch (847:41): [True: 0, False: 6.79k]
  |  Branch (847:56): [True: 0, False: 6.79k]
  ------------------
  848|  6.79k|  if (ABSL_PREDICT_FALSE(should_sample)) {
  ------------------
  |  |  189|  6.79k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 6.79k]
  |  |  |  Branch (189:49): [Folded, False: 6.79k]
  |  |  |  Branch (189:58): [True: 0, False: 6.79k]
  |  |  ------------------
  ------------------
  849|      0|    infoz = ForcedTrySample(slot_size, policy.key_size, policy.value_size,
  850|      0|                            policy.soo_capacity());
  851|      0|  }
  852|  6.79k|  ResizeNonSooImpl<ResizeNonSooMode::kGuaranteedEmpty>(common, policy,
  853|  6.79k|                                                       new_capacity, infoz);
  854|  6.79k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_116ResizeNonSooImplILNS2_16ResizeNonSooModeE0EEEvRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_20HashtablezInfoHandleE:
  789|  6.79k|                      size_t new_capacity, HashtablezInfoHandle infoz) {
  790|  6.79k|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(new_capacity));
  ------------------
  |  |   62|  6.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  791|  6.79k|  ABSL_SWISSTABLE_ASSERT(new_capacity > policy.soo_capacity());
  ------------------
  |  |   62|  6.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  792|       |
  793|  6.79k|  [[maybe_unused]] const size_t old_capacity = common.capacity();
  794|  6.79k|  [[maybe_unused]] ctrl_t* old_ctrl;
  795|  6.79k|  [[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.79k|  const size_t slot_size = policy.slot_size;
  802|  6.79k|  [[maybe_unused]] const size_t slot_align = policy.slot_align;
  803|  6.79k|  const bool has_infoz = infoz.IsSampled();
  804|  6.79k|  void* alloc = policy.get_char_alloc(common);
  805|       |
  806|  6.79k|  common.set_capacity(new_capacity);
  807|  6.79k|  const auto [new_ctrl, new_slots] =
  808|  6.79k|      AllocBackingArray(common, policy, new_capacity, has_infoz, alloc);
  809|  6.79k|  common.set_control(new_ctrl);
  810|  6.79k|  common.set_slots(new_slots);
  811|  6.79k|  common.generate_new_seed(has_infoz);
  812|       |
  813|  6.79k|  size_t total_probe_length = 0;
  814|  6.79k|  ResetCtrl(common, slot_size);
  815|  6.79k|  ABSL_SWISSTABLE_ASSERT(kMode != ResizeNonSooMode::kGuaranteedEmpty ||
  ------------------
  |  |   62|  6.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  816|  6.79k|                         old_capacity == policy.soo_capacity());
  817|  6.79k|  ABSL_SWISSTABLE_ASSERT(kMode != ResizeNonSooMode::kGuaranteedAllocated ||
  ------------------
  |  |   62|  6.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  818|  6.79k|                         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.79k|  } else {
  827|  6.79k|    GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(
  828|  6.79k|        CapacityToGrowth(new_capacity));
  829|  6.79k|  }
  830|       |
  831|  6.79k|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  189|  6.79k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 6.79k]
  |  |  |  Branch (189:49): [Folded, False: 6.79k]
  |  |  |  Branch (189:58): [True: 0, False: 6.79k]
  |  |  ------------------
  ------------------
  832|      0|    ReportResizeToInfoz(common, infoz, total_probe_length);
  833|      0|  }
  834|  6.79k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_17SetCtrlERKNS1_12CommonFieldsEmhm:
  365|  3.58M|inline void SetCtrl(const CommonFields& c, size_t i, h2_t h, size_t slot_size) {
  366|  3.58M|  SetCtrl(c, i, static_cast<ctrl_t>(h), slot_size);
  367|  3.58M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_122PrepareInsertLargeImplERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_18NonIterableBitMaskItLi16ELi0EEENS1_8FindInfoE:
 1970|  3.81M|                              FindInfo target_group) {
 1971|  3.81M|  ABSL_SWISSTABLE_ASSERT(!common.is_small());
  ------------------
  |  |   62|  3.81M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1972|  3.81M|  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|  3.81M|  if (ABSL_PREDICT_FALSE(!growth_info.HasNoDeletedAndGrowthLeft())) {
  ------------------
  |  |  189|  3.81M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 232k, False: 3.58M]
  |  |  |  Branch (189:49): [Folded, False: 3.81M]
  |  |  |  Branch (189:58): [True: 232k, False: 3.58M]
  |  |  ------------------
  ------------------
 1977|   232k|    return PrepareInsertLargeSlow(common, policy, hash);
 1978|   232k|  }
 1979|  3.58M|  PrepareInsertCommon(common);
 1980|  3.58M|  common.growth_info().OverwriteEmptyAsFull();
 1981|  3.58M|  target_group.offset += mask_empty.LowestBitSet();
 1982|  3.58M|  target_group.offset &= common.capacity();
 1983|  3.58M|  SetCtrl(common, target_group.offset, H2(hash), policy.slot_size);
 1984|  3.58M|  common.infoz().RecordInsertMiss(hash, target_group.probe_length);
 1985|  3.58M|  return target_group.offset;
 1986|  3.81M|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_122PrepareInsertLargeSlowERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1632|   232k|                              size_t hash) {
 1633|   232k|  const GrowthInfo growth_info = common.growth_info();
 1634|   232k|  ABSL_SWISSTABLE_ASSERT(!growth_info.HasNoDeletedAndGrowthLeft());
  ------------------
  |  |   62|   232k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1635|   232k|  if (ABSL_PREDICT_TRUE(growth_info.HasNoGrowthLeftAndNoDeleted())) {
  ------------------
  |  |  190|   232k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 150k, False: 82.7k]
  |  |  |  Branch (190:48): [Folded, False: 232k]
  |  |  |  Branch (190:57): [True: 150k, False: 82.7k]
  |  |  ------------------
  ------------------
 1636|       |    // Table without deleted slots (>95% cases) that needs to be resized.
 1637|   150k|    ABSL_SWISSTABLE_ASSERT(growth_info.HasNoDeleted() &&
  ------------------
  |  |   62|   150k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1638|   150k|                           growth_info.GetGrowthLeft() == 0);
 1639|   150k|    return GrowToNextCapacityAndPrepareInsert(common, policy, hash);
 1640|   150k|  }
 1641|  82.7k|  if (ABSL_PREDICT_FALSE(growth_info.HasNoGrowthLeftAssumingMayHaveDeleted())) {
  ------------------
  |  |  189|  82.7k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 868, False: 81.8k]
  |  |  |  Branch (189:49): [Folded, False: 82.7k]
  |  |  |  Branch (189:58): [True: 868, False: 81.8k]
  |  |  ------------------
  ------------------
 1642|       |    // Table with deleted slots that needs to be rehashed or resized.
 1643|    868|    return RehashOrGrowToNextCapacityAndPrepareInsert(common, policy, hash);
 1644|    868|  }
 1645|       |  // Table with deleted slots that has space for the inserting element.
 1646|  81.8k|  FindInfo target = find_first_non_full(common, hash);
 1647|  81.8k|  PrepareInsertCommon(common);
 1648|  81.8k|  common.growth_info().OverwriteControlAsFull(common.control()[target.offset]);
 1649|  81.8k|  SetCtrlInLargeTable(common, target.offset, H2(hash), policy.slot_size);
 1650|  81.8k|  common.infoz().RecordInsertMiss(hash, target.probe_length);
 1651|  81.8k|  return target.offset;
 1652|  82.7k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_134GrowToNextCapacityAndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1456|   150k|    size_t new_hash) {
 1457|   150k|  ABSL_SWISSTABLE_ASSERT(common.growth_left() == 0);
  ------------------
  |  |   62|   150k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1458|   150k|  const size_t old_capacity = common.capacity();
 1459|   150k|  ABSL_SWISSTABLE_ASSERT(old_capacity > policy.soo_capacity());
  ------------------
  |  |   62|   150k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1460|   150k|  ABSL_SWISSTABLE_ASSERT(!IsSmallCapacity(old_capacity));
  ------------------
  |  |   62|   150k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1461|       |
 1462|   150k|  const size_t new_capacity = NextCapacity(old_capacity);
 1463|   150k|  ctrl_t* old_ctrl = common.control();
 1464|   150k|  void* old_slots = common.slot_array();
 1465|       |
 1466|   150k|  common.set_capacity(new_capacity);
 1467|   150k|  const size_t slot_size = policy.slot_size;
 1468|   150k|  const size_t slot_align = policy.slot_align;
 1469|   150k|  void* alloc = policy.get_char_alloc(common);
 1470|   150k|  HashtablezInfoHandle infoz = common.infoz();
 1471|   150k|  const bool has_infoz = infoz.IsSampled();
 1472|       |
 1473|   150k|  const auto [new_ctrl, new_slots] =
 1474|   150k|      AllocBackingArray(common, policy, new_capacity, has_infoz, alloc);
 1475|   150k|  common.set_control(new_ctrl);
 1476|   150k|  common.set_slots(new_slots);
 1477|   150k|  SanitizerPoisonMemoryRegion(new_slots, new_capacity * slot_size);
 1478|       |
 1479|   150k|  h2_t new_h2 = H2(new_hash);
 1480|   150k|  size_t total_probe_length = 0;
 1481|   150k|  FindInfo find_info;
 1482|   150k|  if (ABSL_PREDICT_TRUE(is_single_group(new_capacity))) {
  ------------------
  |  |  190|   150k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 79.8k, False: 71.0k]
  |  |  |  Branch (190:48): [Folded, False: 150k]
  |  |  |  Branch (190:57): [True: 79.8k, False: 71.0k]
  |  |  ------------------
  ------------------
 1483|  79.8k|    size_t offset;
 1484|  79.8k|    GrowIntoSingleGroupShuffleControlBytes(old_ctrl, old_capacity, new_ctrl,
 1485|  79.8k|                                           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|  79.8k|    offset =
 1489|  79.8k|        SingleGroupTableH1(new_hash, common.seed()) & 1 ? 0 : new_capacity - 1;
  ------------------
  |  Branch (1489:9): [True: 39.8k, False: 40.0k]
  ------------------
 1490|       |
 1491|  79.8k|    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[offset]));
  ------------------
  |  |   62|  79.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1492|  79.8k|    SetCtrlInSingleGroupTable(common, offset, new_h2, policy.slot_size);
 1493|  79.8k|    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|  79.8k|    ABSL_SWISSTABLE_ASSERT(common.size() == old_capacity);
  ------------------
  |  |   62|  79.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1497|  79.8k|    void* target = NextSlot(new_slots, slot_size);
 1498|  79.8k|    SanitizerUnpoisonMemoryRegion(target, old_capacity * slot_size);
 1499|  79.8k|    policy.transfer_n(&common, target, old_slots, old_capacity);
 1500|  79.8k|  } else {
 1501|  71.0k|    total_probe_length =
 1502|  71.0k|        GrowToNextCapacityDispatch(common, policy, old_ctrl, old_slots);
 1503|  71.0k|    find_info = find_first_non_full(common, new_hash);
 1504|  71.0k|    SetCtrlInLargeTable(common, find_info.offset, new_h2, policy.slot_size);
 1505|  71.0k|  }
 1506|   150k|  ABSL_SWISSTABLE_ASSERT(old_capacity > policy.soo_capacity());
  ------------------
  |  |   62|   150k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1507|   150k|  (*policy.dealloc)(alloc, old_capacity, old_ctrl, slot_size, slot_align,
 1508|   150k|                    has_infoz);
 1509|   150k|  PrepareInsertCommon(common);
 1510|   150k|  ResetGrowthLeft(GetGrowthInfoFromControl(new_ctrl), new_capacity,
 1511|   150k|                  common.size());
 1512|       |
 1513|   150k|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  189|   150k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 150k]
  |  |  |  Branch (189:49): [Folded, False: 150k]
  |  |  |  Branch (189:58): [True: 0, False: 150k]
  |  |  ------------------
  ------------------
 1514|      0|    ReportGrowthToInfoz(common, infoz, new_hash, total_probe_length,
 1515|      0|                        find_info.probe_length);
 1516|      0|  }
 1517|   150k|  return find_info.offset;
 1518|   150k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_138GrowIntoSingleGroupShuffleControlBytesEPNS1_6ctrl_tEmS4_m:
  941|  79.8k|                                            size_t new_capacity) {
  942|  79.8k|  ABSL_SWISSTABLE_ASSERT(is_single_group(new_capacity));
  ------------------
  |  |   62|  79.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  943|  79.8k|  constexpr size_t kHalfWidth = Group::kWidth / 2;
  944|  79.8k|  ABSL_ASSUME(old_capacity < kHalfWidth);
  ------------------
  |  |  270|  79.8k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  945|  79.8k|  ABSL_ASSUME(old_capacity > 0);
  ------------------
  |  |  270|  79.8k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  946|  79.8k|  static_assert(Group::kWidth == 8 || Group::kWidth == 16,
  947|  79.8k|                "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|  79.8k|  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|  79.8k|  static constexpr uint64_t kEmptyXorSentinel =
  967|  79.8k|      static_cast<uint8_t>(ctrl_t::kEmpty) ^
  968|  79.8k|      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|  79.8k|  copied_bytes ^= kEmptyXorSentinel;
  977|       |
  978|  79.8k|  if (Group::kWidth == 8) {
  ------------------
  |  Branch (978:7): [Folded, False: 79.8k]
  ------------------
  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|  79.8k|  ABSL_SWISSTABLE_ASSERT(Group::kWidth == 16);  // NOLINT(misc-static-assert)
  ------------------
  |  |   62|  79.8k|  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|  79.8k|  std::memset(new_ctrl + kHalfWidth, static_cast<int8_t>(ctrl_t::kEmpty),
 1013|  79.8k|              kHalfWidth);
 1014|       |  // Fill the second half of the mirrored control bytes with kEmpty.
 1015|  79.8k|  std::memset(new_ctrl + new_capacity + kHalfWidth,
 1016|  79.8k|              static_cast<int8_t>(ctrl_t::kEmpty), kHalfWidth);
 1017|       |  // Copy the first half of the non-mirrored control bytes.
 1018|  79.8k|  absl::little_endian::Store64(new_ctrl, copied_bytes);
 1019|  79.8k|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
 1020|       |  // Copy the first half of the mirrored control bytes.
 1021|  79.8k|  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|  79.8k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_126GrowToNextCapacityDispatchERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1368|  71.0k|                                  ctrl_t* old_ctrl, void* old_slots) {
 1369|  71.0k|  const size_t new_capacity = common.capacity();
 1370|  71.0k|  if (ABSL_PREDICT_TRUE(new_capacity <= kMaxLocalBufferNewCapacity)) {
  ------------------
  |  |  190|  71.0k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 66.2k, False: 4.78k]
  |  |  |  Branch (190:48): [Folded, False: 71.0k]
  |  |  |  Branch (190:57): [True: 66.2k, False: 4.78k]
  |  |  ------------------
  ------------------
 1371|  66.2k|    return GrowToNextCapacityThatFitsInLocalBuffer(common, policy, old_ctrl,
 1372|  66.2k|                                                   old_slots);
 1373|  66.2k|  } else {
 1374|  4.78k|    return GrowToNextCapacityOverflowLocalBuffer(common, policy, old_ctrl,
 1375|  4.78k|                                                 old_slots);
 1376|  4.78k|  }
 1377|  71.0k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_139GrowToNextCapacityThatFitsInLocalBufferERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1318|  66.2k|    ctrl_t* old_ctrl, void* old_slots) {
 1319|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= kMaxLocalBufferNewCapacity);
  ------------------
  |  |   62|  66.2k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1320|  66.2k|  return GrowToNextCapacity<
 1321|  66.2k|      ProbedItemEncoder<ProbedItem4Bytes, /*kGuaranteedFitToBuffer=*/true>>(
 1322|  66.2k|      common, policy, old_ctrl, old_slots);
 1323|  66.2k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1299|  66.2k|                          ctrl_t* old_ctrl, void* old_slots) {
 1300|  66.2k|  using ProbedItem = typename Encoder::ProbedItem;
 1301|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   62|  66.2k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1302|  66.2k|  Encoder encoder(old_ctrl);
 1303|  66.2k|  policy.transfer_unprobed_elements_to_next_capacity(
 1304|  66.2k|      common, old_ctrl, old_slots, &encoder,
 1305|  66.2k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|  66.2k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|  66.2k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|  66.2k|      });
 1309|  66.2k|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1310|  66.2k|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1311|  66.2k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEC2EPNS1_6ctrl_tE:
 1174|  66.2k|  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|  19.9k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|  19.9k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|  19.9k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|  19.9k|      });
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EE10EncodeItemES5_:
 1177|  19.9k|  void EncodeItem(ProbedItem item) {
 1178|  19.9k|    if (ABSL_PREDICT_FALSE(!kGuaranteedFitToBuffer && pos_ >= end_)) {
  ------------------
  |  |  189|  19.9k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [Folded, False: 19.9k]
  |  |  |  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|  19.9k|    ABSL_SWISSTABLE_ASSERT(pos_ < end_);
  ------------------
  |  |   62|  19.9k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1182|  19.9k|    *pos_ = item;
 1183|  19.9k|    ++pos_;
 1184|  19.9k|  }
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_130InitializeMirroredControlBytesEPNS1_6ctrl_tEm:
 1150|  71.0k|void InitializeMirroredControlBytes(ctrl_t* new_ctrl, size_t new_capacity) {
 1151|  71.0k|  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|  71.0k|              new_ctrl - 1, Group::kWidth);
 1155|  71.0k|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
 1156|  71.0k|}
raw_hash_set.cc:_ZNK4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1191|  66.2k|                                void* old_slots) const {
 1192|  66.2k|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1192:9): [True: 54.8k, False: 11.4k]
  ------------------
 1193|  54.8k|      return 0;
 1194|  54.8k|    }
 1195|  11.4k|    if constexpr (kGuaranteedFitToBuffer) {
 1196|  11.4k|      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1197|  11.4k|    }
 1198|      0|    size_t total_probe_length = DecodeAndInsertImpl(
 1199|  11.4k|        common, policy, buffer_,
 1200|  11.4k|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1200:9): [True: 0, False: 11.4k]
  ------------------
 1201|  11.4k|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1201:9): [True: 0, False: 11.4k]
  ------------------
 1202|      0|      return total_probe_length;
 1203|      0|    }
 1204|  11.4k|    total_probe_length +=
 1205|  11.4k|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1206|  11.4k|    return total_probe_length;
 1207|  11.4k|  }
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119DecodeAndInsertImplINS1_14ProbedItemImplIjLm32EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPKT_SD_Pv:
 1073|  14.0k|    const ProbedItem* start, const ProbedItem* end, void* old_slots) {
 1074|  14.0k|  const size_t new_capacity = c.capacity();
 1075|       |
 1076|  14.0k|  void* new_slots = c.slot_array();
 1077|  14.0k|  ctrl_t* new_ctrl = c.control();
 1078|  14.0k|  size_t total_probe_length = 0;
 1079|       |
 1080|  14.0k|  const size_t slot_size = policy.slot_size;
 1081|  14.0k|  auto transfer_n = policy.transfer_n;
 1082|       |
 1083|  42.1k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1083:10): [True: 28.1k, False: 14.0k]
  ------------------
 1084|  28.1k|    const FindInfo target = find_first_non_full_from_h1(
 1085|  28.1k|        new_ctrl, static_cast<size_t>(start->h1), new_capacity);
 1086|  28.1k|    total_probe_length += target.probe_length;
 1087|  28.1k|    const size_t old_index = static_cast<size_t>(start->source_offset);
 1088|  28.1k|    const size_t new_i = target.offset;
 1089|  28.1k|    ABSL_SWISSTABLE_ASSERT(old_index < new_capacity / 2);
  ------------------
  |  |   62|  28.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1090|  28.1k|    ABSL_SWISSTABLE_ASSERT(new_i < new_capacity);
  ------------------
  |  |   62|  28.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1091|       |    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_i]));
  ------------------
  |  |   62|  28.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1092|  28.1k|    void* src_slot = SlotAddress(old_slots, old_index, slot_size);
 1093|  28.1k|    void* dst_slot = SlotAddress(new_slots, new_i, slot_size);
 1094|  28.1k|    SanitizerUnpoisonMemoryRegion(dst_slot, slot_size);
 1095|  28.1k|    transfer_n(&c, dst_slot, src_slot, 1);
 1096|  28.1k|    SetCtrlInLargeTable(c, new_i, static_cast<h2_t>(start->h2), slot_size);
 1097|  28.1k|  }
 1098|  14.0k|  return total_probe_length;
 1099|  14.0k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_127find_first_non_full_from_h1EPKNS1_6ctrl_tEmm:
  187|   181k|                                     size_t capacity) {
  188|   181k|  auto seq = probe_h1(capacity, h1);
  189|   181k|  if (IsEmptyOrDeleted(ctrl[seq.offset()])) {
  ------------------
  |  Branch (189:7): [True: 74.0k, False: 107k]
  ------------------
  190|  74.0k|    return {seq.offset(), /*probe_length=*/0};
  191|  74.0k|  }
  192|   107k|  auto mask = probe_till_first_non_full_group(ctrl, seq, capacity);
  193|   107k|  return {seq.offset(mask.LowestBitSet()), seq.index()};
  194|   181k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_131probe_till_first_non_full_groupEPKNS1_6ctrl_tERNS1_9probe_seqILm16EEEm:
  174|   107k|    [[maybe_unused]] size_t capacity) {
  175|   125k|  while (true) {
  ------------------
  |  Branch (175:10): [True: 125k, Folded]
  ------------------
  176|   125k|    GroupFullEmptyOrDeleted g{ctrl + seq.offset()};
  177|   125k|    auto mask = g.MaskEmptyOrDeleted();
  178|   125k|    if (mask) {
  ------------------
  |  Branch (178:9): [True: 107k, False: 17.7k]
  ------------------
  179|   107k|      return mask;
  180|   107k|    }
  181|  17.7k|    seq.next();
  182|       |    ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity && "full table!");
  ------------------
  |  |   62|  17.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  183|  17.7k|  }
  184|   107k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_137GrowToNextCapacityOverflowLocalBufferERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1351|  4.78k|    ctrl_t* old_ctrl, void* old_slots) {
 1352|  4.78k|  const size_t new_capacity = common.capacity();
 1353|  4.78k|  if (ABSL_PREDICT_TRUE(new_capacity <= ProbedItem4Bytes::kMaxNewCapacity)) {
  ------------------
  |  |  190|  4.78k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 4.78k, False: 5]
  |  |  |  Branch (190:48): [Folded, False: 4.78k]
  |  |  |  Branch (190:57): [True: 4.78k, False: 5]
  |  |  ------------------
  ------------------
 1354|  4.78k|    return GrowToNextCapacity4BytesEncoder(common, policy, old_ctrl, old_slots);
 1355|  4.78k|  }
 1356|      5|  if (ABSL_PREDICT_TRUE(new_capacity <= ProbedItem8Bytes::kMaxNewCapacity)) {
  ------------------
  |  |  190|      5|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 5, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 5]
  |  |  |  Branch (190:57): [True: 5, False: 0]
  |  |  ------------------
  ------------------
 1357|      5|    return GrowToNextCapacity8BytesEncoder(common, policy, old_ctrl, old_slots);
 1358|      5|  }
 1359|       |  // 16 bytes encoding supports the maximum swisstable capacity.
 1360|      0|  return GrowToNextCapacity16BytesEncoder(common, policy, old_ctrl, old_slots);
 1361|      5|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_131GrowToNextCapacity4BytesEncoderERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1329|  4.78k|                                       ctrl_t* old_ctrl, void* old_slots) {
 1330|  4.78k|  return GrowToNextCapacity<ProbedItemEncoder<ProbedItem4Bytes>>(
 1331|  4.78k|      common, policy, old_ctrl, old_slots);
 1332|  4.78k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1299|  4.78k|                          ctrl_t* old_ctrl, void* old_slots) {
 1300|  4.78k|  using ProbedItem = typename Encoder::ProbedItem;
 1301|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   62|  4.78k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1302|  4.78k|  Encoder encoder(old_ctrl);
 1303|  4.78k|  policy.transfer_unprobed_elements_to_next_capacity(
 1304|  4.78k|      common, old_ctrl, old_slots, &encoder,
 1305|  4.78k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|  4.78k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|  4.78k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|  4.78k|      });
 1309|  4.78k|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1310|  4.78k|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1311|  4.78k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EEC2EPNS1_6ctrl_tE:
 1174|  4.78k|  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|  8.21k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|  8.21k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|  8.21k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|  8.21k|      });
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EE10EncodeItemES5_:
 1177|  8.21k|  void EncodeItem(ProbedItem item) {
 1178|  8.21k|    if (ABSL_PREDICT_FALSE(!kGuaranteedFitToBuffer && pos_ >= end_)) {
  ------------------
  |  |  189|  16.4k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 8.21k]
  |  |  |  Branch (189:49): [Folded, False: 8.21k]
  |  |  |  Branch (189:59): [True: 8.21k, Folded]
  |  |  |  Branch (189:59): [True: 0, False: 8.21k]
  |  |  ------------------
  ------------------
 1179|      0|      return ProcessEncodeWithOverflow(item);
 1180|      0|    }
 1181|  8.21k|    ABSL_SWISSTABLE_ASSERT(pos_ < end_);
  ------------------
  |  |   62|  8.21k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1182|  8.21k|    *pos_ = item;
 1183|  8.21k|    ++pos_;
 1184|  8.21k|  }
raw_hash_set.cc:_ZNK4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1191|  4.78k|                                void* old_slots) const {
 1192|  4.78k|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1192:9): [True: 2.21k, False: 2.56k]
  ------------------
 1193|  2.21k|      return 0;
 1194|  2.21k|    }
 1195|       |    if constexpr (kGuaranteedFitToBuffer) {
 1196|       |      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1197|       |    }
 1198|  2.56k|    size_t total_probe_length = DecodeAndInsertImpl(
 1199|  2.56k|        common, policy, buffer_,
 1200|  2.56k|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1200:9): [True: 0, False: 2.56k]
  ------------------
 1201|  2.56k|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1201:9): [True: 2.56k, False: 0]
  ------------------
 1202|  2.56k|      return total_probe_length;
 1203|  2.56k|    }
 1204|      0|    total_probe_length +=
 1205|      0|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1206|      0|    return total_probe_length;
 1207|  2.56k|  }
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_131GrowToNextCapacity8BytesEncoderERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1335|      5|                                       ctrl_t* old_ctrl, void* old_slots) {
 1336|      5|  return GrowToNextCapacity<ProbedItemEncoder<ProbedItem8Bytes>>(
 1337|      5|      common, policy, old_ctrl, old_slots);
 1338|      5|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1299|      5|                          ctrl_t* old_ctrl, void* old_slots) {
 1300|      5|  using ProbedItem = typename Encoder::ProbedItem;
 1301|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   62|      5|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1302|      5|  Encoder encoder(old_ctrl);
 1303|      5|  policy.transfer_unprobed_elements_to_next_capacity(
 1304|      5|      common, old_ctrl, old_slots, &encoder,
 1305|      5|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|      5|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|      5|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|      5|      });
 1309|      5|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1310|      5|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1311|      5|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EEC2EPNS1_6ctrl_tE:
 1174|      5|  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|      5|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1306|      5|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1307|      5|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1308|      5|      });
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EE10EncodeItemES5_:
 1177|      5|  void EncodeItem(ProbedItem item) {
 1178|      5|    if (ABSL_PREDICT_FALSE(!kGuaranteedFitToBuffer && pos_ >= end_)) {
  ------------------
  |  |  189|     10|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 5]
  |  |  |  Branch (189:49): [Folded, False: 5]
  |  |  |  Branch (189:59): [True: 5, Folded]
  |  |  |  Branch (189:59): [True: 0, False: 5]
  |  |  ------------------
  ------------------
 1179|      0|      return ProcessEncodeWithOverflow(item);
 1180|      0|    }
 1181|      5|    ABSL_SWISSTABLE_ASSERT(pos_ < end_);
  ------------------
  |  |   62|      5|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1182|      5|    *pos_ = item;
 1183|      5|    ++pos_;
 1184|      5|  }
raw_hash_set.cc:_ZNK4absl12lts_2026010718container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1191|      5|                                void* old_slots) const {
 1192|      5|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1192:9): [True: 2, False: 3]
  ------------------
 1193|      2|      return 0;
 1194|      2|    }
 1195|       |    if constexpr (kGuaranteedFitToBuffer) {
 1196|       |      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1197|       |    }
 1198|      3|    size_t total_probe_length = DecodeAndInsertImpl(
 1199|      3|        common, policy, buffer_,
 1200|      3|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1200:9): [True: 0, False: 3]
  ------------------
 1201|      3|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1201:9): [True: 3, False: 0]
  ------------------
 1202|      3|      return total_probe_length;
 1203|      3|    }
 1204|      0|    total_probe_length +=
 1205|      0|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1206|      0|    return total_probe_length;
 1207|      3|  }
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119DecodeAndInsertImplINS1_14ProbedItemImplImLm64EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPKT_SD_Pv:
 1073|      3|    const ProbedItem* start, const ProbedItem* end, void* old_slots) {
 1074|      3|  const size_t new_capacity = c.capacity();
 1075|       |
 1076|      3|  void* new_slots = c.slot_array();
 1077|      3|  ctrl_t* new_ctrl = c.control();
 1078|      3|  size_t total_probe_length = 0;
 1079|       |
 1080|      3|  const size_t slot_size = policy.slot_size;
 1081|      3|  auto transfer_n = policy.transfer_n;
 1082|       |
 1083|      8|  for (; start < end; ++start) {
  ------------------
  |  Branch (1083:10): [True: 5, False: 3]
  ------------------
 1084|      5|    const FindInfo target = find_first_non_full_from_h1(
 1085|      5|        new_ctrl, static_cast<size_t>(start->h1), new_capacity);
 1086|      5|    total_probe_length += target.probe_length;
 1087|      5|    const size_t old_index = static_cast<size_t>(start->source_offset);
 1088|      5|    const size_t new_i = target.offset;
 1089|      5|    ABSL_SWISSTABLE_ASSERT(old_index < new_capacity / 2);
  ------------------
  |  |   62|      5|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1090|      5|    ABSL_SWISSTABLE_ASSERT(new_i < new_capacity);
  ------------------
  |  |   62|      5|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1091|       |    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_i]));
  ------------------
  |  |   62|      5|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1092|      5|    void* src_slot = SlotAddress(old_slots, old_index, slot_size);
 1093|      5|    void* dst_slot = SlotAddress(new_slots, new_i, slot_size);
 1094|      5|    SanitizerUnpoisonMemoryRegion(dst_slot, slot_size);
 1095|      5|    transfer_n(&c, dst_slot, src_slot, 1);
 1096|      5|    SetCtrlInLargeTable(c, new_i, static_cast<h2_t>(start->h2), slot_size);
 1097|      5|  }
 1098|      3|  return total_probe_length;
 1099|      3|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_142RehashOrGrowToNextCapacityAndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1574|    868|    size_t new_hash) {
 1575|    868|  const size_t cap = common.capacity();
 1576|    868|  ABSL_ASSUME(cap > 0);
  ------------------
  |  |  270|    868|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1577|    868|  if (cap > Group::kWidth &&
  ------------------
  |  Branch (1577:7): [True: 868, False: 0]
  ------------------
 1578|       |      // Do these calculations in 64-bit to avoid overflow.
 1579|    868|      common.size() * uint64_t{32} <= cap * uint64_t{25}) {
  ------------------
  |  Branch (1579:7): [True: 11, False: 857]
  ------------------
 1580|       |    // Squash DELETED without growing if there is enough capacity.
 1581|       |    //
 1582|       |    // Rehash in place if the current size is <= 25/32 of capacity.
 1583|       |    // Rationale for such a high factor: 1) DropDeletesWithoutResize() is
 1584|       |    // faster than resize, and 2) it takes quite a bit of work to add
 1585|       |    // tombstones.  In the worst case, seems to take approximately 4
 1586|       |    // insert/erase pairs to create a single tombstone and so if we are
 1587|       |    // rehashing because of tombstones, we can afford to rehash-in-place as
 1588|       |    // long as we are reclaiming at least 1/8 the capacity without doing more
 1589|       |    // than 2X the work.  (Where "work" is defined to be size() for rehashing
 1590|       |    // or rehashing in place, and 1 for an insert or erase.)  But rehashing in
 1591|       |    // place is faster per operation than inserting or even doubling the size
 1592|       |    // of the table, so we actually afford to reclaim even less space from a
 1593|       |    // resize-in-place.  The decision is to rehash in place if we can reclaim
 1594|       |    // at about 1/8th of the usable capacity (specifically 3/28 of the
 1595|       |    // capacity) which means that the total cost of rehashing will be a small
 1596|       |    // fraction of the total work.
 1597|       |    //
 1598|       |    // Here is output of an experiment using the BM_CacheInSteadyState
 1599|       |    // benchmark running the old case (where we rehash-in-place only if we can
 1600|       |    // reclaim at least 7/16*capacity) vs. this code (which rehashes in place
 1601|       |    // if we can recover 3/32*capacity).
 1602|       |    //
 1603|       |    // Note that although in the worst-case number of rehashes jumped up from
 1604|       |    // 15 to 190, but the number of operations per second is almost the same.
 1605|       |    //
 1606|       |    // Abridged output of running BM_CacheInSteadyState benchmark from
 1607|       |    // raw_hash_set_benchmark.   N is the number of insert/erase operations.
 1608|       |    //
 1609|       |    //      | OLD (recover >= 7/16        | NEW (recover >= 3/32)
 1610|       |    // size |    N/s LoadFactor NRehashes |    N/s LoadFactor NRehashes
 1611|       |    //  448 | 145284       0.44        18 | 140118       0.44        19
 1612|       |    //  493 | 152546       0.24        11 | 151417       0.48        28
 1613|       |    //  538 | 151439       0.26        11 | 151152       0.53        38
 1614|       |    //  583 | 151765       0.28        11 | 150572       0.57        50
 1615|       |    //  628 | 150241       0.31        11 | 150853       0.61        66
 1616|       |    //  672 | 149602       0.33        12 | 150110       0.66        90
 1617|       |    //  717 | 149998       0.35        12 | 149531       0.70       129
 1618|       |    //  762 | 149836       0.37        13 | 148559       0.74       190
 1619|       |    //  807 | 149736       0.39        14 | 151107       0.39        14
 1620|       |    //  852 | 150204       0.42        15 | 151019       0.42        15
 1621|     11|    return DropDeletesWithoutResizeAndPrepareInsert(common, policy, new_hash);
 1622|    857|  } else {
 1623|       |    // Otherwise grow the container.
 1624|    857|    return GrowToNextCapacityAndPrepareInsert(common, policy, new_hash);
 1625|    857|  }
 1626|    868|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_140DropDeletesWithoutResizeAndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
  404|     11|    size_t new_hash) {
  405|     11|  void* set = &common;
  406|     11|  void* slot_array = common.slot_array();
  407|     11|  const size_t capacity = common.capacity();
  408|     11|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |   62|     11|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  409|     11|  ABSL_SWISSTABLE_ASSERT(!is_single_group(capacity));
  ------------------
  |  |   62|     11|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  410|       |  // Algorithm:
  411|       |  // - mark all DELETED slots as EMPTY
  412|       |  // - mark all FULL slots as DELETED
  413|       |  // - for each slot marked as DELETED
  414|       |  //     hash = Hash(element)
  415|       |  //     target = find_first_non_full(hash)
  416|       |  //     if target is in the same group
  417|       |  //       mark slot as FULL
  418|       |  //     else if target is EMPTY
  419|       |  //       transfer element to target
  420|       |  //       mark slot as EMPTY
  421|       |  //       mark target as FULL
  422|       |  //     else if target is DELETED
  423|       |  //       swap current element with target element
  424|       |  //       mark target as FULL
  425|       |  //       repeat procedure for current slot with moved from element (target)
  426|     11|  ctrl_t* ctrl = common.control();
  427|     11|  ConvertDeletedToEmptyAndFullToDeleted(ctrl, capacity);
  428|     11|  const void* hash_fn = policy.hash_fn(common);
  429|     11|  auto hasher = policy.hash_slot;
  430|     11|  auto transfer_n = policy.transfer_n;
  431|     11|  const size_t slot_size = policy.slot_size;
  432|       |
  433|     11|  size_t total_probe_length = 0;
  434|     11|  void* slot_ptr = SlotAddress(slot_array, 0, slot_size);
  435|       |
  436|       |  // The index of an empty slot that can be used as temporary memory for
  437|       |  // the swap operation.
  438|     11|  constexpr size_t kUnknownId = ~size_t{};
  439|     11|  size_t tmp_space_id = kUnknownId;
  440|       |
  441|    451|  for (size_t i = 0; i != capacity;
  ------------------
  |  Branch (441:22): [True: 440, False: 11]
  ------------------
  442|    440|       ++i, slot_ptr = NextSlot(slot_ptr, slot_size)) {
  443|    440|    ABSL_SWISSTABLE_ASSERT(slot_ptr == SlotAddress(slot_array, i, slot_size));
  ------------------
  |  |   62|    440|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  444|    440|    if (IsEmpty(ctrl[i])) {
  ------------------
  |  Branch (444:9): [True: 109, False: 331]
  ------------------
  445|    109|      tmp_space_id = i;
  446|    109|      continue;
  447|    109|    }
  448|    331|    if (!IsDeleted(ctrl[i])) continue;
  ------------------
  |  Branch (448:9): [True: 3, False: 328]
  ------------------
  449|    328|    const size_t hash = (*hasher)(hash_fn, slot_ptr, common.seed().seed());
  450|    328|    const FindInfo target = find_first_non_full(common, hash);
  451|    328|    const size_t new_i = target.offset;
  452|    328|    total_probe_length += target.probe_length;
  453|       |
  454|       |    // Verify if the old and new i fall within the same group wrt the hash.
  455|       |    // If they do, we don't need to move the object as it falls already in the
  456|       |    // best probe we can.
  457|    328|    const size_t probe_offset = probe(common, hash).offset();
  458|    328|    const h2_t h2 = H2(hash);
  459|    328|    const auto probe_index = [probe_offset, capacity](size_t pos) {
  460|    328|      return ((pos - probe_offset) & capacity) / Group::kWidth;
  461|    328|    };
  462|       |
  463|       |    // Element doesn't move.
  464|    328|    if (ABSL_PREDICT_TRUE(probe_index(new_i) == probe_index(i))) {
  ------------------
  |  |  190|    328|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 315, False: 13]
  |  |  |  Branch (190:48): [Folded, False: 328]
  |  |  |  Branch (190:57): [True: 315, False: 13]
  |  |  ------------------
  ------------------
  465|    315|      SetCtrlInLargeTable(common, i, h2, slot_size);
  466|    315|      continue;
  467|    315|    }
  468|       |
  469|     13|    void* new_slot_ptr = SlotAddress(slot_array, new_i, slot_size);
  470|     13|    if (IsEmpty(ctrl[new_i])) {
  ------------------
  |  Branch (470:9): [True: 10, False: 3]
  ------------------
  471|       |      // Transfer element to the empty spot.
  472|       |      // SetCtrl poisons/unpoisons the slots so we have to call it at the
  473|       |      // right time.
  474|     10|      SetCtrlInLargeTable(common, new_i, h2, slot_size);
  475|     10|      (*transfer_n)(set, new_slot_ptr, slot_ptr, 1);
  476|     10|      SetCtrlInLargeTable(common, i, ctrl_t::kEmpty, slot_size);
  477|       |      // Initialize or change empty space id.
  478|     10|      tmp_space_id = i;
  479|     10|    } else {
  480|      3|      ABSL_SWISSTABLE_ASSERT(IsDeleted(ctrl[new_i]));
  ------------------
  |  |   62|      3|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  481|      3|      SetCtrlInLargeTable(common, new_i, h2, slot_size);
  482|       |      // Until we are done rehashing, DELETED marks previously FULL slots.
  483|       |
  484|      3|      if (tmp_space_id == kUnknownId) {
  ------------------
  |  Branch (484:11): [True: 1, False: 2]
  ------------------
  485|      1|        tmp_space_id = FindEmptySlot(i + 1, capacity, ctrl);
  486|      1|      }
  487|      3|      void* tmp_space = SlotAddress(slot_array, tmp_space_id, slot_size);
  488|      3|      SanitizerUnpoisonMemoryRegion(tmp_space, slot_size);
  489|       |
  490|       |      // Swap i and new_i elements.
  491|      3|      (*transfer_n)(set, tmp_space, new_slot_ptr, 1);
  492|      3|      (*transfer_n)(set, new_slot_ptr, slot_ptr, 1);
  493|      3|      (*transfer_n)(set, slot_ptr, tmp_space, 1);
  494|       |
  495|      3|      SanitizerPoisonMemoryRegion(tmp_space, slot_size);
  496|       |
  497|       |      // repeat the processing of the ith slot
  498|      3|      --i;
  499|      3|      slot_ptr = PrevSlot(slot_ptr, slot_size);
  500|      3|    }
  501|     13|  }
  502|       |  // Prepare insert for the new element.
  503|     11|  PrepareInsertCommon(common);
  504|     11|  ResetGrowthLeft(common);
  505|     11|  FindInfo find_info = find_first_non_full(common, new_hash);
  506|     11|  SetCtrlInLargeTable(common, find_info.offset, H2(new_hash), slot_size);
  507|     11|  common.infoz().RecordInsertMiss(new_hash, find_info.probe_length);
  508|     11|  common.infoz().RecordRehash(total_probe_length);
  509|     11|  return find_info.offset;
  510|     11|}
raw_hash_set.cc:_ZZN4absl12lts_2026010718container_internal12_GLOBAL__N_140DropDeletesWithoutResizeAndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmENK3$_0clEm:
  459|    656|    const auto probe_index = [probe_offset, capacity](size_t pos) {
  460|    656|      return ((pos - probe_offset) & capacity) / Group::kWidth;
  461|    656|    };
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_113FindEmptySlotEmmPKNS1_6ctrl_tE:
  313|      1|size_t FindEmptySlot(size_t start, size_t end, const ctrl_t* ctrl) {
  314|      4|  for (size_t i = start; i < end; ++i) {
  ------------------
  |  Branch (314:26): [True: 4, False: 0]
  ------------------
  315|      4|    if (IsEmpty(ctrl[i])) {
  ------------------
  |  Branch (315:9): [True: 1, False: 3]
  ------------------
  316|      1|      return i;
  317|      1|    }
  318|      4|  }
  319|      0|  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]
  |  |  ------------------
  ------------------
  320|      0|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_18PrevSlotEPvm:
  129|  10.4k|inline void* PrevSlot(void* slot, size_t slot_size) {
  130|  10.4k|  return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(slot) - slot_size);
  131|  10.4k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119find_first_non_fullERKNS1_12CommonFieldsEm:
  203|   153k|FindInfo find_first_non_full(const CommonFields& common, size_t hash) {
  204|   153k|  return find_first_non_full_from_h1(common.control(), H1(hash),
  205|   153k|                                     common.capacity());
  206|   153k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_119SetCtrlInLargeTableERKNS1_12CommonFieldsEmhm:
  398|   181k|                                size_t slot_size) {
  399|   181k|  SetCtrlInLargeTable(c, i, static_cast<ctrl_t>(h), slot_size);
  400|   181k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_124IterateOverFullSlotsImplINS0_11FunctionRefIFvPKNS1_6ctrl_tEPvEEEEEvRKNS1_12CommonFieldsEmT_:
  233|  37.9k|void IterateOverFullSlotsImpl(const CommonFields& c, size_t slot_size, Fn cb) {
  234|  37.9k|  const size_t cap = c.capacity();
  235|  37.9k|  ABSL_SWISSTABLE_ASSERT(!IsSmallCapacity(cap));
  ------------------
  |  |   62|  37.9k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  236|  37.9k|  const ctrl_t* ctrl = c.control();
  237|  37.9k|  void* slot = c.slot_array();
  238|  37.9k|  if (is_half_group(cap)) {
  ------------------
  |  Branch (238:7): [True: 10.4k, False: 27.5k]
  ------------------
  239|       |    // Mirrored/cloned control bytes in half-group table are also located in the
  240|       |    // first group (starting from position 0). We are taking group from position
  241|       |    // `capacity` in order to avoid duplicates.
  242|       |
  243|       |    // Half-group tables capacity fits into portable group, where
  244|       |    // GroupPortableImpl::MaskFull is more efficient for the
  245|       |    // capacity <= GroupPortableImpl::kWidth.
  246|  10.4k|    ABSL_SWISSTABLE_ASSERT(cap <= GroupPortableImpl::kWidth &&
  ------------------
  |  |   62|  10.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  247|  10.4k|                           "unexpectedly large half-group capacity");
  248|  10.4k|    static_assert(Group::kWidth >= GroupPortableImpl::kWidth,
  249|  10.4k|                  "unexpected group width");
  250|       |    // Group starts from kSentinel slot, so indices in the mask will
  251|       |    // be increased by 1.
  252|  10.4k|    const auto mask = GroupPortableImpl(ctrl + cap).MaskFull();
  253|  10.4k|    --ctrl;
  254|  10.4k|    slot = PrevSlot(slot, slot_size);
  255|  39.3k|    for (uint32_t i : mask) {
  ------------------
  |  Branch (255:21): [True: 39.3k, False: 10.4k]
  ------------------
  256|  39.3k|      cb(ctrl + i, SlotAddress(slot, i, slot_size));
  257|  39.3k|    }
  258|  10.4k|    return;
  259|  10.4k|  }
  260|  27.5k|  size_t remaining = c.size();
  261|  27.5k|  ABSL_ATTRIBUTE_UNUSED const size_t original_size_for_assert = remaining;
  ------------------
  |  |  563|  27.5k|#define ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))
  ------------------
  262|   309k|  while (remaining != 0) {
  ------------------
  |  Branch (262:10): [True: 281k, False: 27.5k]
  ------------------
  263|  2.76M|    for (uint32_t i : GroupFullEmptyOrDeleted(ctrl).MaskFull()) {
  ------------------
  |  Branch (263:21): [True: 2.76M, False: 281k]
  ------------------
  264|  2.76M|      ABSL_SWISSTABLE_ASSERT(IsFull(ctrl[i]) &&
  ------------------
  |  |   62|  2.76M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  265|  2.76M|                             "hash table was modified unexpectedly");
  266|  2.76M|      cb(ctrl + i, SlotAddress(slot, i, slot_size));
  267|  2.76M|      --remaining;
  268|  2.76M|    }
  269|   281k|    ctrl += Group::kWidth;
  270|   281k|    slot = NextSlot(slot, slot_size, Group::kWidth);
  271|   281k|    ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |   62|   281k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  272|   281k|        (remaining == 0 || *(ctrl - 1) != ctrl_t::kSentinel) &&
  273|   281k|        "hash table was modified unexpectedly");
  274|   281k|  }
  275|       |  // NOTE: erasure of the current element is allowed in callback for
  276|       |  // absl::erase_if specialization. So we use `>=`.
  277|       |  ABSL_SWISSTABLE_ASSERT(original_size_for_assert >= c.size() &&
  ------------------
  |  |   62|  27.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  278|  27.5k|                         "hash table was modified unexpectedly");
  279|  27.5k|}
raw_hash_set.cc:_ZN4absl12lts_2026010718container_internal12_GLOBAL__N_113is_half_groupEm:
  228|  37.9k|constexpr bool is_half_group(size_t capacity) {
  229|  37.9k|  return capacity < Group::kWidth - 1;
  230|  37.9k|}

_ZN4absl12lts_2026010718container_internal13HashtableSize14increment_sizeEv:
  477|  3.90M|  void increment_size() { data_ += kSizeOneNoMetadata; }
_ZNK4absl12lts_2026010718container_internal13HashtableSize5emptyEv:
  483|  37.8k|  bool empty() const { return data_ < kSizeOneNoMetadata; }
_ZN4absl12lts_2026010718container_internal13HashtableSize30set_size_to_zero_keep_metadataEv:
  485|  3.66k|  void set_size_to_zero_keep_metadata() { data_ = data_ & kMetadataMask; }
_ZN4absl12lts_2026010718container_internal13HashtableSize17generate_new_seedEv:
  491|  56.2k|  void generate_new_seed() { set_seed(NextSeed()); }
_ZN4absl12lts_2026010718container_internal13HashtableSize8set_seedEt:
  515|  56.2k|  void set_seed(uint16_t seed) {
  516|  56.2k|    data_ = (data_ & ~kSeedMask) | (seed | PerTableSeed::kSignBit);
  517|  56.2k|  }
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled36maybe_increment_generation_on_insertEv:
  627|  3.90M|  void maybe_increment_generation_on_insert() {}
_ZNK4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled10generationEv:
  634|   247k|  GenerationType generation() const { return 0; }
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled14set_generationEh:
  635|   247k|  void set_generation(GenerationType) {}
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled18set_generation_ptrEPh:
  637|   247k|  void set_generation_ptr(GenerationType*) {}
_ZN4absl12lts_2026010718container_internal10GrowthInfo23InitGrowthLeftNoDeletedEm:
  703|   210k|  void InitGrowthLeftNoDeleted(size_t growth_left) {
  704|   210k|    growth_left_info_ = growth_left;
  705|   210k|  }
_ZN4absl12lts_2026010718container_internal10GrowthInfo20OverwriteFullAsEmptyEv:
  708|  47.1k|  void OverwriteFullAsEmpty() { ++growth_left_info_; }
_ZN4absl12lts_2026010718container_internal10GrowthInfo20OverwriteEmptyAsFullEv:
  711|  3.58M|  void OverwriteEmptyAsFull() {
  712|       |    ABSL_SWISSTABLE_ASSERT(GetGrowthLeft() > 0);
  ------------------
  |  |  248|  3.58M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  713|  3.58M|    --growth_left_info_;
  714|  3.58M|  }
_ZN4absl12lts_2026010718container_internal10GrowthInfo22OverwriteControlAsFullENS1_6ctrl_tE:
  723|  81.8k|  void OverwriteControlAsFull(ctrl_t ctrl) {
  724|       |    ABSL_SWISSTABLE_ASSERT(GetGrowthLeft() >=
  ------------------
  |  |  248|  81.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  725|  81.8k|                           static_cast<size_t>(IsEmpty(ctrl)));
  726|  81.8k|    growth_left_info_ -= static_cast<size_t>(IsEmpty(ctrl));
  727|  81.8k|  }
_ZN4absl12lts_2026010718container_internal10GrowthInfo22OverwriteFullAsDeletedEv:
  730|  9.71k|  void OverwriteFullAsDeleted() { growth_left_info_ |= kDeletedBit; }
_ZNK4absl12lts_2026010718container_internal10GrowthInfo25HasNoDeletedAndGrowthLeftEv:
  735|  3.81M|  bool HasNoDeletedAndGrowthLeft() const {
  736|  3.81M|    return static_cast<std::make_signed_t<size_t>>(growth_left_info_) > 0;
  737|  3.81M|  }
_ZNK4absl12lts_2026010718container_internal10GrowthInfo27HasNoGrowthLeftAndNoDeletedEv:
  742|   232k|  bool HasNoGrowthLeftAndNoDeleted() const { return growth_left_info_ == 0; }
_ZNK4absl12lts_2026010718container_internal10GrowthInfo37HasNoGrowthLeftAssumingMayHaveDeletedEv:
  746|  82.7k|  bool HasNoGrowthLeftAssumingMayHaveDeleted() const {
  747|       |    ABSL_SWISSTABLE_ASSERT(!HasNoDeleted());
  ------------------
  |  |  248|  82.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  748|  82.7k|    return growth_left_info_ == kDeletedBit;
  749|  82.7k|  }
_ZN4absl12lts_2026010718container_internal16RawHashSetLayoutC2Emmmb:
  809|   495k|      : control_offset_(ControlOffset(has_infoz)),
  810|   495k|        generation_offset_(control_offset_ + NumControlBytes(capacity)),
  811|       |        slot_offset_(
  812|   495k|            AlignUpTo(generation_offset_ + NumGenerationBytes(), slot_align)),
  813|   495k|        alloc_size_(slot_offset_ + capacity * slot_size) {
  814|   495k|    ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |  248|   495k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  815|       |    ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |  248|   495k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  816|   495k|        slot_size <=
  817|   495k|        ((std::numeric_limits<size_t>::max)() - slot_offset_) / capacity);
  818|   495k|  }
_ZNK4absl12lts_2026010718container_internal16RawHashSetLayout14control_offsetEv:
  822|   495k|  size_t control_offset() const { return control_offset_; }
_ZNK4absl12lts_2026010718container_internal16RawHashSetLayout17generation_offsetEv:
  826|   247k|  size_t generation_offset() const { return generation_offset_; }
_ZNK4absl12lts_2026010718container_internal16RawHashSetLayout11slot_offsetEv:
  830|   247k|  size_t slot_offset() const { return slot_offset_; }
_ZNK4absl12lts_2026010718container_internal16RawHashSetLayout10alloc_sizeEv:
  834|   742k|  size_t alloc_size() const { return alloc_size_; }
_ZN4absl12lts_2026010718container_internal9HeapOrSoo7controlEv:
  877|   247k|  MaybeInitializedPtr<ctrl_t>& control() {
  878|   247k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.control);
  ------------------
  |  |  488|   247k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  879|   247k|  }
_ZN4absl12lts_2026010718container_internal9HeapOrSoo10slot_arrayEv:
  883|   247k|  MaybeInitializedPtr<void>& slot_array() {
  884|   247k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.slot_array);
  ------------------
  |  |  488|   247k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  885|   247k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields11set_controlEPNS1_6ctrl_tE:
  960|   247k|  void set_control(ctrl_t* c) { heap_or_soo_.control().set(c); }
_ZN4absl12lts_2026010718container_internal12CommonFields9set_slotsEPv:
  967|   247k|  void set_slots(void* s) { heap_or_soo_.slot_array().set(s); }
_ZN4absl12lts_2026010718container_internal12CommonFields16set_size_to_zeroEv:
  972|  3.66k|  void set_size_to_zero() { size_.set_size_to_zero_keep_metadata(); }
_ZN4absl12lts_2026010718container_internal12CommonFields14increment_sizeEv:
  981|  3.90M|  void increment_size() {
  982|       |    ABSL_SWISSTABLE_ASSERT(size() < capacity());
  ------------------
  |  |  248|  3.90M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  983|  3.90M|    size_.increment_size();
  984|  3.90M|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields5emptyEv:
  993|  37.8k|  bool empty() const { return size_.empty(); }
_ZN4absl12lts_2026010718container_internal12CommonFields17generate_new_seedEb:
 1000|  56.2k|  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|  56.2k|    if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  189|  56.2k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 56.2k]
  |  |  |  Branch (189:49): [Folded, False: 56.2k]
  |  |  |  Branch (189:58): [True: 0, False: 56.2k]
  |  |  ------------------
  ------------------
 1004|      0|      size_.set_sampled_seed();
 1005|      0|      return;
 1006|      0|    }
 1007|  56.2k|    size_.generate_new_seed();
 1008|  56.2k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields12set_capacityEm:
 1013|   247k|  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|   247k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1016|   247k|                           c > kAboveMaxValidCapacity);
 1017|   247k|    capacity_ = c;
 1018|   247k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields11growth_infoEv:
 1027|  7.77M|  GrowthInfo& growth_info() {
 1028|       |    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  7.77M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1029|  7.77M|    return GetGrowthInfoFromControl(control());
 1030|  7.77M|  }
_ZN4absl12lts_2026010718container_internal24MaxValidSizeFor1ByteSlotILm8EEEmv:
 1570|  6.79k|constexpr size_t MaxValidSizeFor1ByteSlot() {
 1571|  6.79k|  if constexpr (kSizeOfSizeT == 8) {
 1572|  6.79k|    return CapacityToGrowth(
 1573|  6.79k|        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.79k|}
_ZN4absl12lts_2026010718container_internal23SentinelEmptyGenerationEv:
  256|   247k|constexpr GenerationType SentinelEmptyGeneration() { return 0; }
_ZN4absl12lts_2026010718container_internal14NextGenerationEh:
  258|   247k|constexpr GenerationType NextGeneration(GenerationType generation) {
  259|   247k|  return ++generation == SentinelEmptyGeneration() ? ++generation : generation;
  ------------------
  |  Branch (259:10): [True: 0, False: 247k]
  ------------------
  260|   247k|}
_ZN4absl12lts_2026010718container_internal18NumGenerationBytesEv:
  267|   495k|constexpr size_t NumGenerationBytes() { return 0; }
_ZN4absl12lts_2026010718container_internal9AlignUpToEmm:
  797|   495k|constexpr size_t AlignUpTo(size_t offset, size_t align) {
  798|   495k|  return (offset + align - 1) & (~align + 1);
  799|   495k|}
_ZN4absl12lts_2026010718container_internal24GetGrowthInfoFromControlEPNS1_6ctrl_tE:
  902|  7.98M|inline GrowthInfo& GetGrowthInfoFromControl(ctrl_t* control) {
  903|  7.98M|  auto* gl_ptr = reinterpret_cast<GrowthInfo*>(control) - 1;
  904|       |  ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |  248|  7.98M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  905|  7.98M|      reinterpret_cast<uintptr_t>(gl_ptr) % alignof(GrowthInfo) == 0);
  906|  7.98M|  return *gl_ptr;
  907|  7.98M|}
_ZN4absl12lts_2026010718container_internal12NextCapacityEm:
 1145|   150k|constexpr size_t NextCapacity(size_t n) {
 1146|       |  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(n) || n == 0);
  ------------------
  |  |  248|   150k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1147|   150k|  return n * 2 + 1;
 1148|   150k|}
_ZN4absl12lts_2026010718container_internal17NormalizeCapacityEm:
 1167|  6.79k|constexpr size_t NormalizeCapacity(size_t n) {
 1168|  6.79k|  return n ? ~size_t{} >> countl_zero(n) : 1;
  ------------------
  |  Branch (1168:10): [True: 6.79k, False: 0]
  ------------------
 1169|  6.79k|}
_ZN4absl12lts_2026010718container_internal16CapacityToGrowthEm:
 1181|   174k|constexpr size_t CapacityToGrowth(size_t capacity) {
 1182|   174k|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |  248|   174k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1183|       |  // `capacity*7/8`
 1184|   174k|  if (Group::kWidth == 8 && capacity == 7) {
  ------------------
  |  Branch (1184:7): [Folded, False: 174k]
  |  Branch (1184:29): [True: 0, False: 0]
  ------------------
 1185|       |    // x-x/8 does not work when x==7.
 1186|      0|    return 6;
 1187|      0|  }
 1188|   174k|  return capacity - capacity / 8;
 1189|   174k|}
_ZN4absl12lts_2026010718container_internal15is_single_groupEm:
 1393|   207k|constexpr bool is_single_group(size_t capacity) {
 1394|   207k|  return capacity <= Group::kWidth;
 1395|   207k|}
_ZN4absl12lts_2026010718container_internal12SooSlotIndexEv:
 1618|  61.2k|constexpr size_t SooSlotIndex() { return 1; }
_ZN4absl12lts_2026010718container_internal19MaybeInitializedPtrINS1_6ctrl_tEE3setEPS3_:
  850|   247k|  void set(T* ptr) { p = ptr; }
_ZN4absl12lts_2026010718container_internal19MaybeInitializedPtrIvE3setEPv:
  850|   247k|  void set(T* ptr) { p = ptr; }
_ZN4absl12lts_2026010718container_internal20AllocateBackingArrayILm8ENSt3__19allocatorIcEEEEPvS6_m:
 1495|   247k|void* AllocateBackingArray(void* alloc, size_t n) {
 1496|   247k|  return Allocate<AlignOfBackingArray>(static_cast<Alloc*>(alloc), n);
 1497|   247k|}
_ZN4absl12lts_2026010718container_internal22DeallocateBackingArrayILm8ENSt3__19allocatorIcEEEEvPvmPNS1_6ctrl_tEmmb:
 1504|   247k|    size_t slot_align, bool had_infoz) {
 1505|   247k|  RawHashSetLayout layout(capacity, slot_size, slot_align, had_infoz);
 1506|   247k|  void* backing_array = ctrl - layout.control_offset();
 1507|       |  // Unpoison before returning the memory to the allocator.
 1508|   247k|  SanitizerUnpoisonMemoryRegion(backing_array, layout.alloc_size());
 1509|   247k|  Deallocate<AlignOfBackingArray>(static_cast<Alloc*>(alloc), backing_array,
 1510|   247k|                                  layout.alloc_size());
 1511|   247k|}
_ZN4absl12lts_2026010718container_internal16IsAboveValidSizeILm8EEEbmm:
 1599|  6.79k|constexpr bool IsAboveValidSize(size_t size, size_t slot_size) {
 1600|  6.79k|  if constexpr (kSizeOfSizeT == 8) {
 1601|       |    // For small slot sizes we are limited by HashtableSize::kSizeBitCount.
 1602|  6.79k|    if (ABSL_PREDICT_TRUE(slot_size <
  ------------------
  |  |  190|  6.79k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 6.79k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 6.79k]
  |  |  |  Branch (190:57): [True: 6.79k, False: 0]
  |  |  ------------------
  ------------------
 1603|  6.79k|                          (size_t{1} << (64 - HashtableSize::kSizeBitCount)))) {
 1604|  6.79k|      return size > MaxValidSizeFor1ByteSlot<kSizeOfSizeT>();
 1605|  6.79k|    }
 1606|      0|    return size > MaxValidSize<kSizeOfSizeT>(slot_size);
 1607|       |  } else {
 1608|       |    return uint64_t{size} * slot_size >
 1609|       |           MaxValidSizeFor1ByteSlot<kSizeOfSizeT>();
 1610|       |  }
 1611|  6.79k|}

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

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

_ZN4absl12lts_2026010713hash_internal43CombineLargeContiguousImplOn64BitLengthGt32EmPKhm:
  299|   361k|                                                     size_t len) {
  300|   361k|  assert(len > 32);
  301|   361k|  assert(sizeof(size_t) == 8);  // NOLINT(misc-static-assert)
  302|   361k|  if (ABSL_PREDICT_TRUE(len <= PiecewiseChunkSize())) {
  ------------------
  |  |  190|   361k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 361k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 361k]
  |  |  |  Branch (190:57): [True: 361k, False: 0]
  |  |  ------------------
  ------------------
  303|   361k|    return HashBlockOn64Bit(state, first, len);
  304|   361k|  }
  305|      0|  return SplitAndCombineOn64Bit(state, first, len);
  306|   361k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_116HashBlockOn64BitEmPKhm:
  258|   361k|    uint64_t state, const unsigned char* data, size_t len) {
  259|   361k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  260|   361k|  return LowLevelHashLenGt32(state, data, len);
  261|       |#else
  262|       |  return hash_internal::CityHash64WithSeed(reinterpret_cast<const char*>(data),
  263|       |                                           len, state);
  264|       |#endif
  265|   361k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_119LowLevelHashLenGt32EmPKvm:
  223|   361k|                                              size_t len) {
  224|   361k|  assert(len > 32);
  225|   361k|  if (ABSL_PREDICT_FALSE(len > 64)) {
  ------------------
  |  |  189|   361k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 103k, False: 257k]
  |  |  |  Branch (189:49): [Folded, False: 361k]
  |  |  |  Branch (189:58): [True: 103k, False: 257k]
  |  |  ------------------
  ------------------
  226|   103k|    return LowLevelHashLenGt64(seed, data, len);
  227|   103k|  }
  228|   257k|  return LowLevelHash33To64(seed, static_cast<const uint8_t*>(data), len);
  229|   361k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_119LowLevelHashLenGt64EmPKvm:
  173|   103k|LowLevelHashLenGt64(uint64_t seed, const void* data, size_t len) {
  174|   103k|  assert(len > 64);
  175|   103k|  const uint8_t* ptr = static_cast<const uint8_t*>(data);
  176|   103k|  uint64_t current_state = seed ^ kStaticRandomData[0] ^ len;
  177|   103k|  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|   103k|  uint64_t duplicated_state0 = current_state;
  182|   103k|  uint64_t duplicated_state1 = current_state;
  183|   103k|  uint64_t duplicated_state2 = current_state;
  184|       |
  185|   232k|  do {
  186|   232k|    PrefetchFutureDataToLocalCache(ptr);
  187|       |
  188|   232k|    uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
  189|   232k|    uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
  190|   232k|    uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
  191|   232k|    uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
  192|   232k|    uint64_t e = absl::base_internal::UnalignedLoad64(ptr + 32);
  193|   232k|    uint64_t f = absl::base_internal::UnalignedLoad64(ptr + 40);
  194|   232k|    uint64_t g = absl::base_internal::UnalignedLoad64(ptr + 48);
  195|   232k|    uint64_t h = absl::base_internal::UnalignedLoad64(ptr + 56);
  196|       |
  197|   232k|    current_state = Mix(a ^ kStaticRandomData[1], b ^ current_state);
  198|   232k|    duplicated_state0 = Mix(c ^ kStaticRandomData[2], d ^ duplicated_state0);
  199|       |
  200|   232k|    duplicated_state1 = Mix(e ^ kStaticRandomData[3], f ^ duplicated_state1);
  201|   232k|    duplicated_state2 = Mix(g ^ kStaticRandomData[4], h ^ duplicated_state2);
  202|       |
  203|   232k|    ptr += 64;
  204|   232k|    len -= 64;
  205|   232k|  } while (len > 64);
  ------------------
  |  Branch (205:12): [True: 129k, False: 103k]
  ------------------
  206|       |
  207|   103k|  current_state = (current_state ^ duplicated_state0) ^
  208|   103k|                  (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|   103k|  if (len > 32) {
  ------------------
  |  Branch (211:7): [True: 24.1k, False: 79.7k]
  ------------------
  212|  24.1k|    current_state = Mix32Bytes(ptr, current_state);
  213|  24.1k|  }
  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|   103k|  return Mix32Bytes(last_32_ptr, current_state);
  219|   103k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_130PrefetchFutureDataToLocalCacheEPKh:
   48|   232k|void PrefetchFutureDataToLocalCache(const uint8_t* ptr) {
   49|   232k|  PrefetchToLocalCache(ptr + 5 * ABSL_CACHELINE_SIZE);
  ------------------
  |  |   88|   232k|#define ABSL_CACHELINE_SIZE 64
  ------------------
   50|   232k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_110Mix32BytesEPKhm:
  153|   643k|uint64_t Mix32Bytes(const uint8_t* ptr, uint64_t current_state) {
  154|   643k|  uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
  155|   643k|  uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
  156|   643k|  uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
  157|   643k|  uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
  158|       |
  159|   643k|  uint64_t cs0 = Mix(a ^ kStaticRandomData[1], b ^ current_state);
  160|   643k|  uint64_t cs1 = Mix(c ^ kStaticRandomData[2], d ^ current_state);
  161|   643k|  return cs0 ^ cs1;
  162|   643k|}
hash.cc:_ZN4absl12lts_2026010713hash_internal12_GLOBAL__N_118LowLevelHash33To64EmPKhm:
  164|   257k|uint64_t LowLevelHash33To64(uint64_t seed, const uint8_t* ptr, size_t len) {
  165|   257k|  assert(len > 32);
  166|       |  assert(len <= 64);
  167|   257k|  uint64_t current_state = seed ^ kStaticRandomData[0] ^ len;
  168|   257k|  const uint8_t* last_32_ptr = ptr + len - 32;
  169|   257k|  return Mix32Bytes(last_32_ptr, Mix32Bytes(ptr, current_state));
  170|   257k|}

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

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

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

_ZN4absl12lts_2026010712log_internal13IsInitializedEv:
   54|  1.23M|bool IsInitialized() {
   55|  1.23M|  return logging_initialized.load(std::memory_order_acquire);
   56|  1.23M|}
_ZN4absl12lts_2026010712log_internal13WriteToStderrENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS0_11LogSeverityE:
   62|   619k|void WriteToStderr(absl::string_view message, absl::LogSeverity severity) {
   63|   619k|  if (message.empty()) return;
  ------------------
  |  Branch (63:7): [True: 0, False: 619k]
  ------------------
   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|   619k|  std::fwrite(message.data(), message.size(), 1, stderr);
   80|   619k|#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|   619k|  (void)severity;
   94|   619k|#endif
   95|   619k|}
_ZN4absl12lts_2026010712log_internal8TimeZoneEv:
  109|   619k|const absl::TimeZone* TimeZone() {
  110|   619k|  return timezone_ptr.load(std::memory_order_acquire);
  111|   619k|}

_ZN4absl12lts_2026010712log_internal15FormatLogPrefixENS0_11LogSeverityENS0_4TimeEiNSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiNS1_12PrefixFormatERNS0_4SpanIcEE:
  194|   619k|                       int line, PrefixFormat format, absl::Span<char>& buf) {
  195|   619k|  auto prefix_size = FormatBoundedFields(severity, timestamp, tid, buf);
  196|   619k|  prefix_size += log_internal::AppendTruncated(basename, buf);
  197|   619k|  prefix_size += FormatLineNumber(line, buf);
  198|   619k|  if (format == PrefixFormat::kRaw)
  ------------------
  |  Branch (198:7): [True: 0, False: 619k]
  ------------------
  199|      0|    prefix_size += log_internal::AppendTruncated("RAW: ", buf);
  200|   619k|  return prefix_size;
  201|   619k|}
log_format.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_119FormatBoundedFieldsENS0_11LogSeverityENS0_4TimeEiRNS0_4SpanIcEE:
   78|   619k|                           log_internal::Tid tid, absl::Span<char>& buf) {
   79|   619k|  constexpr size_t kBoundedFieldsMaxLen =
   80|   619k|      sizeof("SMMDD HH:MM:SS.NNNNNN  ") +
   81|   619k|      (1 + std::numeric_limits<log_internal::Tid>::digits10 + 1) - sizeof("");
   82|   619k|  if (ABSL_PREDICT_FALSE(buf.size() < kBoundedFieldsMaxLen)) {
  ------------------
  |  |  189|   619k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 619k]
  |  |  |  Branch (189:49): [Folded, False: 619k]
  |  |  |  Branch (189:58): [True: 0, False: 619k]
  |  |  ------------------
  ------------------
   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|   619k|  const absl::TimeZone* tz = absl::log_internal::TimeZone();
   96|   619k|  if (ABSL_PREDICT_FALSE(tz == nullptr)) {
  ------------------
  |  |  189|   619k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 619k, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 619k]
  |  |  |  Branch (189:58): [True: 619k, 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|   619k|    auto tv = absl::ToTimeval(timestamp);
  102|   619k|    int snprintf_result = absl::SNPrintF(
  103|   619k|        buf.data(), buf.size(), "%c0000 00:00:%02d.%06d %7d ",
  104|   619k|        absl::LogSeverityName(severity)[0], static_cast<int>(tv.tv_sec),
  105|   619k|        static_cast<int>(tv.tv_usec), static_cast<int>(tid));
  106|   619k|    if (snprintf_result >= 0) {
  ------------------
  |  Branch (106:9): [True: 619k, False: 0]
  ------------------
  107|   619k|      buf.remove_prefix(static_cast<size_t>(snprintf_result));
  108|   619k|      return static_cast<size_t>(snprintf_result);
  109|   619k|    }
  110|      0|    return 0;
  111|   619k|  }
  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|   619k|}
log_format.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_116FormatLineNumberEiRNS0_4SpanIcEE:
  149|   619k|size_t FormatLineNumber(int line, absl::Span<char>& buf) {
  150|   619k|  constexpr size_t kLineFieldMaxLen =
  151|   619k|      sizeof(":] ") + (1 + std::numeric_limits<int>::digits10 + 1) - sizeof("");
  152|   619k|  if (ABSL_PREDICT_FALSE(buf.size() < kLineFieldMaxLen)) {
  ------------------
  |  |  189|   619k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 619k]
  |  |  |  Branch (189:49): [Folded, False: 619k]
  |  |  |  Branch (189:58): [True: 0, False: 619k]
  |  |  ------------------
  ------------------
  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|   619k|  char* p = buf.data();
  159|   619k|  *p++ = ':';
  160|   619k|  p = absl::numbers_internal::FastIntToBuffer(line, p);
  161|   619k|  *p++ = ']';
  162|   619k|  *p++ = ' ';
  163|   619k|  const size_t bytes_formatted = static_cast<size_t>(p - buf.data());
  164|   619k|  buf.remove_prefix(bytes_formatted);
  165|   619k|  return bytes_formatted;
  166|   619k|}

_ZN4absl12lts_2026010712log_internal10LogMessage19CopyToEncodedBufferILNS2_10StringTypeE0EEEvNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  608|   806k|void LogMessage::CopyToEncodedBuffer(absl::string_view str) {
  609|   806k|  auto encoded_remaining_copy = data_->encoded_remaining();
  610|   806k|  constexpr uint8_t tag_value = str_type == StringType::kLiteral
  ------------------
  |  Branch (610:33): [True: 0, Folded]
  ------------------
  611|   806k|                                    ? ValueTag::kStringLiteral
  612|   806k|                                    : ValueTag::kString;
  613|   806k|  auto start = EncodeMessageStart(
  614|   806k|      EventTag::kValue,
  615|   806k|      BufferSizeFor(tag_value, WireType::kLengthDelimited) + str.size(),
  616|   806k|      &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|   806k|  if (EncodeStringTruncate(tag_value, str, &encoded_remaining_copy)) {
  ------------------
  |  Branch (620:7): [True: 806k, False: 0]
  ------------------
  621|       |    // The string may have been truncated, but the field header fit.
  622|   806k|    EncodeMessageLength(start, &encoded_remaining_copy);
  623|   806k|    data_->encoded_remaining() = encoded_remaining_copy;
  624|   806k|  } 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|   806k|}
_ZN4absl12lts_2026010712log_internal10LogMessage19CopyToEncodedBufferILNS2_10StringTypeE1EEEvNSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  608|  64.8k|void LogMessage::CopyToEncodedBuffer(absl::string_view str) {
  609|  64.8k|  auto encoded_remaining_copy = data_->encoded_remaining();
  610|  64.8k|  constexpr uint8_t tag_value = str_type == StringType::kLiteral
  ------------------
  |  Branch (610:33): [Folded, False: 64.8k]
  ------------------
  611|  64.8k|                                    ? ValueTag::kStringLiteral
  612|  64.8k|                                    : ValueTag::kString;
  613|  64.8k|  auto start = EncodeMessageStart(
  614|  64.8k|      EventTag::kValue,
  615|  64.8k|      BufferSizeFor(tag_value, WireType::kLengthDelimited) + str.size(),
  616|  64.8k|      &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|  64.8k|  if (EncodeStringTruncate(tag_value, str, &encoded_remaining_copy)) {
  ------------------
  |  Branch (620:7): [True: 64.8k, False: 0]
  ------------------
  621|       |    // The string may have been truncated, but the field header fit.
  622|  64.8k|    EncodeMessageLength(start, &encoded_remaining_copy);
  623|  64.8k|    data_->encoded_remaining() = encoded_remaining_copy;
  624|  64.8k|  } 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|  64.8k|}
_ZN4absl12lts_2026010712log_internal10LogMessage14LogMessageDataC2ENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiNS0_11LogSeverityENS0_4TimeE:
  208|   619k|    : extra_sinks_only(false), manipulated(nullptr) {
  209|       |  // Legacy defaults for LOG's ostream:
  210|   619k|  manipulated.setf(std::ios_base::showbase | std::ios_base::boolalpha);
  211|   619k|  entry.full_filename_ = file;
  212|   619k|  entry.base_filename_ = Basename(file);
  213|   619k|  entry.line_ = line;
  214|   619k|  entry.prefix_ = absl::ShouldPrependLogPrefix();
  215|   619k|  entry.severity_ = absl::NormalizeLogSeverity(severity);
  216|   619k|  entry.verbose_level_ = absl::LogEntry::kNoVerbosityLevel;
  217|   619k|  entry.timestamp_ = timestamp;
  218|   619k|  entry.tid_ = absl::base_internal::GetCachedTID();
  219|   619k|}
_ZN4absl12lts_2026010712log_internal10LogMessage14LogMessageData27InitializeEncodingAndFormatEv:
  221|   619k|void LogMessage::LogMessageData::InitializeEncodingAndFormat() {
  222|   619k|  EncodeStringTruncate(EventTag::kFileName, entry.source_filename(),
  223|   619k|                       &encoded_remaining());
  224|   619k|  EncodeVarint(EventTag::kFileLine, entry.source_line(), &encoded_remaining());
  225|   619k|  EncodeVarint(EventTag::kTimeNsecs, absl::ToUnixNanos(entry.timestamp()),
  226|   619k|               &encoded_remaining());
  227|   619k|  EncodeVarint(EventTag::kSeverity,
  228|   619k|               ProtoSeverity(entry.log_severity(), entry.verbosity()),
  229|   619k|               &encoded_remaining());
  230|   619k|  EncodeVarint(EventTag::kThreadId, entry.tid(), &encoded_remaining());
  231|   619k|}
_ZN4absl12lts_2026010712log_internal10LogMessage14LogMessageData25FinalizeEncodingAndFormatEv:
  233|   619k|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|   619k|  absl::Span<const char> encoded_data(
  238|   619k|      encoded_buf.data(),
  239|   619k|      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|   619k|  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|   619k|  string_remaining.remove_suffix(2);
  248|   619k|  entry.prefix_len_ =
  249|   619k|      entry.prefix() ? log_internal::FormatLogPrefix(
  ------------------
  |  Branch (249:7): [True: 619k, False: 0]
  ------------------
  250|   619k|                           entry.log_severity(), entry.timestamp(), entry.tid(),
  251|   619k|                           entry.source_basename(), entry.source_line(),
  252|   619k|                           log_internal::ThreadIsLoggingToLogSink()
  ------------------
  |  Branch (252:28): [True: 0, False: 619k]
  ------------------
  253|   619k|                               ? PrefixFormat::kRaw
  254|   619k|                               : PrefixFormat::kNotRaw,
  255|   619k|                           string_remaining)
  256|   619k|                     : 0;
  257|       |  // Decode data from `encoded_buf` until we run out of data or we run out of
  258|       |  // `string_remaining`.
  259|   619k|  ProtoField field;
  260|  4.87M|  while (field.DecodeFrom(&encoded_data)) {
  ------------------
  |  Branch (260:10): [True: 4.25M, False: 619k]
  ------------------
  261|  4.25M|    switch (field.tag()) {
  ------------------
  |  Branch (261:13): [True: 1.15M, False: 3.09M]
  ------------------
  262|  1.15M|      case EventTag::kValue:
  ------------------
  |  Branch (262:7): [True: 1.15M, False: 3.09M]
  ------------------
  263|  1.15M|        if (field.type() != WireType::kLengthDelimited) continue;
  ------------------
  |  Branch (263:13): [True: 0, False: 1.15M]
  ------------------
  264|  1.15M|        if (PrintValue(string_remaining, field.bytes_value())) continue;
  ------------------
  |  Branch (264:13): [True: 1.15M, False: 0]
  ------------------
  265|      0|        break;
  266|  4.25M|    }
  267|  4.25M|  }
  268|   619k|  auto chars_written =
  269|   619k|      static_cast<size_t>(string_remaining.data() - string_buf.data());
  270|   619k|    string_buf[chars_written++] = '\n';
  271|   619k|  string_buf[chars_written++] = '\0';
  272|   619k|  entry.text_message_with_prefix_and_newline_and_nul_ =
  273|   619k|      absl::MakeSpan(string_buf).subspan(0, chars_written);
  274|   619k|}
_ZN4absl12lts_2026010712log_internal10LogMessageC2EPKciNS0_11LogSeverityE:
  278|   619k|  : LogMessage(absl::string_view(file), line, severity) {}
_ZN4absl12lts_2026010712log_internal10LogMessageC2ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiNS0_11LogSeverityE:
  281|   619k|    : data_(absl::make_unique<LogMessageData>(file, line, severity,
  282|   619k|                                              absl::Now())) {
  283|   619k|  data_->first_fatal = false;
  284|   619k|  data_->is_perror = false;
  285|   619k|  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|   619k|  LogBacktraceIfNeeded();
  291|   619k|}
_ZN4absl12lts_2026010712log_internal10LogMessageC2EPKciNS2_7InfoTagE:
  294|   619k|    : LogMessage(file, line, absl::LogSeverity::kInfo) {}
_ZN4absl12lts_2026010712log_internal10LogMessageC2EPKciNS2_10WarningTagE:
  296|    685|    : LogMessage(file, line, absl::LogSeverity::kWarning) {}
_ZN4absl12lts_2026010712log_internal10LogMessageD2Ev:
  301|   619k|LogMessage::~LogMessage() = default;
_ZN4absl12lts_2026010712log_internal10LogMessagelsERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  403|  64.8k|LogMessage& LogMessage::operator<<(const std::string& v) {
  404|  64.8k|  CopyToEncodedBuffer<StringType::kNotLiteral>(v);
  405|  64.8k|  return *this;
  406|  64.8k|}
_ZN4absl12lts_2026010712log_internal10LogMessage5FlushEv:
  471|   619k|void LogMessage::Flush() {
  472|   619k|  if (data_->entry.log_severity() < absl::MinLogLevel()) return;
  ------------------
  |  Branch (472:7): [True: 0, False: 619k]
  ------------------
  473|       |
  474|   619k|  if (data_->is_perror) {
  ------------------
  |  Branch (474:7): [True: 0, False: 619k]
  ------------------
  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|   619k|  ABSL_CONST_INIT static std::atomic<bool> seen_fatal(false);
  ------------------
  |  |  760|   619k|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
  481|   619k|  if (data_->entry.log_severity() == absl::LogSeverity::kFatal &&
  ------------------
  |  Branch (481:7): [True: 0, False: 619k]
  ------------------
  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|   619k|  data_->FinalizeEncodingAndFormat();
  493|   619k|  data_->entry.encoding_ =
  494|   619k|      absl::string_view(data_->encoded_buf.data(),
  495|   619k|                        static_cast<size_t>(data_->encoded_remaining().data() -
  496|   619k|                                            data_->encoded_buf.data()));
  497|   619k|  SendToLog();
  498|   619k|}
_ZN4absl12lts_2026010712log_internal10LogMessage11OstreamViewC2ERNS2_14LogMessageDataE:
  503|   285k|    : 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|   285k|  message_start_ =
  511|   285k|      EncodeMessageStart(EventTag::kValue, encoded_remaining_copy_.size(),
  512|   285k|                         &encoded_remaining_copy_);
  513|   285k|  string_start_ =
  514|   285k|      EncodeMessageStart(ValueTag::kString, encoded_remaining_copy_.size(),
  515|   285k|                         &encoded_remaining_copy_);
  516|   285k|  setp(encoded_remaining_copy_.data(),
  517|   285k|       encoded_remaining_copy_.data() + encoded_remaining_copy_.size());
  518|   285k|  data_.manipulated.rdbuf(this);
  519|   285k|}
_ZN4absl12lts_2026010712log_internal10LogMessage11OstreamViewD2Ev:
  521|   285k|LogMessage::OstreamView::~OstreamView() {
  522|   285k|  data_.manipulated.rdbuf(nullptr);
  523|   285k|  if (!string_start_.data()) {
  ------------------
  |  Branch (523:7): [True: 0, False: 285k]
  ------------------
  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|   285k|  const absl::Span<const char> contents(pbase(),
  531|   285k|                                        static_cast<size_t>(pptr() - pbase()));
  532|   285k|  if (contents.empty()) return;
  ------------------
  |  Branch (532:7): [True: 0, False: 285k]
  ------------------
  533|   285k|  encoded_remaining_copy_.remove_prefix(contents.size());
  534|   285k|  EncodeMessageLength(string_start_, &encoded_remaining_copy_);
  535|   285k|  EncodeMessageLength(message_start_, &encoded_remaining_copy_);
  536|   285k|  data_.encoded_remaining() = encoded_remaining_copy_;
  537|   285k|}
_ZN4absl12lts_2026010712log_internal10LogMessage11OstreamView6streamEv:
  539|   285k|std::ostream& LogMessage::OstreamView::stream() { return data_.manipulated; }
_ZNK4absl12lts_2026010712log_internal10LogMessage7IsFatalEv:
  541|  1.23M|bool LogMessage::IsFatal() const {
  542|  1.23M|  return data_->entry.log_severity() == absl::LogSeverity::kFatal &&
  ------------------
  |  Branch (542:10): [True: 0, False: 1.23M]
  ------------------
  543|      0|         absl::log_internal::ExitOnDFatal();
  ------------------
  |  Branch (543:10): [True: 0, False: 0]
  ------------------
  544|  1.23M|}
_ZN4absl12lts_2026010712log_internal10LogMessage9SendToLogEv:
  580|   619k|void LogMessage::SendToLog() {
  581|   619k|  if (IsFatal()) PrepareToDie();
  ------------------
  |  Branch (581:7): [True: 0, False: 619k]
  ------------------
  582|       |  // Also log to all registered sinks, even if OnlyLogToStderr() is set.
  583|   619k|  log_internal::LogToSinks(data_->entry, absl::MakeSpan(data_->extra_sinks),
  584|   619k|                           data_->extra_sinks_only);
  585|   619k|  if (IsFatal()) Die();
  ------------------
  |  Branch (585:7): [True: 0, False: 619k]
  ------------------
  586|   619k|}
_ZN4absl12lts_2026010712log_internal10LogMessage20LogBacktraceIfNeededEv:
  588|   619k|void LogMessage::LogBacktraceIfNeeded() {
  589|   619k|  if (!absl::log_internal::IsInitialized()) return;
  ------------------
  |  Branch (589:7): [True: 619k, 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|  6.65M|  absl::Span<char>& encoded_remaining() {
  189|  6.65M|    if (encoded_remaining_actual_do_not_use_directly.data() == nullptr) {
  ------------------
  |  Branch (189:9): [True: 619k, False: 6.03M]
  ------------------
  190|   619k|      encoded_remaining_actual_do_not_use_directly =
  191|   619k|          absl::MakeSpan(encoded_buf);
  192|   619k|      InitializeEncodingAndFormat();
  193|   619k|    }
  194|  6.65M|    return encoded_remaining_actual_do_not_use_directly;
  195|  6.65M|  }
log_message.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_18BasenameENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  133|   619k|absl::string_view Basename(absl::string_view filepath) {
  134|       |#ifdef _WIN32
  135|       |  size_t path = filepath.find_last_of("/\\");
  136|       |#else
  137|   619k|  size_t path = filepath.find_last_of('/');
  138|   619k|#endif
  139|   619k|  if (path != filepath.npos) filepath.remove_prefix(path + 1);
  ------------------
  |  Branch (139:7): [True: 619k, False: 0]
  ------------------
  140|   619k|  return filepath;
  141|   619k|}
log_message.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_113ProtoSeverityENS0_11LogSeverityEi:
  117|   619k|int32_t ProtoSeverity(absl::LogSeverity severity, int verbose_level) {
  118|   619k|  switch (severity) {
  119|   619k|    case absl::LogSeverity::kInfo:
  ------------------
  |  Branch (119:5): [True: 619k, False: 685]
  ------------------
  120|   619k|      if (verbose_level == absl::LogEntry::kNoVerbosityLevel) return 800;
  ------------------
  |  Branch (120:11): [True: 619k, False: 0]
  ------------------
  121|      0|      return 600 - verbose_level;
  122|    685|    case absl::LogSeverity::kWarning:
  ------------------
  |  Branch (122:5): [True: 685, False: 619k]
  ------------------
  123|    685|      return 900;
  124|      0|    case absl::LogSeverity::kError:
  ------------------
  |  Branch (124:5): [True: 0, False: 619k]
  ------------------
  125|      0|      return 950;
  126|      0|    case absl::LogSeverity::kFatal:
  ------------------
  |  Branch (126:5): [True: 0, False: 619k]
  ------------------
  127|      0|      return 1100;
  128|      0|    default:
  ------------------
  |  Branch (128:5): [True: 0, False: 619k]
  ------------------
  129|      0|      return 800;
  130|   619k|  }
  131|   619k|}
log_message.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_110PrintValueERNS0_4SpanIcEENS3_IKcEE:
  100|  1.15M|bool PrintValue(absl::Span<char>& dst, absl::Span<const char> buf) {
  101|  1.15M|  if (dst.size() <= 1) return false;
  ------------------
  |  Branch (101:7): [True: 0, False: 1.15M]
  ------------------
  102|  1.15M|  ProtoField field;
  103|  2.31M|  while (field.DecodeFrom(&buf)) {
  ------------------
  |  Branch (103:10): [True: 1.15M, False: 1.15M]
  ------------------
  104|  1.15M|    switch (field.tag()) {
  ------------------
  |  Branch (104:13): [True: 1.15M, False: 0]
  ------------------
  105|   350k|      case ValueTag::kString:
  ------------------
  |  Branch (105:7): [True: 350k, False: 806k]
  ------------------
  106|  1.15M|      case ValueTag::kStringLiteral:
  ------------------
  |  Branch (106:7): [True: 806k, False: 350k]
  ------------------
  107|  1.15M|        if (field.type() == WireType::kLengthDelimited)
  ------------------
  |  Branch (107:13): [True: 1.15M, False: 0]
  ------------------
  108|  1.15M|          if (log_internal::AppendTruncated(field.string_value(), dst) <
  ------------------
  |  Branch (108:15): [True: 0, False: 1.15M]
  ------------------
  109|  1.15M|              field.string_value().size())
  110|      0|            return false;
  111|  1.15M|    }
  112|  1.15M|  }
  113|  1.15M|  return true;
  114|  1.15M|}

_ZN4absl12lts_2026010712log_internal10LogMessagelsIiEERS2_RKT_:
  337|  76.6k|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|  76.6k|  } else {
  343|  76.6k|    OstreamView view(*data_);
  344|  76.6k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  345|  76.6k|  }
  346|  76.6k|  return *this;
  347|  76.6k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsIlEERS2_RKT_:
  337|  45.0k|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|  45.0k|  } else {
  343|  45.0k|    OstreamView view(*data_);
  344|  45.0k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  345|  45.0k|  }
  346|  45.0k|  return *this;
  347|  45.0k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsImEERS2_RKT_:
  337|  71.6k|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|  71.6k|  } else {
  343|  71.6k|    OstreamView view(*data_);
  344|  71.6k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  345|  71.6k|  }
  346|  71.6k|  return *this;
  347|  71.6k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsIfEERS2_RKT_:
  337|  34.9k|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|  34.9k|  } else {
  343|  34.9k|    OstreamView view(*data_);
  344|  34.9k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  345|  34.9k|  }
  346|  34.9k|  return *this;
  347|  34.9k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsIdEERS2_RKT_:
  337|  47.5k|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|  47.5k|  } else {
  343|  47.5k|    OstreamView view(*data_);
  344|  47.5k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  345|  47.5k|  }
  346|  47.5k|  return *this;
  347|  47.5k|}

_ZN4absl12lts_2026010712log_internal24ThreadIsLoggingToLogSinkEv:
  277|  1.23M|bool ThreadIsLoggingToLogSink() { return ThreadIsLoggingStatus(); }
_ZN4absl12lts_2026010712log_internal10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEb:
  280|   619k|                absl::Span<absl::LogSink*> extra_sinks, bool extra_sinks_only) {
  281|   619k|  log_internal::GlobalSinks().LogToSinks(entry, extra_sinks, extra_sinks_only);
  282|   619k|}
log_sink_set.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_121ThreadIsLoggingStatusEv:
   58|  2.47M|bool& ThreadIsLoggingStatus() {
   59|  2.47M|#ifdef ABSL_HAVE_THREAD_LOCAL
   60|  2.47M|  ABSL_CONST_INIT thread_local bool thread_is_logging = false;
  ------------------
  |  |  760|  2.47M|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
   61|  2.47M|  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.47M|}
log_sink_set.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_111GlobalSinksEv:
  270|   619k|GlobalLogSinkSet& GlobalSinks() {
  271|   619k|  static absl::NoDestructor<GlobalLogSinkSet> global_sinks;
  272|   619k|  return *global_sinks;
  273|   619k|}
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|   619k|  void Send(const absl::LogEntry& entry) override {
   93|   619k|    if (entry.log_severity() < absl::StderrThreshold() &&
  ------------------
  |  Branch (93:9): [True: 619k, False: 0]
  ------------------
   94|   619k|        absl::log_internal::IsInitialized()) {
  ------------------
  |  Branch (94:9): [True: 0, False: 619k]
  ------------------
   95|      0|      return;
   96|      0|    }
   97|       |
   98|   619k|    ABSL_CONST_INIT static absl::once_flag warn_if_not_initialized;
  ------------------
  |  |  760|   619k|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
   99|   619k|    absl::call_once(warn_if_not_initialized, []() {
  100|   619k|      if (absl::log_internal::IsInitialized()) return;
  101|   619k|      const char w[] =
  102|   619k|          "WARNING: All log messages before absl::InitializeLog() is called"
  103|   619k|          " are written to STDERR\n";
  104|   619k|      absl::log_internal::WriteToStderr(w, absl::LogSeverity::kWarning);
  105|   619k|    });
  106|       |
  107|   619k|    if (!entry.stacktrace().empty()) {
  ------------------
  |  Branch (107:9): [True: 0, False: 619k]
  ------------------
  108|      0|      absl::log_internal::WriteToStderr(entry.stacktrace(),
  109|      0|                                        entry.log_severity());
  110|   619k|    } else {
  111|       |      // TODO(b/226937039): do this outside else condition once we avoid
  112|       |      // ReprintFatalMessage
  113|   619k|      absl::log_internal::WriteToStderr(
  114|   619k|          entry.text_message_with_prefix_and_newline(), entry.log_severity());
  115|   619k|    }
  116|   619k|  }
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|   619k|      ABSL_LOCKS_EXCLUDED(guard_) {
  188|   619k|    SendToSinks(entry, extra_sinks);
  189|       |
  190|   619k|    if (!extra_sinks_only) {
  ------------------
  |  Branch (190:9): [True: 619k, False: 0]
  ------------------
  191|   619k|      if (ThreadIsLoggingToLogSink()) {
  ------------------
  |  Branch (191:11): [True: 0, False: 619k]
  ------------------
  192|      0|        absl::log_internal::WriteToStderr(
  193|      0|            entry.text_message_with_prefix_and_newline(), entry.log_severity());
  194|   619k|      } else {
  195|   619k|        absl::ReaderMutexLock global_sinks_lock(guard_);
  196|   619k|        ThreadIsLoggingStatus() = true;
  197|       |        // Ensure the "thread is logging" status is reverted upon leaving the
  198|       |        // scope even in case of exceptions.
  199|   619k|        auto status_cleanup =
  200|   619k|            absl::MakeCleanup([] { ThreadIsLoggingStatus() = false; });
  201|   619k|        SendToSinks(entry, absl::MakeSpan(sinks_));
  202|   619k|      }
  203|   619k|    }
  204|   619k|  }
log_sink_set.cc:_ZN4absl12lts_2026010712log_internal12_GLOBAL__N_116GlobalLogSinkSet11SendToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEE:
  258|  1.23M|                          absl::Span<absl::LogSink*> sinks) {
  259|  1.23M|    for (absl::LogSink* sink : sinks) {
  ------------------
  |  Branch (259:30): [True: 619k, False: 1.23M]
  ------------------
  260|   619k|      sink->Send(entry);
  261|   619k|    }
  262|  1.23M|  }
log_sink_set.cc:_ZZN4absl12lts_2026010712log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbENKUlvE_clEv:
  200|   619k|            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_internal9NullGuardIfE5GuardERKf:
   45|  34.9k|  static const T& Guard(const T& v) { return v; }
_ZN4absl12lts_2026010712log_internal9NullGuardIdE5GuardERKd:
   45|  47.5k|  static const T& Guard(const T& v) { return v; }
_ZN4absl12lts_2026010712log_internal9NullGuardIiE5GuardERKi:
   45|  76.6k|  static const T& Guard(const T& v) { return v; }

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

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

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

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

_ZN4absl12lts_2026010711countl_zeroItEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  108|  47.7k|    countl_zero(T x) noexcept {
  109|  47.7k|  return numeric_internal::CountLeadingZeroes(x);
  110|  47.7k|}
_ZN4absl12lts_2026010711countr_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  123|  1.90M|    countr_zero(T x) noexcept {
  124|  1.90M|  return numeric_internal::CountTrailingZeroes(x);
  125|  1.90M|}

_ZN4absl12lts_202601077uint128rSEi:
  631|     54|inline uint128& uint128::operator>>=(int amount) {
  632|     54|  *this = *this >> amount;
  633|     54|  return *this;
  634|     54|}
_ZN4absl12lts_202601077uint128pLES1_:
  636|     35|inline uint128& uint128::operator+=(uint128 other) {
  637|     35|  *this = *this + other;
  638|     35|  return *this;
  639|     35|}
_ZN4absl12lts_20260107ltENS0_7uint128ES1_:
  832|     27|constexpr bool operator<(uint128 lhs, uint128 rhs) {
  833|     27|#ifdef ABSL_HAVE_INTRINSIC_INT128
  834|     27|  return static_cast<unsigned __int128>(lhs) <
  835|     27|         static_cast<unsigned __int128>(rhs);
  836|       |#else
  837|       |  return (Uint128High64(lhs) == Uint128High64(rhs))
  838|       |             ? (Uint128Low64(lhs) < Uint128Low64(rhs))
  839|       |             : (Uint128High64(lhs) < Uint128High64(rhs));
  840|       |#endif
  841|     27|}
_ZN4absl12lts_20260107gtENS0_7uint128ES1_:
  843|     27|constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
_ZN4absl12lts_20260107anENS0_7uint128ES1_:
  923|     27|constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
  924|     27|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  925|     27|  return static_cast<unsigned __int128>(lhs) &
  926|     27|         static_cast<unsigned __int128>(rhs);
  927|       |#else
  928|       |  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
  929|       |                     Uint128Low64(lhs) & Uint128Low64(rhs));
  930|       |#endif
  931|     27|}
_ZN4absl12lts_20260107eoENS0_7uint128ES1_:
  933|  1.35k|constexpr inline uint128 operator^(uint128 lhs, uint128 rhs) {
  934|  1.35k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  935|  1.35k|  return static_cast<unsigned __int128>(lhs) ^
  936|  1.35k|         static_cast<unsigned __int128>(rhs);
  937|       |#else
  938|       |  return MakeUint128(Uint128High64(lhs) ^ Uint128High64(rhs),
  939|       |                     Uint128Low64(lhs) ^ Uint128Low64(rhs));
  940|       |#endif
  941|  1.35k|}
_ZN4absl12lts_202601077uint128eOES1_:
  953|  1.35k|inline uint128& uint128::operator^=(uint128 other) {
  954|  1.35k|  *this = *this ^ other;
  955|  1.35k|  return *this;
  956|  1.35k|}
_ZN4absl12lts_20260107lsENS0_7uint128Ei:
  960|     54|constexpr uint128 operator<<(uint128 lhs, int amount) {
  961|     54|#ifdef ABSL_HAVE_INTRINSIC_INT128
  962|     54|  return static_cast<unsigned __int128>(lhs) << amount;
  963|       |#else
  964|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  965|       |  // special-casing.
  966|       |  return amount >= 64  ? MakeUint128(Uint128Low64(lhs) << (amount - 64), 0)
  967|       |         : amount == 0 ? lhs
  968|       |                       : MakeUint128((Uint128High64(lhs) << amount) |
  969|       |                                         (Uint128Low64(lhs) >> (64 - amount)),
  970|       |                                     Uint128Low64(lhs) << amount);
  971|       |#endif
  972|     54|}
_ZN4absl12lts_20260107plENS0_7uint128ES1_:
  999|     62|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
 1000|     62|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1001|     62|  return static_cast<unsigned __int128>(lhs) +
 1002|     62|         static_cast<unsigned __int128>(rhs);
 1003|       |#else
 1004|       |  return int128_internal::AddResult(
 1005|       |      MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
 1006|       |                  Uint128Low64(lhs) + Uint128Low64(rhs)),
 1007|       |      lhs);
 1008|       |#endif
 1009|     62|}
_ZN4absl12lts_20260107miENS0_7uint128ES1_:
 1022|     27|constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
 1023|     27|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1024|     27|  return static_cast<unsigned __int128>(lhs) -
 1025|     27|         static_cast<unsigned __int128>(rhs);
 1026|       |#else
 1027|       |  return int128_internal::SubstructResult(
 1028|       |      MakeUint128(Uint128High64(lhs) - Uint128High64(rhs),
 1029|       |                  Uint128Low64(lhs) - Uint128Low64(rhs)),
 1030|       |      lhs, rhs);
 1031|       |#endif
 1032|     27|}
_ZN4absl12lts_202601077uint128C2Ei:
  672|    108|    : lo_{static_cast<uint64_t>(v)},
  673|    108|      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
  ------------------
  |  Branch (673:11): [True: 0, False: 108]
  ------------------

_ZN4absl12lts_2026010716numeric_internal20CountLeadingZeroes16Et:
  201|  47.7k|CountLeadingZeroes16(uint16_t x) {
  202|  47.7k|#if ABSL_HAVE_BUILTIN(__builtin_clzg)
  203|  47.7k|  return x == 0 ? 16 : __builtin_clzg(x);
  ------------------
  |  Branch (203:10): [True: 0, False: 47.7k]
  ------------------
  204|       |#elif ABSL_HAVE_BUILTIN(__builtin_clzs)
  205|       |  static_assert(sizeof(unsigned short) == sizeof(x),  // NOLINT(runtime/int)
  206|       |                "__builtin_clzs does not take 16-bit arg");
  207|       |  return x == 0 ? 16 : __builtin_clzs(x);
  208|       |#else
  209|       |  return CountLeadingZeroes32(x) - 16;
  210|       |#endif
  211|  47.7k|}
_ZN4absl12lts_2026010716numeric_internal28CountTrailingZeroesNonzero64Em:
  307|  1.90M|CountTrailingZeroesNonzero64(uint64_t x) {
  308|  1.90M|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
  309|  1.90M|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  310|  1.90M|                "__builtin_ctzll does not take 64-bit arg");
  311|  1.90M|  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.90M|}
_ZN4absl12lts_2026010716numeric_internal18CountLeadingZeroesItEEiT_:
  268|  47.7k|CountLeadingZeroes(T x) {
  269|  47.7k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  270|  47.7k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  271|  47.7k|                "T must have a power-of-2 size");
  272|  47.7k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  273|  47.7k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (273:10): [True: 47.7k, Folded]
  ------------------
  274|  47.7k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  275|  47.7k|                   (std::numeric_limits<uint16_t>::digits -
  276|  47.7k|                    std::numeric_limits<T>::digits)
  277|  47.7k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (277:17): [True: 0, Folded]
  ------------------
  278|      0|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  279|      0|                          (std::numeric_limits<uint32_t>::digits -
  280|      0|                           std::numeric_limits<T>::digits)
  281|      0|                    : CountLeadingZeroes64(x));
  282|  47.7k|}
_ZN4absl12lts_2026010716numeric_internal19CountTrailingZeroesImEEiT_:
  353|  1.90M|CountTrailingZeroes(T x) noexcept {
  354|  1.90M|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  355|  1.90M|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  356|  1.90M|                "T must have a power-of-2 size");
  357|  1.90M|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  358|  1.90M|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (358:10): [True: 0, False: 1.90M]
  ------------------
  359|  1.90M|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (359:20): [Folded, False: 1.90M]
  ------------------
  360|  1.90M|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  361|  1.90M|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (361:27): [Folded, False: 1.90M]
  ------------------
  362|  1.90M|                              ? CountTrailingZeroesNonzero32(
  363|      0|                                    static_cast<uint32_t>(x))
  364|  1.90M|                              : CountTrailingZeroesNonzero64(x)));
  365|  1.90M|}

_ZN4absl12lts_2026010715random_internal24GetEntropyFromRandenPoolEPvm:
  178|  10.1k|void GetEntropyFromRandenPool(void* dest, size_t bytes) {
  179|  10.1k|  auto* pool = GetPoolForCurrentThread();
  180|  10.1k|  pool->Fill(reinterpret_cast<uint8_t*>(dest), bytes);
  181|  10.1k|}
entropy_pool.cc:_ZN4absl12lts_2026010715random_internal12_GLOBAL__N_123GetPoolForCurrentThreadEv:
  171|  10.1k|RandenPoolEntry* GetPoolForCurrentThread() {
  172|  10.1k|  absl::call_once(pool_once, InitPoolURBG);
  173|  10.1k|  return shared_pools[GetPoolID()];
  174|  10.1k|}
entropy_pool.cc:_ZN4absl12lts_2026010715random_internal12_GLOBAL__N_112InitPoolURBGEv:
  155|      1|void InitPoolURBG() {
  156|      1|  static constexpr size_t kSeedSize =
  157|      1|      RandenTraits::kStateBytes / sizeof(uint32_t);
  158|       |  // Read OS entropy once, and use it to initialize each pool entry.
  159|      1|  uint32_t seed_material[kPoolSize * kSeedSize];
  160|      1|  if (!ReadSeedMaterialFromOSEntropy(absl::MakeSpan(seed_material))) {
  ------------------
  |  Branch (160:7): [True: 0, False: 1]
  ------------------
  161|      0|    ThrowSeedGenException();
  162|      0|  }
  163|      9|  for (size_t i = 0; i < kPoolSize; i++) {
  ------------------
  |  Branch (163:22): [True: 8, False: 1]
  ------------------
  164|      8|    shared_pools[i] = new RandenPoolEntry();
  165|      8|    shared_pools[i]->Init(
  166|      8|        absl::MakeSpan(&seed_material[i * kSeedSize], kSeedSize));
  167|      8|  }
  168|      1|}
entropy_pool.cc:_ZN4absl12lts_2026010715random_internal12_GLOBAL__N_115RandenPoolEntry4InitENS0_4SpanIKjEE:
   57|      8|  void Init(absl::Span<const uint32_t> data) {
   58|      8|    SpinLockHolder l(mu_);  // Always uncontested.
   59|      8|    std::copy(data.begin(), data.end(), std::begin(state_));
   60|      8|    next_ = kState;
   61|      8|  }
entropy_pool.cc:_ZN4absl12lts_2026010715random_internal12_GLOBAL__N_19GetPoolIDEv:
  116|  10.1k|size_t GetPoolID() {
  117|  10.1k|  static_assert(kPoolSize >= 1,
  118|  10.1k|                "At least one urbg instance is required for PoolURBG");
  119|       |
  120|  10.1k|  ABSL_CONST_INIT static std::atomic<uint64_t> sequence{0};
  ------------------
  |  |  760|  10.1k|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
  121|       |
  122|  10.1k|#ifdef ABSL_HAVE_THREAD_LOCAL
  123|  10.1k|  static thread_local size_t my_pool_id = kPoolSize;
  124|  10.1k|  if (ABSL_PREDICT_FALSE(my_pool_id == kPoolSize)) {
  ------------------
  |  |  189|  10.1k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 10.1k]
  |  |  |  Branch (189:49): [Folded, False: 10.1k]
  |  |  |  Branch (189:58): [True: 1, False: 10.1k]
  |  |  ------------------
  ------------------
  125|      1|    my_pool_id = (sequence++ % kPoolSize);
  126|      1|  }
  127|  10.1k|  return my_pool_id;
  128|       |#else
  129|       |  static pthread_key_t tid_key = [] {
  130|       |    pthread_key_t tmp_key;
  131|       |    int err = pthread_key_create(&tmp_key, nullptr);
  132|       |    if (err) {
  133|       |      ABSL_RAW_LOG(FATAL, "pthread_key_create failed with %d", err);
  134|       |    }
  135|       |    return tmp_key;
  136|       |  }();
  137|       |
  138|       |  // Store the value in the pthread_{get/set}specific. However an uninitialized
  139|       |  // value is 0, so add +1 to distinguish from the null value.
  140|       |  uintptr_t my_pool_id =
  141|       |      reinterpret_cast<uintptr_t>(pthread_getspecific(tid_key));
  142|       |  if (ABSL_PREDICT_FALSE(my_pool_id == 0)) {
  143|       |    // No allocated ID, allocate the next value, cache it, and return.
  144|       |    my_pool_id = (sequence++ % kPoolSize) + 1;
  145|       |    int err = pthread_setspecific(tid_key, reinterpret_cast<void*>(my_pool_id));
  146|       |    if (err) {
  147|       |      ABSL_RAW_LOG(FATAL, "pthread_setspecific failed with %d", err);
  148|       |    }
  149|       |  }
  150|       |  return my_pool_id - 1;
  151|       |#endif
  152|  10.1k|}
entropy_pool.cc:_ZN4absl12lts_2026010715random_internal12_GLOBAL__N_115RandenPoolEntry4FillEPhm:
   86|  10.1k|void RandenPoolEntry::Fill(uint8_t* out, size_t bytes) {
   87|  10.1k|  SpinLockHolder l(mu_);
   88|  20.9k|  while (bytes > 0) {
  ------------------
  |  Branch (88:10): [True: 10.8k, False: 10.1k]
  ------------------
   89|  10.8k|    MaybeRefill();
   90|  10.8k|    size_t remaining = available() * sizeof(state_[0]);
   91|  10.8k|    size_t to_copy = std::min(bytes, remaining);
   92|  10.8k|    std::memcpy(out, &state_[next_], to_copy);
   93|  10.8k|    out += to_copy;
   94|  10.8k|    bytes -= to_copy;
   95|  10.8k|    next_ += (to_copy + sizeof(state_[0]) - 1) / sizeof(state_[0]);
   96|  10.8k|  }
   97|  10.1k|}
entropy_pool.cc:_ZN4absl12lts_2026010715random_internal12_GLOBAL__N_115RandenPoolEntry11MaybeRefillEv:
   66|  10.8k|  inline void MaybeRefill() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
   67|  10.8k|    if (next_ >= kState) {
  ------------------
  |  Branch (67:9): [True: 1.35k, False: 9.45k]
  ------------------
   68|  1.35k|      next_ = kCapacity;
   69|  1.35k|      impl_.Generate(state_);
   70|  1.35k|    }
   71|  10.8k|  }
entropy_pool.cc:_ZNK4absl12lts_2026010715random_internal12_GLOBAL__N_115RandenPoolEntry9availableEv:
   73|  10.8k|  inline size_t available() const ABSL_SHARED_LOCKS_REQUIRED(mu_) {
   74|  10.8k|    return kState - next_;
   75|  10.8k|  }

_ZN4absl12lts_2026010715random_internal6RandenC2Ev:
   81|  11.5k|Randen::Randen() {
   82|  11.5k|  auto tmp = GetRandenState();
   83|  11.5k|  keys_ = tmp.keys;
   84|  11.5k|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   85|  11.5k|  has_crypto_ = tmp.has_crypto;
   86|  11.5k|#endif
   87|  11.5k|}
randen.cc:_ZN4absl12lts_2026010715random_internal12_GLOBAL__N_114GetRandenStateEv:
   53|  11.5k|RandenState GetRandenState() {
   54|  11.5k|  static const RandenState state = []() {
   55|  11.5k|    RandenState tmp;
   56|  11.5k|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   57|       |    // HW AES Dispatch.
   58|  11.5k|    if (HasRandenHwAesImplementation() && CPUSupportsRandenHwAes()) {
   59|  11.5k|      tmp.has_crypto = true;
   60|  11.5k|      tmp.keys = RandenHwAes::GetKeys();
   61|  11.5k|    } else {
   62|  11.5k|      tmp.has_crypto = false;
   63|  11.5k|      tmp.keys = RandenSlow::GetKeys();
   64|  11.5k|    }
   65|       |#elif ABSL_HAVE_ACCELERATED_AES
   66|       |    // HW AES is enabled.
   67|       |    tmp.has_crypto = true;
   68|       |    tmp.keys = RandenHwAes::GetKeys();
   69|       |#else
   70|       |    // HW AES is disabled.
   71|       |    tmp.has_crypto = false;
   72|       |    tmp.keys = RandenSlow::GetKeys();
   73|       |#endif
   74|  11.5k|    return tmp;
   75|  11.5k|  }();
   76|  11.5k|  return state;
   77|  11.5k|}
randen.cc:_ZZN4absl12lts_2026010715random_internal12_GLOBAL__N_114GetRandenStateEvENK3$_0clEv:
   54|      1|  static const RandenState state = []() {
   55|      1|    RandenState tmp;
   56|      1|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   57|       |    // HW AES Dispatch.
   58|      1|    if (HasRandenHwAesImplementation() && CPUSupportsRandenHwAes()) {
  ------------------
  |  Branch (58:9): [True: 0, False: 1]
  |  Branch (58:43): [True: 0, False: 0]
  ------------------
   59|      0|      tmp.has_crypto = true;
   60|      0|      tmp.keys = RandenHwAes::GetKeys();
   61|      1|    } else {
   62|      1|      tmp.has_crypto = false;
   63|      1|      tmp.keys = RandenSlow::GetKeys();
   64|      1|    }
   65|       |#elif ABSL_HAVE_ACCELERATED_AES
   66|       |    // HW AES is enabled.
   67|       |    tmp.has_crypto = true;
   68|       |    tmp.keys = RandenHwAes::GetKeys();
   69|       |#else
   70|       |    // HW AES is disabled.
   71|       |    tmp.has_crypto = false;
   72|       |    tmp.keys = RandenSlow::GetKeys();
   73|       |#endif
   74|      1|    return tmp;
   75|      1|  }();

_ZN4absl12lts_2026010715random_internal28HasRandenHwAesImplementationEv:
   54|      1|bool HasRandenHwAesImplementation() { return false; }

_ZN4absl12lts_2026010715random_internal10RandenSlow7GetKeysEv:
  421|      1|const void* RandenSlow::GetKeys() {
  422|       |  // Round keys for one AES per Feistel round and branch.
  423|       |  // The canonical implementation uses first digits of Pi.
  424|      1|#ifdef ABSL_IS_LITTLE_ENDIAN
  425|      1|  return kRandenRoundKeys;
  426|       |#else
  427|       |  return kRandenRoundKeysBE;
  428|       |#endif
  429|      1|}
_ZN4absl12lts_2026010715random_internal10RandenSlow6AbsorbEPKvPv:
  431|  11.5k|void RandenSlow::Absorb(const void* seed_void, void* state_void) {
  432|  11.5k|  auto* state =
  433|  11.5k|      reinterpret_cast<uint64_t * ABSL_RANDOM_INTERNAL_RESTRICT>(state_void);
  434|  11.5k|  const auto* seed =
  435|  11.5k|      reinterpret_cast<const uint64_t * ABSL_RANDOM_INTERNAL_RESTRICT>(
  436|  11.5k|          seed_void);
  437|       |
  438|  11.5k|  constexpr size_t kCapacityBlocks =
  439|  11.5k|      RandenTraits::kCapacityBytes / sizeof(uint64_t);
  440|  11.5k|  static_assert(
  441|  11.5k|      kCapacityBlocks * sizeof(uint64_t) == RandenTraits::kCapacityBytes,
  442|  11.5k|      "Not i*V");
  443|       |
  444|  11.5k|  for (size_t i = kCapacityBlocks;
  445|   359k|       i < RandenTraits::kStateBytes / sizeof(uint64_t); ++i) {
  ------------------
  |  Branch (445:8): [True: 347k, False: 11.5k]
  ------------------
  446|   347k|    state[i] ^= seed[i - kCapacityBlocks];
  447|   347k|  }
  448|  11.5k|}
_ZN4absl12lts_2026010715random_internal10RandenSlow8GenerateEPKvPv:
  450|  1.35k|void RandenSlow::Generate(const void* keys_void, void* state_void) {
  451|  1.35k|  static_assert(RandenTraits::kCapacityBytes == sizeof(absl::uint128),
  452|  1.35k|                "Capacity mismatch");
  453|       |
  454|  1.35k|  auto* state = reinterpret_cast<absl::uint128*>(state_void);
  455|  1.35k|  const auto* keys = reinterpret_cast<const absl::uint128*>(keys_void);
  456|       |
  457|  1.35k|  const absl::uint128 prev_inner = state[0];
  458|       |
  459|  1.35k|  SwapEndian(state);
  460|       |
  461|  1.35k|  Permute(state, keys);
  462|       |
  463|  1.35k|  SwapEndian(state);
  464|       |
  465|       |  // Ensure backtracking resistance.
  466|  1.35k|  *state ^= prev_inner;
  467|  1.35k|}
randen_slow.cc:_ZN12_GLOBAL__N_110SwapEndianEPN4absl12lts_202601077uint128E:
  400|  2.70k|    absl::uint128* state) {
  401|       |#ifdef ABSL_IS_BIG_ENDIAN
  402|       |  for (uint32_t block = 0; block < RandenTraits::kFeistelBlocks; ++block) {
  403|       |    uint64_t new_lo = absl::little_endian::ToHost64(
  404|       |        static_cast<uint64_t>(state[block] >> 64));
  405|       |    uint64_t new_hi = absl::little_endian::ToHost64(
  406|       |        static_cast<uint64_t>((state[block] << 64) >> 64));
  407|       |    state[block] = (static_cast<absl::uint128>(new_hi) << 64) | new_lo;
  408|       |  }
  409|       |#else
  410|       |  // Avoid warning about unused variable.
  411|  2.70k|  (void)state;
  412|  2.70k|#endif
  413|  2.70k|}
randen_slow.cc:_ZN12_GLOBAL__N_17PermuteEPN4absl12lts_202601077uint128EPKS2_:
  391|  1.35k|    const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) {
  392|  24.3k|  for (size_t round = 0; round < RandenTraits::kFeistelRounds; ++round) {
  ------------------
  |  Branch (392:26): [True: 22.9k, False: 1.35k]
  ------------------
  393|  22.9k|    keys = FeistelRound(state, keys);
  394|  22.9k|    BlockShuffle(state);
  395|  22.9k|  }
  396|  1.35k|}
randen_slow.cc:_ZN12_GLOBAL__N_112FeistelRoundEPN4absl12lts_202601077uint128EPKS2_:
  365|  22.9k|             const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) {
  366|   114k|  for (size_t branch = 0; branch < RandenTraits::kFeistelBlocks; branch += 4) {
  ------------------
  |  Branch (366:27): [True: 91.8k, False: 22.9k]
  ------------------
  367|  91.8k|    const Vector128 s0 = Vector128Load(state + branch);
  368|  91.8k|    const Vector128 s1 = Vector128Load(state + branch + 1);
  369|  91.8k|    const Vector128 f0 = AesRound(s0, Vector128Load(keys));
  370|  91.8k|    keys++;
  371|  91.8k|    const Vector128 o1 = AesRound(f0, s1);
  372|  91.8k|    Vector128Store(o1, state + branch + 1);
  373|       |
  374|       |    // Manually unroll this loop once. about 10% better than not unrolled.
  375|  91.8k|    const Vector128 s2 = Vector128Load(state + branch + 2);
  376|  91.8k|    const Vector128 s3 = Vector128Load(state + branch + 3);
  377|  91.8k|    const Vector128 f2 = AesRound(s2, Vector128Load(keys));
  378|  91.8k|    keys++;
  379|  91.8k|    const Vector128 o3 = AesRound(f2, s3);
  380|  91.8k|    Vector128Store(o3, state + branch + 3);
  381|  91.8k|  }
  382|  22.9k|  return keys;
  383|  22.9k|}
randen_slow.cc:_ZN12_GLOBAL__N_113Vector128LoadEPKv:
  239|   550k|Vector128Load(const void* from) {
  240|   550k|  Vector128 result;
  241|   550k|  std::memcpy(result.s, from, sizeof(Vector128));
  242|   550k|  return result;
  243|   550k|}
randen_slow.cc:_ZN12_GLOBAL__N_18AesRoundERKNS_9Vector128ES2_:
  253|   367k|AesRound(const Vector128& state, const Vector128& round_key) {
  254|   367k|  Vector128 result;
  255|   367k|#ifdef ABSL_IS_LITTLE_ENDIAN
  256|   367k|  result.s[0] = round_key.s[0] ^                  //
  257|   367k|                te0[uint8_t(state.s[0])] ^        //
  258|   367k|                te1[uint8_t(state.s[1] >> 8)] ^   //
  259|   367k|                te2[uint8_t(state.s[2] >> 16)] ^  //
  260|   367k|                te3[uint8_t(state.s[3] >> 24)];
  261|   367k|  result.s[1] = round_key.s[1] ^                  //
  262|   367k|                te0[uint8_t(state.s[1])] ^        //
  263|   367k|                te1[uint8_t(state.s[2] >> 8)] ^   //
  264|   367k|                te2[uint8_t(state.s[3] >> 16)] ^  //
  265|   367k|                te3[uint8_t(state.s[0] >> 24)];
  266|   367k|  result.s[2] = round_key.s[2] ^                  //
  267|   367k|                te0[uint8_t(state.s[2])] ^        //
  268|   367k|                te1[uint8_t(state.s[3] >> 8)] ^   //
  269|   367k|                te2[uint8_t(state.s[0] >> 16)] ^  //
  270|   367k|                te3[uint8_t(state.s[1] >> 24)];
  271|   367k|  result.s[3] = round_key.s[3] ^                  //
  272|   367k|                te0[uint8_t(state.s[3])] ^        //
  273|   367k|                te1[uint8_t(state.s[0] >> 8)] ^   //
  274|   367k|                te2[uint8_t(state.s[1] >> 16)] ^  //
  275|   367k|                te3[uint8_t(state.s[2] >> 24)];
  276|       |#else
  277|       |  result.s[0] = round_key.s[0] ^                  //
  278|       |                te0[uint8_t(state.s[0])] ^        //
  279|       |                te1[uint8_t(state.s[3] >> 8)] ^   //
  280|       |                te2[uint8_t(state.s[2] >> 16)] ^  //
  281|       |                te3[uint8_t(state.s[1] >> 24)];
  282|       |  result.s[1] = round_key.s[1] ^                  //
  283|       |                te0[uint8_t(state.s[1])] ^        //
  284|       |                te1[uint8_t(state.s[0] >> 8)] ^   //
  285|       |                te2[uint8_t(state.s[3] >> 16)] ^  //
  286|       |                te3[uint8_t(state.s[2] >> 24)];
  287|       |  result.s[2] = round_key.s[2] ^                  //
  288|       |                te0[uint8_t(state.s[2])] ^        //
  289|       |                te1[uint8_t(state.s[1] >> 8)] ^   //
  290|       |                te2[uint8_t(state.s[0] >> 16)] ^  //
  291|       |                te3[uint8_t(state.s[3] >> 24)];
  292|       |  result.s[3] = round_key.s[3] ^                  //
  293|       |                te0[uint8_t(state.s[3])] ^        //
  294|       |                te1[uint8_t(state.s[2] >> 8)] ^   //
  295|       |                te2[uint8_t(state.s[1] >> 16)] ^  //
  296|       |                te3[uint8_t(state.s[0] >> 24)];
  297|       |#endif
  298|   367k|  return result;
  299|   367k|}
randen_slow.cc:_ZN12_GLOBAL__N_114Vector128StoreERKNS_9Vector128EPv:
  246|   183k|    const Vector128& v, void* to) {
  247|   183k|  std::memcpy(to, v.s, sizeof(Vector128));
  248|   183k|}
randen_slow.cc:_ZN12_GLOBAL__N_112BlockShuffleEPN4absl12lts_202601077uint128E:
  305|  22.9k|    absl::uint128* state) {
  306|  22.9k|  static_assert(RandenTraits::kFeistelBlocks == 16,
  307|  22.9k|                "Feistel block shuffle only works for 16 blocks.");
  308|       |
  309|  22.9k|  constexpr size_t shuffle[RandenTraits::kFeistelBlocks] = {
  310|  22.9k|      7, 2, 13, 4, 11, 8, 3, 6, 15, 0, 9, 10, 1, 14, 5, 12};
  311|       |
  312|       |  // The fully unrolled loop without the memcpy improves the speed by about
  313|       |  // 30% over the equivalent:
  314|       |#if 0
  315|       |  absl::uint128 source[RandenTraits::kFeistelBlocks];
  316|       |  std::memcpy(source, state, sizeof(source));
  317|       |  for (size_t i = 0; i < RandenTraits::kFeistelBlocks; i++) {
  318|       |    const absl::uint128 v0 = source[shuffle[i]];
  319|       |    state[i] = v0;
  320|       |  }
  321|       |  return;
  322|       |#endif
  323|       |
  324|  22.9k|  const absl::uint128 v0 = state[shuffle[0]];
  325|  22.9k|  const absl::uint128 v1 = state[shuffle[1]];
  326|  22.9k|  const absl::uint128 v2 = state[shuffle[2]];
  327|  22.9k|  const absl::uint128 v3 = state[shuffle[3]];
  328|  22.9k|  const absl::uint128 v4 = state[shuffle[4]];
  329|  22.9k|  const absl::uint128 v5 = state[shuffle[5]];
  330|  22.9k|  const absl::uint128 v6 = state[shuffle[6]];
  331|  22.9k|  const absl::uint128 v7 = state[shuffle[7]];
  332|  22.9k|  const absl::uint128 w0 = state[shuffle[8]];
  333|  22.9k|  const absl::uint128 w1 = state[shuffle[9]];
  334|  22.9k|  const absl::uint128 w2 = state[shuffle[10]];
  335|  22.9k|  const absl::uint128 w3 = state[shuffle[11]];
  336|  22.9k|  const absl::uint128 w4 = state[shuffle[12]];
  337|  22.9k|  const absl::uint128 w5 = state[shuffle[13]];
  338|  22.9k|  const absl::uint128 w6 = state[shuffle[14]];
  339|  22.9k|  const absl::uint128 w7 = state[shuffle[15]];
  340|  22.9k|  state[0] = v0;
  341|  22.9k|  state[1] = v1;
  342|  22.9k|  state[2] = v2;
  343|  22.9k|  state[3] = v3;
  344|  22.9k|  state[4] = v4;
  345|  22.9k|  state[5] = v5;
  346|  22.9k|  state[6] = v6;
  347|  22.9k|  state[7] = v7;
  348|  22.9k|  state[8] = w0;
  349|  22.9k|  state[9] = w1;
  350|  22.9k|  state[10] = w2;
  351|  22.9k|  state[11] = w3;
  352|  22.9k|  state[12] = w4;
  353|  22.9k|  state[13] = w5;
  354|  22.9k|  state[14] = w6;
  355|  22.9k|  state[15] = w7;
  356|  22.9k|}

_ZN4absl12lts_2026010715random_internal29ReadSeedMaterialFromOSEntropyENS0_4SpanIjEE:
  188|      2|bool ReadSeedMaterialFromOSEntropy(absl::Span<uint32_t> values) {
  189|      2|  assert(values.data() != nullptr);
  190|      2|  if (values.data() == nullptr) {
  ------------------
  |  Branch (190:7): [True: 0, False: 2]
  ------------------
  191|      0|    return false;
  192|      0|  }
  193|      2|  if (values.empty()) {
  ------------------
  |  Branch (193:7): [True: 0, False: 2]
  ------------------
  194|      0|    return true;
  195|      0|  }
  196|      2|  return ReadSeedMaterialFromOSEntropyImpl(values);
  197|      2|}
_ZN4absl12lts_2026010715random_internal19MixIntoSeedMaterialENS0_4SpanIKjEENS2_IjEE:
  200|  1.46k|                         absl::Span<uint32_t> seed_material) {
  201|       |  // Algorithm is based on code available at
  202|       |  // https://gist.github.com/imneme/540829265469e673d045
  203|  1.46k|  constexpr uint32_t kInitVal = 0x43b0d7e5;
  204|  1.46k|  constexpr uint32_t kHashMul = 0x931e8875;
  205|  1.46k|  constexpr uint32_t kMixMulL = 0xca01f9dd;
  206|  1.46k|  constexpr uint32_t kMixMulR = 0x4973f715;
  207|  1.46k|  constexpr uint32_t kShiftSize = sizeof(uint32_t) * 8 / 2;
  208|       |
  209|  1.46k|  uint32_t hash_const = kInitVal;
  210|  1.46k|  auto hash = [&](uint32_t value) {
  211|  1.46k|    value ^= hash_const;
  212|  1.46k|    hash_const *= kHashMul;
  213|  1.46k|    value *= hash_const;
  214|  1.46k|    value ^= value >> kShiftSize;
  215|  1.46k|    return value;
  216|  1.46k|  };
  217|       |
  218|  1.46k|  auto mix = [&](uint32_t x, uint32_t y) {
  219|  1.46k|    uint32_t result = kMixMulL * x - kMixMulR * y;
  220|  1.46k|    result ^= result >> kShiftSize;
  221|  1.46k|    return result;
  222|  1.46k|  };
  223|       |
  224|  1.46k|  for (const auto& seq_val : sequence) {
  ------------------
  |  Branch (224:28): [True: 1.46k, False: 1.46k]
  ------------------
  225|  1.46k|    for (auto& elem : seed_material) {
  ------------------
  |  Branch (225:21): [True: 1.46k, False: 1.46k]
  ------------------
  226|  1.46k|      elem = mix(elem, hash(seq_val));
  227|  1.46k|    }
  228|  1.46k|  }
  229|  1.46k|}
_ZN4absl12lts_2026010715random_internal15GetSaltMaterialEv:
  231|  1.46k|absl::optional<uint32_t> GetSaltMaterial() {
  232|       |  // Salt must be common for all generators within the same process so read it
  233|       |  // only once and store in static variable.
  234|  1.46k|  static const auto salt_material = []() -> absl::optional<uint32_t> {
  235|  1.46k|    uint32_t salt_value = 0;
  236|       |
  237|  1.46k|    if (ReadSeedMaterialFromOSEntropy(absl::MakeSpan(&salt_value, 1))) {
  238|  1.46k|      return salt_value;
  239|  1.46k|    }
  240|       |
  241|  1.46k|    return absl::nullopt;
  242|  1.46k|  }();
  243|       |
  244|  1.46k|  return salt_material;
  245|  1.46k|}
seed_material.cc:_ZN4absl12lts_2026010715random_internal12_GLOBAL__N_133ReadSeedMaterialFromOSEntropyImplENS0_4SpanIjEE:
  173|      2|bool ReadSeedMaterialFromOSEntropyImpl(absl::Span<uint32_t> values) {
  174|      2|#if defined(ABSL_RANDOM_USE_GET_ENTROPY)
  175|      2|  if (ReadSeedMaterialFromGetEntropy(values)) {
  ------------------
  |  Branch (175:7): [True: 2, False: 0]
  ------------------
  176|      2|    return true;
  177|      2|  }
  178|      0|#endif
  179|       |  // Libc may support getentropy, but the kernel may not, so we still have
  180|       |  // to fallback to ReadSeedMaterialFromDevURandom().
  181|      0|  return ReadSeedMaterialFromDevURandom(values);
  182|      2|}
seed_material.cc:_ZN4absl12lts_2026010715random_internal12_GLOBAL__N_130ReadSeedMaterialFromGetEntropyENS0_4SpanIjEE:
  122|      2|bool ReadSeedMaterialFromGetEntropy(absl::Span<uint32_t> values) {
  123|      2|  auto buffer = reinterpret_cast<uint8_t*>(values.data());
  124|      2|  size_t buffer_size = sizeof(uint32_t) * values.size();
  125|     11|  while (buffer_size > 0) {
  ------------------
  |  Branch (125:10): [True: 9, False: 2]
  ------------------
  126|       |    // getentropy() has a maximum permitted length of 256.
  127|      9|    size_t to_read = std::min<size_t>(buffer_size, 256);
  128|      9|    int result = getentropy(buffer, to_read);
  129|      9|    if (result < 0) {
  ------------------
  |  Branch (129:9): [True: 0, False: 9]
  ------------------
  130|      0|      return false;
  131|      0|    }
  132|       |    // https://github.com/google/sanitizers/issues/1173
  133|       |    // MemorySanitizer can't see through getentropy().
  134|      9|    ABSL_ANNOTATE_MEMORY_IS_INITIALIZED(buffer, to_read);
  135|      9|    buffer += to_read;
  136|      9|    buffer_size -= to_read;
  137|      9|  }
  138|      2|  return true;
  139|      2|}
seed_material.cc:_ZZN4absl12lts_2026010715random_internal19MixIntoSeedMaterialENS0_4SpanIKjEENS2_IjEEENK3$_1clEjj:
  218|  1.46k|  auto mix = [&](uint32_t x, uint32_t y) {
  219|  1.46k|    uint32_t result = kMixMulL * x - kMixMulR * y;
  220|  1.46k|    result ^= result >> kShiftSize;
  221|  1.46k|    return result;
  222|  1.46k|  };
seed_material.cc:_ZZN4absl12lts_2026010715random_internal19MixIntoSeedMaterialENS0_4SpanIKjEENS2_IjEEENK3$_0clEj:
  210|  1.46k|  auto hash = [&](uint32_t value) {
  211|  1.46k|    value ^= hash_const;
  212|  1.46k|    hash_const *= kHashMul;
  213|  1.46k|    value *= hash_const;
  214|  1.46k|    value ^= value >> kShiftSize;
  215|  1.46k|    return value;
  216|  1.46k|  };
seed_material.cc:_ZZN4absl12lts_2026010715random_internal15GetSaltMaterialEvENK3$_0clEv:
  234|      1|  static const auto salt_material = []() -> absl::optional<uint32_t> {
  235|      1|    uint32_t salt_value = 0;
  236|       |
  237|      1|    if (ReadSeedMaterialFromOSEntropy(absl::MakeSpan(&salt_value, 1))) {
  ------------------
  |  Branch (237:9): [True: 1, False: 0]
  ------------------
  238|      1|      return salt_value;
  239|      1|    }
  240|       |
  241|      0|    return absl::nullopt;
  242|      1|  }();

_ZN4absl12lts_2026010714ascii_internal15AsciiStrToUpperEPcPKcm:
  226|  10.1k|                     size_t n) {
  227|  10.1k|  return AsciiStrCaseFold<true>(dst, src, n);
  228|  10.1k|}
_ZN4absl12lts_2026010714ascii_internal16AsciiStrCaseFoldILb1EEEvPcPKcm:
  215|  10.1k|                                const char* absl_nullable src, size_t size) {
  216|  10.1k|  size < 16 ? AsciiStrCaseFoldImpl<ToUpper, /*Naive=*/true>(dst, src, size)
  ------------------
  |  Branch (216:3): [True: 10.1k, False: 0]
  ------------------
  217|  10.1k|            : AsciiStrCaseFoldImpl<ToUpper, /*Naive=*/false>(dst, src, size);
  218|  10.1k|}
_ZN4absl12lts_2026010714ascii_internal20AsciiStrCaseFoldImplILb1ELb1EEEvPcPKcm:
  188|  10.1k|                                    size_t size) {
  189|       |  // The upper- and lowercase versions of ASCII characters differ by only 1 bit.
  190|       |  // When we need to flip the case, we can xor with this bit to achieve the
  191|       |  // desired result. Note that the choice of 'a' and 'A' here is arbitrary. We
  192|       |  // could have chosen 'z' and 'Z', or any other pair of characters as they all
  193|       |  // have the same single bit difference.
  194|  10.1k|  constexpr unsigned char kAsciiCaseBitFlip = 'a' ^ 'A';
  195|       |
  196|  69.5k|  for (size_t i = 0; i < size; ++i) {
  ------------------
  |  Branch (196:22): [True: 59.4k, False: 10.1k]
  ------------------
  197|  59.4k|    unsigned char v = static_cast<unsigned char>(src[i]);
  198|  59.4k|    if ABSL_INTERNAL_CONSTEXPR_SINCE_CXX17 (Naive) {
  199|  59.4k|      v ^= AsciiInAZRangeNaive<ToUpper>(v) ? kAsciiCaseBitFlip : 0;
  ------------------
  |  Branch (199:12): [True: 59.4k, False: 0]
  ------------------
  200|       |    } else {
  201|       |      v ^= AsciiInAZRange<ToUpper>(v) ? kAsciiCaseBitFlip : 0;
  202|       |    }
  203|  59.4k|    dst[i] = static_cast<char>(v);
  204|  59.4k|  }
  205|  10.1k|}
_ZN4absl12lts_2026010714ascii_internal19AsciiInAZRangeNaiveILb1EEEbh:
  179|  59.4k|constexpr bool AsciiInAZRangeNaive(unsigned char c) {
  180|  59.4k|  constexpr unsigned char a = (ToUpper ? 'a' : 'A');
  ------------------
  |  Branch (180:32): [True: 0, Folded]
  ------------------
  181|  59.4k|  constexpr unsigned char z = (ToUpper ? 'z' : 'Z');
  ------------------
  |  Branch (181:32): [True: 0, Folded]
  ------------------
  182|  59.4k|  return a <= c && c <= z;
  ------------------
  |  Branch (182:10): [True: 59.4k, False: 0]
  |  Branch (182:20): [True: 59.4k, False: 0]
  ------------------
  183|  59.4k|}

_ZN4absl12lts_2026010713ascii_isspaceEh:
  106|  49.7k|inline bool ascii_isspace(unsigned char c) {
  107|  49.7k|  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
  108|  49.7k|}
_ZN4absl12lts_2026010727StripLeadingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  245|  2.54k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  246|  2.54k|  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
  247|  2.54k|  return str.substr(static_cast<size_t>(it - str.begin()));
  248|  2.54k|}
_ZN4absl12lts_2026010728StripTrailingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  259|  2.54k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  260|  2.54k|  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
  261|  2.54k|  return str.substr(0, static_cast<size_t>(str.rend() - it));
  262|  2.54k|}
_ZN4absl12lts_2026010720StripAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  273|  2.54k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  274|  2.54k|  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
  275|  2.54k|}

_ZN4absl12lts_2026010710from_charsEPKcS2_RdNS0_12chars_formatE:
  949|  2.54k|                             chars_format fmt) {
  950|  2.54k|  return FromCharsImpl(first, last, value, fmt);
  951|  2.54k|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_113FromCharsImplIdEENS0_17from_chars_resultEPKcS5_RT_NS0_12chars_formatE:
  862|  2.54k|                                chars_format fmt_flags) {
  863|  2.54k|  from_chars_result result;
  864|  2.54k|  result.ptr = first;  // overwritten on successful parse
  865|  2.54k|  result.ec = std::errc();
  866|       |
  867|  2.54k|  bool negative = false;
  868|  2.54k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (868:7): [True: 2.54k, False: 0]
  |  Branch (868:24): [True: 0, False: 2.54k]
  ------------------
  869|      0|    ++first;
  870|      0|    negative = true;
  871|      0|  }
  872|       |  // If the `hex` flag is *not* set, then we will accept a 0x prefix and try
  873|       |  // to parse a hexadecimal float.
  874|  2.54k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (874:7): [True: 2.54k, False: 0]
  |  Branch (874:60): [True: 2.54k, False: 0]
  ------------------
  875|  2.54k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (875:7): [True: 2.52k, False: 21]
  |  Branch (875:25): [True: 0, False: 2.52k]
  |  Branch (875:44): [True: 0, False: 2.52k]
  ------------------
  876|      0|    const char* hex_first = first + 2;
  877|      0|    strings_internal::ParsedFloat hex_parse =
  878|      0|        strings_internal::ParseFloat<16>(hex_first, last, fmt_flags);
  879|      0|    if (hex_parse.end == nullptr ||
  ------------------
  |  Branch (879:9): [True: 0, False: 0]
  ------------------
  880|      0|        hex_parse.type != strings_internal::FloatType::kNumber) {
  ------------------
  |  Branch (880:9): [True: 0, False: 0]
  ------------------
  881|       |      // Either we failed to parse a hex float after the "0x", or we read
  882|       |      // "0xinf" or "0xnan" which we don't want to match.
  883|       |      //
  884|       |      // However, a string that begins with "0x" also begins with "0", which
  885|       |      // is normally a valid match for the number zero.  So we want these
  886|       |      // strings to match zero unless fmt_flags is `scientific`.  (This flag
  887|       |      // means an exponent is required, which the string "0" does not have.)
  888|      0|      if (fmt_flags == chars_format::scientific) {
  ------------------
  |  Branch (888:11): [True: 0, False: 0]
  ------------------
  889|      0|        result.ec = std::errc::invalid_argument;
  890|      0|      } else {
  891|      0|        result.ptr = first + 1;
  892|      0|        value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (892:17): [True: 0, False: 0]
  ------------------
  893|      0|      }
  894|      0|      return result;
  895|      0|    }
  896|       |    // We matched a value.
  897|      0|    result.ptr = hex_parse.end;
  898|      0|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (898:9): [True: 0, False: 0]
  ------------------
  899|      0|      return result;
  900|      0|    }
  901|      0|    CalculatedFloat calculated =
  902|      0|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  903|      0|    EncodeResult(calculated, negative, &result, &value);
  904|      0|    return result;
  905|      0|  }
  906|       |  // Otherwise, we choose the number base based on the flags.
  907|  2.54k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (907:7): [True: 0, False: 2.54k]
  ------------------
  908|      0|    strings_internal::ParsedFloat hex_parse =
  909|      0|        strings_internal::ParseFloat<16>(first, last, fmt_flags);
  910|      0|    if (hex_parse.end == nullptr) {
  ------------------
  |  Branch (910:9): [True: 0, False: 0]
  ------------------
  911|      0|      result.ec = std::errc::invalid_argument;
  912|      0|      return result;
  913|      0|    }
  914|      0|    result.ptr = hex_parse.end;
  915|      0|    if (HandleEdgeCase(hex_parse, negative, &value)) {
  ------------------
  |  Branch (915:9): [True: 0, False: 0]
  ------------------
  916|      0|      return result;
  917|      0|    }
  918|      0|    CalculatedFloat calculated =
  919|      0|        CalculateFromParsedHexadecimal<FloatType>(hex_parse);
  920|      0|    EncodeResult(calculated, negative, &result, &value);
  921|      0|    return result;
  922|  2.54k|  } else {
  923|  2.54k|    strings_internal::ParsedFloat decimal_parse =
  924|  2.54k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  925|  2.54k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (925:9): [True: 0, False: 2.54k]
  ------------------
  926|      0|      result.ec = std::errc::invalid_argument;
  927|      0|      return result;
  928|      0|    }
  929|  2.54k|    result.ptr = decimal_parse.end;
  930|  2.54k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (930:9): [True: 0, False: 2.54k]
  ------------------
  931|      0|      return result;
  932|      0|    }
  933|       |    // A nullptr subrange_begin means that the decimal_parse.mantissa is exact
  934|       |    // (not truncated), a precondition of the Eisel-Lemire algorithm.
  935|  2.54k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (935:9): [True: 2.54k, False: 0]
  ------------------
  936|  2.54k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (936:9): [True: 2.51k, False: 27]
  ------------------
  937|  2.51k|      return result;
  938|  2.51k|    }
  939|     27|    CalculatedFloat calculated =
  940|     27|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  941|     27|    EncodeResult(calculated, negative, &result, &value);
  942|     27|    return result;
  943|  2.54k|  }
  944|  2.54k|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_114HandleEdgeCaseIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_:
  360|  2.54k|                    FloatType* absl_nonnull value) {
  361|  2.54k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 0, False: 2.54k]
  ------------------
  362|       |    // A bug in gcc would cause the compiler to optimize away the buffer we are
  363|       |    // building below.  Declaring the buffer volatile avoids the issue, and has
  364|       |    // no measurable performance impact in microbenchmarks.
  365|       |    //
  366|       |    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=86113
  367|      0|    constexpr ptrdiff_t kNanBufferSize = 128;
  368|       |#if (defined(__GNUC__) && !defined(__clang__))
  369|       |    volatile char n_char_sequence[kNanBufferSize];
  370|       |#else
  371|      0|    char n_char_sequence[kNanBufferSize];
  372|      0|#endif
  373|      0|    if (input.subrange_begin == nullptr) {
  ------------------
  |  Branch (373:9): [True: 0, False: 0]
  ------------------
  374|      0|      n_char_sequence[0] = '\0';
  375|      0|    } else {
  376|      0|      ptrdiff_t nan_size = input.subrange_end - input.subrange_begin;
  377|      0|      nan_size = std::min(nan_size, kNanBufferSize - 1);
  378|      0|      std::copy_n(input.subrange_begin, nan_size, n_char_sequence);
  379|      0|      n_char_sequence[nan_size] = '\0';
  380|      0|    }
  381|      0|    char* nan_argument = const_cast<char*>(n_char_sequence);
  382|      0|    *value = negative ? -FloatTraits<FloatType>::MakeNan(nan_argument)
  ------------------
  |  Branch (382:14): [True: 0, False: 0]
  ------------------
  383|      0|                      : FloatTraits<FloatType>::MakeNan(nan_argument);
  384|      0|    return true;
  385|      0|  }
  386|  2.54k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (386:7): [True: 0, False: 2.54k]
  ------------------
  387|      0|    *value = negative ? -std::numeric_limits<FloatType>::infinity()
  ------------------
  |  Branch (387:14): [True: 0, False: 0]
  ------------------
  388|      0|                      : std::numeric_limits<FloatType>::infinity();
  389|      0|    return true;
  390|      0|  }
  391|  2.54k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (391:7): [True: 0, False: 2.54k]
  ------------------
  392|      0|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (392:14): [True: 0, False: 0]
  ------------------
  393|      0|    return true;
  394|      0|  }
  395|  2.54k|  return false;
  396|  2.54k|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_119NormalizedShiftSizeIdEEiii:
  335|     27|int NormalizedShiftSize(int mantissa_width, int binary_exponent) {
  336|     27|  const int normal_shift =
  337|     27|      mantissa_width - FloatTraits<FloatType>::kTargetMantissaBits;
  338|     27|  const int minimum_shift =
  339|     27|      FloatTraits<FloatType>::kMinNormalExponent - binary_exponent;
  340|     27|  return std::max(normal_shift, minimum_shift);
  341|     27|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_118ShiftRightAndRoundENS0_7uint128EibPb:
  453|     27|                            bool* absl_nonnull output_exact) {
  454|     27|  if (shift <= 0) {
  ------------------
  |  Branch (454:7): [True: 0, False: 27]
  ------------------
  455|      0|    *output_exact = input_exact;
  456|      0|    return static_cast<uint64_t>(value << -shift);
  457|      0|  }
  458|     27|  if (shift >= 128) {
  ------------------
  |  Branch (458:7): [True: 0, False: 27]
  ------------------
  459|       |    // Exponent is so small that we are shifting away all significant bits.
  460|       |    // Answer will not be representable, even as a subnormal, so return a zero
  461|       |    // mantissa (which represents underflow).
  462|      0|    *output_exact = true;
  463|      0|    return 0;
  464|      0|  }
  465|       |
  466|     27|  *output_exact = true;
  467|     27|  const uint128 shift_mask = (uint128(1) << shift) - 1;
  468|     27|  const uint128 halfway_point = uint128(1) << (shift - 1);
  469|       |
  470|     27|  const uint128 shifted_bits = value & shift_mask;
  471|     27|  value >>= shift;
  472|     27|  if (shifted_bits > halfway_point) {
  ------------------
  |  Branch (472:7): [True: 27, False: 0]
  ------------------
  473|       |    // Shifted bits greater than 10000... require rounding up.
  474|     27|    return static_cast<uint64_t>(value + 1);
  475|     27|  }
  476|      0|  if (shifted_bits == halfway_point) {
  ------------------
  |  Branch (476:7): [True: 0, False: 0]
  ------------------
  477|       |    // In exact mode, shifted bits of 10000... mean we're exactly halfway
  478|       |    // between two numbers, and we must round to even.  So only round up if
  479|       |    // the low bit of `value` is set.
  480|       |    //
  481|       |    // In inexact mode, the nonzero error means the actual value is greater
  482|       |    // than the halfway point and we must always round up.
  483|      0|    if ((value & 1) == 1 || !input_exact) {
  ------------------
  |  Branch (483:9): [True: 0, False: 0]
  |  Branch (483:29): [True: 0, False: 0]
  ------------------
  484|      0|      ++value;
  485|      0|    }
  486|      0|    return static_cast<uint64_t>(value);
  487|      0|  }
  488|      0|  if (!input_exact && shifted_bits == halfway_point - 1) {
  ------------------
  |  Branch (488:7): [True: 0, False: 0]
  |  Branch (488:23): [True: 0, False: 0]
  ------------------
  489|       |    // Rounding direction is unclear, due to error.
  490|      0|    *output_exact = false;
  491|      0|  }
  492|       |  // Otherwise, round down.
  493|      0|  return static_cast<uint64_t>(value);
  494|      0|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_128CalculatedFloatFromRawValuesIdEENS1_15CalculatedFloatEmi:
  580|     27|CalculatedFloat CalculatedFloatFromRawValues(uint64_t mantissa, int exponent) {
  581|     27|  CalculatedFloat result;
  582|     27|  if (mantissa == uint64_t{1} << FloatTraits<FloatType>::kTargetMantissaBits) {
  ------------------
  |  Branch (582:7): [True: 21, False: 6]
  ------------------
  583|     21|    mantissa >>= 1;
  584|     21|    exponent += 1;
  585|     21|  }
  586|     27|  if (exponent > FloatTraits<FloatType>::kMaxExponent) {
  ------------------
  |  Branch (586:7): [True: 0, False: 27]
  ------------------
  587|      0|    result.exponent = kOverflow;
  588|     27|  } else if (mantissa == 0) {
  ------------------
  |  Branch (588:14): [True: 0, False: 27]
  ------------------
  589|      0|    result.exponent = kUnderflow;
  590|     27|  } else {
  591|     27|    result.exponent = exponent;
  592|     27|    result.mantissa = mantissa;
  593|     27|  }
  594|     27|  return result;
  595|     27|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_112EncodeResultIdEEvRKNS1_15CalculatedFloatEbPNS0_17from_chars_resultEPT_:
  407|     27|                  FloatType* absl_nonnull value) {
  408|     27|  if (calculated.exponent == kOverflow) {
  ------------------
  |  Branch (408:7): [True: 0, False: 27]
  ------------------
  409|      0|    result->ec = std::errc::result_out_of_range;
  410|      0|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (410:14): [True: 0, False: 0]
  ------------------
  411|      0|                      : std::numeric_limits<FloatType>::max();
  412|      0|    return;
  413|     27|  } else if (calculated.mantissa == 0 || calculated.exponent == kUnderflow) {
  ------------------
  |  Branch (413:14): [True: 0, False: 27]
  |  Branch (413:42): [True: 0, False: 27]
  ------------------
  414|      0|    result->ec = std::errc::result_out_of_range;
  415|      0|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (415:14): [True: 0, False: 0]
  ------------------
  416|      0|    return;
  417|      0|  }
  418|     27|  *value = FloatTraits<FloatType>::Make(
  419|     27|      static_cast<typename FloatTraits<FloatType>::mantissa_t>(
  420|     27|          calculated.mantissa),
  421|     27|      calculated.exponent, negative);
  422|     27|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_111FloatTraitsIdE4MakeEmib:
  150|     27|  static double Make(mantissa_t mantissa, int exponent, bool sign) {
  151|       |#ifndef ABSL_BIT_PACK_FLOATS
  152|       |    // Support ldexp no matter which namespace it's in.  Some platforms
  153|       |    // incorrectly don't put it in namespace std.
  154|       |    using namespace std;  // NOLINT
  155|       |    return sign ? -ldexp(mantissa, exponent) : ldexp(mantissa, exponent);
  156|       |#else
  157|     27|    constexpr uint64_t kMantissaMask =
  158|     27|        (uint64_t{1} << (kTargetMantissaBits - 1)) - 1;
  159|     27|    uint64_t dbl = static_cast<uint64_t>(sign) << 63;
  160|     27|    if (mantissa > kMantissaMask) {
  ------------------
  |  Branch (160:9): [True: 27, False: 0]
  ------------------
  161|       |      // Normal value.
  162|       |      // Adjust by 1023 for the exponent representation bias, and an additional
  163|       |      // 52 due to the implied decimal point in the IEEE mantissa
  164|       |      // representation.
  165|     27|      dbl += static_cast<uint64_t>(exponent + 1023 + kTargetMantissaBits - 1)
  166|     27|             << 52;
  167|     27|      mantissa &= kMantissaMask;
  168|     27|    } else {
  169|       |      // subnormal value
  170|       |      assert(exponent == kMinNormalExponent);
  171|      0|    }
  172|     27|    dbl += mantissa;
  173|     27|    return absl::bit_cast<double>(dbl);
  174|     27|#endif  // ABSL_BIT_PACK_FLOATS
  175|     27|  }
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_111EiselLemireIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  687|  2.54k|                 FloatType* absl_nonnull value, std::errc* absl_nonnull ec) {
  688|  2.54k|  uint64_t man = input.mantissa;
  689|  2.54k|  int exp10 = input.exponent;
  690|  2.54k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (690:7): [True: 0, False: 2.54k]
  ------------------
  691|      0|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (691:14): [True: 0, False: 0]
  ------------------
  692|      0|    *ec = std::errc::result_out_of_range;
  693|      0|    return true;
  694|  2.54k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (694:14): [True: 0, False: 2.54k]
  ------------------
  695|       |    // Return max (a finite value) consistent with from_chars and DR 3081. For
  696|       |    // SimpleAtod and SimpleAtof, post-processing will return infinity.
  697|      0|    *value = negative ? -std::numeric_limits<FloatType>::max()
  ------------------
  |  Branch (697:14): [True: 0, False: 0]
  ------------------
  698|      0|                      : std::numeric_limits<FloatType>::max();
  699|      0|    *ec = std::errc::result_out_of_range;
  700|      0|    return true;
  701|      0|  }
  702|       |
  703|       |  // Assert kPower10TableMinInclusive <= exp10 < kPower10TableMaxExclusive.
  704|       |  // Equivalently, !Power10Underflow(exp10) and !Power10Overflow(exp10).
  705|  2.54k|  static_assert(
  706|  2.54k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  707|  2.54k|          kPower10TableMinInclusive,
  708|  2.54k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  709|  2.54k|  static_assert(
  710|  2.54k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  711|  2.54k|          kPower10TableMaxExclusive,
  712|  2.54k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  713|       |
  714|       |  // The terse (+) comments in this function body refer to sections of the
  715|       |  // https://nigeltao.github.io/blog/2020/eisel-lemire.html blog post.
  716|       |  //
  717|       |  // That blog post discusses double precision (11 exponent bits with a -1023
  718|       |  // bias, 52 mantissa bits), but the same approach applies to single precision
  719|       |  // (8 exponent bits with a -127 bias, 23 mantissa bits). Either way, the
  720|       |  // computation here happens with 64-bit values (e.g. man) or 128-bit values
  721|       |  // (e.g. x) before finally converting to 64- or 32-bit floating point.
  722|       |  //
  723|       |  // See also "Number Parsing at a Gigabyte per Second, Software: Practice and
  724|       |  // Experience 51 (8), 2021" (https://arxiv.org/abs/2101.11408) for detail.
  725|       |
  726|       |  // (+) Normalization.
  727|  2.54k|  int clz = countl_zero(man);
  728|  2.54k|  man <<= static_cast<unsigned int>(clz);
  729|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  730|  2.54k|  uint64_t ret_exp2 =
  731|  2.54k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  732|  2.54k|                            FloatTraits<FloatType>::kExponentBias - clz);
  733|       |
  734|       |  // (+) Multiplication.
  735|  2.54k|  uint128 x = static_cast<uint128>(man) *
  736|  2.54k|              static_cast<uint128>(
  737|  2.54k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  738|       |
  739|       |  // (+) Wider Approximation.
  740|  2.54k|  static constexpr uint64_t high64_mask =
  741|  2.54k|      FloatTraits<FloatType>::kEiselLemireMask;
  742|  2.54k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (742:7): [True: 35, False: 2.51k]
  ------------------
  743|     35|      (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(x)))) {
  ------------------
  |  Branch (743:7): [True: 35, False: 0]
  ------------------
  744|     35|    uint128 y =
  745|     35|        static_cast<uint128>(man) *
  746|     35|        static_cast<uint128>(
  747|     35|            kPower10MantissaLowTable[exp10 - kPower10TableMinInclusive]);
  748|     35|    x += Uint128High64(y);
  749|       |    // For example, parsing "4503599627370497.5" will take the if-true
  750|       |    // branch here (for double precision), since:
  751|       |    //  - x   = 0x8000000000000BFF_FFFFFFFFFFFFFFFF
  752|       |    //  - y   = 0x8000000000000BFF_7FFFFFFFFFFFF400
  753|       |    //  - man = 0xA000000000000F00
  754|       |    // Likewise, when parsing "0.0625" for single precision:
  755|       |    //  - x   = 0x7FFFFFFFFFFFFFFF_FFFFFFFFFFFFFFFF
  756|       |    //  - y   = 0x813FFFFFFFFFFFFF_8A00000000000000
  757|       |    //  - man = 0x9C40000000000000
  758|     35|    if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (758:9): [True: 33, False: 2]
  ------------------
  759|     33|        ((Uint128Low64(x) + 1) == 0) &&
  ------------------
  |  Branch (759:9): [True: 27, False: 6]
  ------------------
  760|     27|        (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(y)))) {
  ------------------
  |  Branch (760:9): [True: 27, False: 0]
  ------------------
  761|     27|      return false;
  762|     27|    }
  763|     35|  }
  764|       |
  765|       |  // (+) Shifting to 54 Bits (or for single precision, to 25 bits).
  766|  2.51k|  uint64_t msb = Uint128High64(x) >> 63;
  767|  2.51k|  uint64_t ret_man =
  768|  2.51k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  769|  2.51k|  ret_exp2 -= 1 ^ msb;
  770|       |
  771|       |  // (+) Half-way Ambiguity.
  772|       |  //
  773|       |  // For example, parsing "1e+23" will take the if-true branch here (for double
  774|       |  // precision), since:
  775|       |  //  - x       = 0x54B40B1F852BDA00_0000000000000000
  776|       |  //  - ret_man = 0x002A5A058FC295ED
  777|       |  // Likewise, when parsing "20040229.0" for single precision:
  778|       |  //  - x       = 0x4C72894000000000_0000000000000000
  779|       |  //  - ret_man = 0x000000000131CA25
  780|  2.51k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (780:7): [True: 0, False: 2.51k]
  |  Branch (780:33): [True: 0, False: 0]
  ------------------
  781|      0|      ((ret_man & 3) == 1)) {
  ------------------
  |  Branch (781:7): [True: 0, False: 0]
  ------------------
  782|      0|    return false;
  783|      0|  }
  784|       |
  785|       |  // (+) From 54 to 53 Bits (or for single precision, from 25 to 24 bits).
  786|  2.51k|  ret_man += ret_man & 1;  // Line From54a.
  787|  2.51k|  ret_man >>= 1;           // Line From54b.
  788|       |  // Incrementing ret_man (at line From54a) may have overflowed 54 bits (53
  789|       |  // bits after the right shift by 1 at line From54b), so adjust for that.
  790|       |  //
  791|       |  // For example, parsing "9223372036854775807" will take the if-true branch
  792|       |  // here (for double precision), since:
  793|       |  //  - ret_man = 0x0020000000000000 = (1 << 53)
  794|       |  // Likewise, when parsing "2147483647.0" for single precision:
  795|       |  //  - ret_man = 0x0000000001000000 = (1 << 24)
  796|  2.51k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (796:7): [True: 0, False: 2.51k]
  ------------------
  797|      0|    ret_exp2 += 1;
  798|       |    // Conceptually, we need a "ret_man >>= 1" in this if-block to balance
  799|       |    // incrementing ret_exp2 in the line immediately above. However, we only
  800|       |    // get here when line From54a overflowed (after adding a 1), so ret_man
  801|       |    // here is (1 << 53). Its low 53 bits are therefore all zeroes. The only
  802|       |    // remaining use of ret_man is to mask it with ((1 << 52) - 1), so only its
  803|       |    // low 52 bits matter. A "ret_man >>= 1" would have no effect in practice.
  804|       |    //
  805|       |    // We omit the "ret_man >>= 1", even if it is cheap (and this if-branch is
  806|       |    // rarely taken) and technically 'more correct', so that mutation tests
  807|       |    // that would otherwise modify or omit that "ret_man >>= 1" don't complain
  808|       |    // that such code mutations have no observable effect.
  809|      0|  }
  810|       |
  811|       |  // ret_exp2 is a uint64_t. Zero or underflow means that we're in subnormal
  812|       |  // space. max_exp2 (0x7FF for double precision, 0xFF for single precision) or
  813|       |  // above means that we're in Inf/NaN space.
  814|       |  //
  815|       |  // The if block is equivalent to (but has fewer branches than):
  816|       |  //   if ((ret_exp2 <= 0) || (ret_exp2 >= max_exp2)) { etc }
  817|       |  //
  818|       |  // For example, parsing "4.9406564584124654e-324" will take the if-true
  819|       |  // branch here, since ret_exp2 = -51.
  820|  2.51k|  static constexpr uint64_t max_exp2 =
  821|  2.51k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  822|  2.51k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (822:7): [True: 0, False: 2.51k]
  ------------------
  823|      0|    return false;
  824|      0|  }
  825|       |
  826|       |#ifndef ABSL_BIT_PACK_FLOATS
  827|       |  if (FloatTraits<FloatType>::kTargetBits == 64) {
  828|       |    *value = FloatTraits<FloatType>::Make(
  829|       |        (ret_man & 0x000FFFFFFFFFFFFFu) | 0x0010000000000000u,
  830|       |        static_cast<int>(ret_exp2) - 1023 - 52, negative);
  831|       |    return true;
  832|       |  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  833|       |    *value = FloatTraits<FloatType>::Make(
  834|       |        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu) | 0x00800000u,
  835|       |        static_cast<int>(ret_exp2) - 127 - 23, negative);
  836|       |    return true;
  837|       |  }
  838|       |#else
  839|  2.51k|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (839:7): [True: 2.51k, Folded]
  ------------------
  840|  2.51k|    uint64_t ret_bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFFu);
  841|  2.51k|    if (negative) {
  ------------------
  |  Branch (841:9): [True: 0, False: 2.51k]
  ------------------
  842|      0|      ret_bits |= 0x8000000000000000u;
  843|      0|    }
  844|  2.51k|    *value = static_cast<FloatType>(absl::bit_cast<double>(ret_bits));
  845|  2.51k|    return true;
  846|  2.51k|  } else if (FloatTraits<FloatType>::kTargetBits == 32) {
  ------------------
  |  Branch (846:14): [Folded, False: 0]
  ------------------
  847|      0|    uint32_t ret_bits = (static_cast<uint32_t>(ret_exp2) << 23) |
  848|      0|                        (static_cast<uint32_t>(ret_man) & 0x007FFFFFu);
  849|      0|    if (negative) {
  ------------------
  |  Branch (849:9): [True: 0, False: 0]
  ------------------
  850|      0|      ret_bits |= 0x80000000u;
  851|      0|    }
  852|      0|    *value = static_cast<FloatType>(absl::bit_cast<float>(ret_bits));
  853|      0|    return true;
  854|      0|  }
  855|      0|#endif  // ABSL_BIT_PACK_FLOATS
  856|      0|  return false;
  857|  2.51k|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_126CalculateFromParsedDecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  617|     27|    const strings_internal::ParsedFloat& parsed_decimal) {
  618|     27|  CalculatedFloat result;
  619|       |
  620|       |  // Large or small enough decimal exponents will always result in overflow
  621|       |  // or underflow.
  622|     27|  if (Power10Underflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (622:7): [True: 0, False: 27]
  ------------------
  623|      0|    result.exponent = kUnderflow;
  624|      0|    return result;
  625|     27|  } else if (Power10Overflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (625:14): [True: 0, False: 27]
  ------------------
  626|      0|    result.exponent = kOverflow;
  627|      0|    return result;
  628|      0|  }
  629|       |
  630|       |  // Otherwise convert our power of 10 into a power of 2 times an integer
  631|       |  // mantissa, and multiply this by our parsed decimal mantissa.
  632|     27|  uint128 wide_binary_mantissa = parsed_decimal.mantissa;
  633|     27|  wide_binary_mantissa *= Power10Mantissa(parsed_decimal.exponent);
  634|     27|  int binary_exponent = Power10Exponent(parsed_decimal.exponent);
  635|       |
  636|       |  // Discard bits that are inaccurate due to truncation error.  The magic
  637|       |  // `mantissa_width` constants below are justified in
  638|       |  // https://abseil.io/about/design/charconv. They represent the number of bits
  639|       |  // in `wide_binary_mantissa` that are guaranteed to be unaffected by error
  640|       |  // propagation.
  641|     27|  bool mantissa_exact;
  642|     27|  int mantissa_width;
  643|     27|  if (parsed_decimal.subrange_begin) {
  ------------------
  |  Branch (643:7): [True: 0, False: 27]
  ------------------
  644|       |    // Truncated mantissa
  645|      0|    mantissa_width = 58;
  646|      0|    mantissa_exact = false;
  647|      0|    binary_exponent +=
  648|      0|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  649|     27|  } else if (!Power10Exact(parsed_decimal.exponent)) {
  ------------------
  |  Branch (649:14): [True: 27, False: 0]
  ------------------
  650|       |    // Exact mantissa, truncated power of ten
  651|     27|    mantissa_width = 63;
  652|     27|    mantissa_exact = false;
  653|     27|    binary_exponent +=
  654|     27|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  655|     27|  } else {
  656|       |    // Product is exact
  657|      0|    mantissa_width = BitWidth(wide_binary_mantissa);
  658|      0|    mantissa_exact = true;
  659|      0|  }
  660|       |
  661|       |  // Shift into an FloatType-sized mantissa, and round to nearest.
  662|     27|  const int shift =
  663|     27|      NormalizedShiftSize<FloatType>(mantissa_width, binary_exponent);
  664|     27|  bool result_exact;
  665|     27|  binary_exponent += shift;
  666|     27|  uint64_t binary_mantissa = ShiftRightAndRound(wide_binary_mantissa, shift,
  667|     27|                                                mantissa_exact, &result_exact);
  668|     27|  if (!result_exact) {
  ------------------
  |  Branch (668:7): [True: 0, False: 27]
  ------------------
  669|       |    // We could not determine the rounding direction using int128 math.  Use
  670|       |    // full resolution math instead.
  671|      0|    if (MustRoundUp(binary_mantissa, binary_exponent, parsed_decimal)) {
  ------------------
  |  Branch (671:9): [True: 0, False: 0]
  ------------------
  672|      0|      binary_mantissa += 1;
  673|      0|    }
  674|      0|  }
  675|       |
  676|     27|  return CalculatedFloatFromRawValues<FloatType>(binary_mantissa,
  677|     27|                                                 binary_exponent);
  678|     27|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_116Power10UnderflowEi:
  288|     27|bool Power10Underflow(int n) { return n < kPower10TableMinInclusive; }
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_115Power10OverflowEi:
  284|     27|bool Power10Overflow(int n) { return n >= kPower10TableMaxExclusive; }
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_115Power10MantissaEi:
  270|     27|uint64_t Power10Mantissa(int n) {
  271|     27|  return kPower10MantissaHighTable[n - kPower10TableMinInclusive];
  272|     27|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_115Power10ExponentEi:
  274|     27|int Power10Exponent(int n) {
  275|       |  // The 217706 etc magic numbers encode the results as a formula instead of a
  276|       |  // table. Their equivalence (over the kPower10TableMinInclusive ..
  277|       |  // kPower10TableMaxExclusive range) is confirmed by
  278|       |  // https://github.com/google/wuffs/blob/315b2e52625ebd7b02d8fac13e3cd85ea374fb80/script/print-mpb-powers-of-10.go
  279|     27|  return (217706 * n >> 16) - 63;
  280|     27|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_118TruncateToBitWidthEiPNS0_7uint128E:
  348|     27|int TruncateToBitWidth(int bit_width, uint128* absl_nonnull value) {
  349|     27|  const int current_bit_width = BitWidth(*value);
  350|     27|  const int shift = current_bit_width - bit_width;
  351|     27|  *value >>= shift;
  352|     27|  return shift;
  353|     27|}
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_112Power10ExactEi:
  293|     27|bool Power10Exact(int n) { return n >= 0 && n <= 27; }
  ------------------
  |  Branch (293:35): [True: 0, False: 27]
  |  Branch (293:45): [True: 0, False: 0]
  ------------------
charconv.cc:_ZN4absl12lts_2026010712_GLOBAL__N_18BitWidthENS0_7uint128E:
  317|     27|int BitWidth(uint128 value) {
  318|     27|  if (Uint128High64(value) == 0) {
  ------------------
  |  Branch (318:7): [True: 0, False: 27]
  ------------------
  319|       |    // This static_cast is only needed when using a std::bit_width()
  320|       |    // implementation that does not have the fix for LWG 3656 applied.
  321|      0|    return static_cast<int>(bit_width(Uint128Low64(value)));
  322|      0|  }
  323|     27|  return 128 - countl_zero(Uint128High64(value));
  324|     27|}

_ZN4absl12lts_20260107anENS0_12chars_formatES1_:
   92|  15.2k|inline constexpr chars_format operator&(chars_format lhs, chars_format rhs) {
   93|  15.2k|  return static_cast<chars_format>(static_cast<int>(lhs) &
   94|  15.2k|                                   static_cast<int>(rhs));
   95|  15.2k|}

_ZN4absl12lts_2026010716strings_internal10ParseFloatILi10EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|  2.54k|                                         chars_format format_flags) {
  357|  2.54k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  2.54k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 0, False: 2.54k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  2.54k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 0, False: 2.54k]
  ------------------
  364|      0|    return result;
  365|      0|  }
  366|       |
  367|  2.54k|  const char* const mantissa_begin = begin;
  368|  5.07k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 5.07k, False: 0]
  |  Branch (368:25): [True: 2.52k, False: 2.54k]
  ------------------
  369|  2.52k|    ++begin;  // skip leading zeros
  370|  2.52k|  }
  371|  2.54k|  uint64_t mantissa = 0;
  372|       |
  373|  2.54k|  int exponent_adjustment = 0;
  374|  2.54k|  bool mantissa_is_inexact = false;
  375|  2.54k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  2.54k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  2.54k|  begin += pre_decimal_digits;
  378|  2.54k|  int digits_left;
  379|  2.54k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 2.54k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  2.54k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 0, False: 2.54k]
  ------------------
  383|       |    // We dropped some non-fraction digits on the floor.  Adjust our exponent
  384|       |    // to compensate.
  385|      0|    exponent_adjustment =
  386|      0|        static_cast<int>(pre_decimal_digits - MantissaDigitsMax<base>());
  387|      0|    digits_left = 0;
  388|  2.54k|  } else {
  389|  2.54k|    digits_left =
  390|  2.54k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  2.54k|  }
  392|  2.54k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 2.54k, False: 0]
  |  Branch (392:22): [True: 2.54k, False: 0]
  ------------------
  393|  2.54k|    ++begin;
  394|  2.54k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 2.52k, False: 21]
  ------------------
  395|       |      // If we haven't seen any nonzero digits yet, keep skipping zeros.  We
  396|       |      // have to adjust the exponent to reflect the changed place value.
  397|  2.52k|      const char* begin_zeros = begin;
  398|  2.52k|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 2.52k, False: 0]
  |  Branch (398:29): [True: 0, False: 2.52k]
  ------------------
  399|      0|        ++begin;
  400|      0|      }
  401|  2.52k|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|  2.52k|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 2.52k]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|  2.52k|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|  2.52k|    }
  408|  2.54k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  2.54k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  2.54k|    begin += post_decimal_digits;
  411|       |
  412|       |    // Since `mantissa` is an integer, each significant digit we read after
  413|       |    // the decimal point requires an adjustment to the exponent. "1.23e0" will
  414|       |    // be stored as `mantissa` == 123 and `exponent` == -2 (that is,
  415|       |    // "123e-2").
  416|  2.54k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 2.54k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  2.54k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 0, False: 2.54k]
  ------------------
  420|      0|      exponent_adjustment -= digits_left;
  421|  2.54k|    } else {
  422|  2.54k|      exponent_adjustment -= post_decimal_digits;
  423|  2.54k|    }
  424|  2.54k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  2.54k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 0, False: 2.54k]
  ------------------
  427|      0|    return result;
  428|      0|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  2.54k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 0, False: 2.54k]
  |  Branch (430:38): [True: 0, False: 0]
  ------------------
  431|      0|    return result;
  432|      0|  }
  433|       |
  434|  2.54k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 0, False: 2.54k]
  ------------------
  435|       |    // We dropped significant digits on the floor.  Handle this appropriately.
  436|      0|    if (base == 10) {
  ------------------
  |  Branch (436:9): [True: 0, Folded]
  ------------------
  437|       |      // If we truncated significant decimal digits, store the full range of the
  438|       |      // mantissa for future big integer math for exact rounding.
  439|      0|      result.subrange_begin = mantissa_begin;
  440|      0|      result.subrange_end = begin;
  441|      0|    } else if (base == 16) {
  ------------------
  |  Branch (441:16): [Folded, False: 0]
  ------------------
  442|       |      // If we truncated hex digits, reflect this fact by setting the low
  443|       |      // ("sticky") bit.  This allows for correct rounding in all cases.
  444|      0|      mantissa |= 1;
  445|      0|    }
  446|      0|  }
  447|  2.54k|  result.mantissa = mantissa;
  448|       |
  449|  2.54k|  const char* const exponent_begin = begin;
  450|  2.54k|  result.literal_exponent = 0;
  451|  2.54k|  bool found_exponent = false;
  452|  2.54k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 2.54k, False: 0]
  |  Branch (452:38): [True: 0, False: 2.54k]
  ------------------
  453|      0|      IsExponentCharacter<base>(*begin)) {
  ------------------
  |  Branch (453:7): [True: 0, False: 0]
  ------------------
  454|      0|    bool negative_exponent = false;
  455|      0|    ++begin;
  456|      0|    if (begin < end && *begin == '-') {
  ------------------
  |  Branch (456:9): [True: 0, False: 0]
  |  Branch (456:24): [True: 0, False: 0]
  ------------------
  457|      0|      negative_exponent = true;
  458|      0|      ++begin;
  459|      0|    } else if (begin < end && *begin == '+') {
  ------------------
  |  Branch (459:16): [True: 0, False: 0]
  |  Branch (459:31): [True: 0, False: 0]
  ------------------
  460|      0|      ++begin;
  461|      0|    }
  462|      0|    const char* const exponent_digits_begin = begin;
  463|       |    // Exponent is always expressed in decimal, even for hexadecimal floats.
  464|      0|    begin += ConsumeDigits<10>(begin, end, kDecimalExponentDigitsMax,
  465|      0|                               &result.literal_exponent, nullptr);
  466|      0|    if (begin == exponent_digits_begin) {
  ------------------
  |  Branch (466:9): [True: 0, False: 0]
  ------------------
  467|       |      // there were no digits where we expected an exponent.  We failed to read
  468|       |      // an exponent and should not consume the 'e' after all.  Rewind 'begin'.
  469|      0|      found_exponent = false;
  470|      0|      begin = exponent_begin;
  471|      0|    } else {
  472|      0|      found_exponent = true;
  473|      0|      if (negative_exponent) {
  ------------------
  |  Branch (473:11): [True: 0, False: 0]
  ------------------
  474|      0|        result.literal_exponent = -result.literal_exponent;
  475|      0|      }
  476|      0|    }
  477|      0|  }
  478|       |
  479|  2.54k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 2.54k, False: 0]
  |  Branch (479:26): [True: 0, False: 2.54k]
  ------------------
  480|       |    // Provided flags required an exponent, but none was found.  This results
  481|       |    // in a failure to scan.
  482|      0|    return result;
  483|      0|  }
  484|       |
  485|       |  // Success!
  486|  2.54k|  result.type = strings_internal::FloatType::kNumber;
  487|  2.54k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 2.54k, False: 0]
  ------------------
  488|  2.54k|    result.exponent = result.literal_exponent +
  489|  2.54k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  2.54k|  } else {
  491|      0|    result.exponent = 0;
  492|      0|  }
  493|  2.54k|  result.end = begin;
  494|  2.54k|  return result;
  495|  2.54k|}
charconv_parse.cc:_ZN4absl12lts_2026010712_GLOBAL__N_113AllowExponentENS0_12chars_formatE:
  122|  2.54k|bool AllowExponent(chars_format flags) {
  123|  2.54k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  124|  2.54k|  bool scientific =
  125|  2.54k|      (flags & chars_format::scientific) == chars_format::scientific;
  126|  2.54k|  return scientific || !fixed;
  ------------------
  |  Branch (126:10): [True: 2.54k, False: 0]
  |  Branch (126:24): [True: 0, False: 0]
  ------------------
  127|  2.54k|}
charconv_parse.cc:_ZN4absl12lts_2026010712_GLOBAL__N_115RequireExponentENS0_12chars_formatE:
  130|  2.54k|bool RequireExponent(chars_format flags) {
  131|  2.54k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  132|  2.54k|  bool scientific =
  133|  2.54k|      (flags & chars_format::scientific) == chars_format::scientific;
  134|  2.54k|  return scientific && !fixed;
  ------------------
  |  Branch (134:10): [True: 2.54k, False: 0]
  |  Branch (134:24): [True: 0, False: 2.54k]
  ------------------
  135|  2.54k|}
charconv_parse.cc:_ZN4absl12lts_2026010712_GLOBAL__N_117MantissaDigitsMaxILi10EEEiv:
  211|  7.63k|constexpr int MantissaDigitsMax<10>() {
  212|  7.63k|  return kDecimalMantissaDigitsMax;
  213|  7.63k|}
charconv_parse.cc:_ZN4absl12lts_2026010712_GLOBAL__N_110DigitLimitILi10EEEiv:
  220|  7.61k|constexpr int DigitLimit<10>() {
  221|  7.61k|  return kDecimalDigitLimit;
  222|  7.61k|}
charconv_parse.cc:_ZN4absl12lts_2026010712_GLOBAL__N_114DigitMagnitudeILi10EEEiv:
  229|  2.54k|constexpr int DigitMagnitude<10>() {
  230|  2.54k|  return 1;
  231|  2.54k|}
charconv_parse.cc:_ZN4absl12lts_2026010712_GLOBAL__N_118ParseInfinityOrNanEPKcS3_PNS0_16strings_internal11ParsedFloatE:
  298|  2.54k|                        strings_internal::ParsedFloat* out) {
  299|  2.54k|  if (end - begin < 3) {
  ------------------
  |  Branch (299:7): [True: 0, False: 2.54k]
  ------------------
  300|      0|    return false;
  301|      0|  }
  302|  2.54k|  switch (*begin) {
  303|      0|    case 'i':
  ------------------
  |  Branch (303:5): [True: 0, False: 2.54k]
  ------------------
  304|      0|    case 'I': {
  ------------------
  |  Branch (304:5): [True: 0, False: 2.54k]
  ------------------
  305|       |      // An infinity string consists of the characters "inf" or "infinity",
  306|       |      // case insensitive.
  307|      0|      if (strings_internal::memcasecmp(begin + 1, "nf", 2) != 0) {
  ------------------
  |  Branch (307:11): [True: 0, False: 0]
  ------------------
  308|      0|        return false;
  309|      0|      }
  310|      0|      out->type = strings_internal::FloatType::kInfinity;
  311|      0|      if (end - begin >= 8 &&
  ------------------
  |  Branch (311:11): [True: 0, False: 0]
  ------------------
  312|      0|          strings_internal::memcasecmp(begin + 3, "inity", 5) == 0) {
  ------------------
  |  Branch (312:11): [True: 0, False: 0]
  ------------------
  313|      0|        out->end = begin + 8;
  314|      0|      } else {
  315|      0|        out->end = begin + 3;
  316|      0|      }
  317|      0|      return true;
  318|      0|    }
  319|      0|    case 'n':
  ------------------
  |  Branch (319:5): [True: 0, False: 2.54k]
  ------------------
  320|      0|    case 'N': {
  ------------------
  |  Branch (320:5): [True: 0, False: 2.54k]
  ------------------
  321|       |      // A NaN consists of the characters "nan", case insensitive, optionally
  322|       |      // followed by a parenthesized sequence of zero or more alphanumeric
  323|       |      // characters and/or underscores.
  324|      0|      if (strings_internal::memcasecmp(begin + 1, "an", 2) != 0) {
  ------------------
  |  Branch (324:11): [True: 0, False: 0]
  ------------------
  325|      0|        return false;
  326|      0|      }
  327|      0|      out->type = strings_internal::FloatType::kNan;
  328|      0|      out->end = begin + 3;
  329|       |      // NaN is allowed to be followed by a parenthesized string, consisting of
  330|       |      // only the characters [a-zA-Z0-9_].  Match that if it's present.
  331|      0|      begin += 3;
  332|      0|      if (begin < end && *begin == '(') {
  ------------------
  |  Branch (332:11): [True: 0, False: 0]
  |  Branch (332:26): [True: 0, False: 0]
  ------------------
  333|      0|        const char* nan_begin = begin + 1;
  334|      0|        while (nan_begin < end && IsNanChar(*nan_begin)) {
  ------------------
  |  Branch (334:16): [True: 0, False: 0]
  |  Branch (334:35): [True: 0, False: 0]
  ------------------
  335|      0|          ++nan_begin;
  336|      0|        }
  337|      0|        if (nan_begin < end && *nan_begin == ')') {
  ------------------
  |  Branch (337:13): [True: 0, False: 0]
  |  Branch (337:32): [True: 0, False: 0]
  ------------------
  338|       |          // We found an extra NaN specifier range
  339|      0|          out->subrange_begin = begin + 1;
  340|      0|          out->subrange_end = nan_begin;
  341|      0|          out->end = nan_begin + 1;
  342|      0|        }
  343|      0|      }
  344|      0|      return true;
  345|      0|    }
  346|  2.54k|    default:
  ------------------
  |  Branch (346:5): [True: 2.54k, False: 0]
  ------------------
  347|  2.54k|      return false;
  348|  2.54k|  }
  349|  2.54k|}
charconv_parse.cc:_ZN4absl12lts_2026010712_GLOBAL__N_113ConsumeDigitsILi10EmEEiPKcS4_iPT0_Pb:
  250|  5.09k|                  bool* dropped_nonzero_digit) {
  251|  5.09k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 5.09k, Folded]
  ------------------
  252|  5.09k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  5.09k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded, False: 0]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  5.09k|  const char* const original_begin = begin;
  257|       |
  258|       |  // Skip leading zeros, but only if *out is zero.
  259|       |  // They don't cause an overflow so we don't have to count them for
  260|       |  // `max_digits`.
  261|  5.09k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 5.07k, False: 21]
  |  Branch (261:19): [True: 5.07k, False: 0]
  |  Branch (261:35): [True: 0, False: 5.07k]
  ------------------
  262|       |
  263|  5.09k|  T accumulator = *out;
  264|  5.09k|  const char* significant_digits_end =
  265|  5.09k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 0, False: 5.09k]
  ------------------
  266|  20.3k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 17.8k, False: 2.54k]
  |  Branch (266:44): [True: 15.2k, False: 2.54k]
  ------------------
  267|       |    // Do not guard against *out overflow; max_digits was chosen to avoid this.
  268|       |    // Do assert against it, to detect problems in debug builds.
  269|  15.2k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  15.2k|    assert(accumulator * base >= accumulator);
  271|  15.2k|    accumulator *= base;
  272|  15.2k|    assert(accumulator + digit >= accumulator);
  273|  15.2k|    accumulator += digit;
  274|  15.2k|    ++begin;
  275|  15.2k|  }
  276|  5.09k|  bool dropped_nonzero = false;
  277|  5.09k|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 2.54k, False: 2.54k]
  |  Branch (277:25): [True: 0, False: 2.54k]
  ------------------
  278|      0|    dropped_nonzero = dropped_nonzero || (*begin != '0');
  ------------------
  |  Branch (278:23): [True: 0, False: 0]
  |  Branch (278:42): [True: 0, False: 0]
  ------------------
  279|      0|    ++begin;
  280|      0|  }
  281|  5.09k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 0, False: 5.09k]
  |  Branch (281:26): [True: 0, False: 0]
  ------------------
  282|      0|    *dropped_nonzero_digit = true;
  283|      0|  }
  284|  5.09k|  *out = accumulator;
  285|  5.09k|  return static_cast<int>(begin - original_begin);
  286|  5.09k|}
charconv_parse.cc:_ZN4absl12lts_2026010712_GLOBAL__N_17IsDigitILi10EEEbc:
  183|  20.3k|bool IsDigit<10>(char ch) {
  184|  20.3k|  return ch >= '0' && ch <= '9';
  ------------------
  |  Branch (184:10): [True: 15.2k, False: 5.09k]
  |  Branch (184:23): [True: 15.2k, False: 0]
  ------------------
  185|  20.3k|}
charconv_parse.cc:_ZN4absl12lts_2026010712_GLOBAL__N_17ToDigitILi10EEEjc:
  192|  15.2k|unsigned ToDigit<10>(char ch) {
  193|  15.2k|  return static_cast<unsigned>(ch - '0');
  194|  15.2k|}

_ZN4absl12lts_2026010716strings_internal10memcasecmpEPKcS3_m:
   25|  13.1k|int memcasecmp(const char* s1, const char* s2, size_t len) {
   26|  13.1k|  const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1);
   27|  13.1k|  const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2);
   28|       |
   29|  74.2k|  for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (29:22): [True: 61.1k, False: 13.1k]
  ------------------
   30|  61.1k|    unsigned char c1 = us1[i];
   31|  61.1k|    unsigned char c2 = us2[i];
   32|       |    // If bytes are the same, they will be the same when converted to lower.
   33|       |    // So we only need to convert if bytes are not equal.
   34|       |    // NOTE(b/308193381): We do not use `absl::ascii_tolower` here in order
   35|       |    // to avoid its lookup table and improve performance.
   36|  61.1k|    if (c1 != c2) {
  ------------------
  |  Branch (36:9): [True: 0, False: 61.1k]
  ------------------
   37|      0|      c1 = c1 >= 'A' && c1 <= 'Z' ? c1 - 'A' + 'a' : c1;
  ------------------
  |  Branch (37:12): [True: 0, False: 0]
  |  Branch (37:25): [True: 0, False: 0]
  ------------------
   38|      0|      c2 = c2 >= 'A' && c2 <= 'Z' ? c2 - 'A' + 'a' : c2;
  ------------------
  |  Branch (38:12): [True: 0, False: 0]
  |  Branch (38:25): [True: 0, False: 0]
  ------------------
   39|      0|      const int diff = int{c1} - int{c2};
   40|      0|      if (diff != 0) return diff;
  ------------------
  |  Branch (40:11): [True: 0, False: 0]
  ------------------
   41|      0|    }
   42|  61.1k|  }
   43|  13.1k|  return 0;
   44|  13.1k|}

_ZN4absl12lts_2026010719str_format_internal13ConvertIntArgIcEEbT_NS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  349|   619k|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  350|   619k|  using U = typename MakeUnsigned<T>::type;
  351|   619k|  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|   619k|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  358|   619k|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (358:5): [True: 619k, False: 0]
  ------------------
  359|   619k|      return (std::is_same<T, wchar_t>::value ||
  ------------------
  |  Branch (359:15): [Folded, False: 619k]
  ------------------
  360|   619k|              (conv.length_mod() == LengthMod::l))
  ------------------
  |  Branch (360:15): [True: 0, False: 619k]
  ------------------
  361|   619k|                 ? ConvertWCharTImpl(static_cast<wchar_t>(v), conv, sink)
  362|   619k|                 : ConvertCharImpl(static_cast<char>(v), conv, sink);
  363|       |
  364|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::o):
  ------------------
  |  Branch (364:5): [True: 0, False: 619k]
  ------------------
  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: 619k]
  ------------------
  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: 619k]
  ------------------
  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: 619k]
  ------------------
  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: 619k]
  ------------------
  380|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (380:5): [True: 0, False: 619k]
  ------------------
  381|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (381:5): [True: 0, False: 619k]
  ------------------
  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: 619k]
  ------------------
  386|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (386:5): [True: 0, False: 619k]
  ------------------
  387|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (387:5): [True: 0, False: 619k]
  ------------------
  388|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (388:5): [True: 0, False: 619k]
  ------------------
  389|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (389:5): [True: 0, False: 619k]
  ------------------
  390|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (390:5): [True: 0, False: 619k]
  ------------------
  391|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (391:5): [True: 0, False: 619k]
  ------------------
  392|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (392:5): [True: 0, False: 619k]
  ------------------
  393|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  394|       |
  395|      0|    default:
  ------------------
  |  Branch (395:5): [True: 0, False: 619k]
  ------------------
  396|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  270|      0|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  397|   619k|  }
  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|  22.0k|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  350|  22.0k|  using U = typename MakeUnsigned<T>::type;
  351|  22.0k|  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|  22.0k|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  358|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (358:5): [True: 0, False: 22.0k]
  ------------------
  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: 22.0k]
  ------------------
  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: 22.0k]
  ------------------
  369|      0|      as_digits.PrintAsHexLower(static_cast<U>(v));
  370|      0|      break;
  371|  22.0k|    case static_cast<uint8_t>(FormatConversionCharInternal::X):
  ------------------
  |  Branch (371:5): [True: 22.0k, False: 0]
  ------------------
  372|  22.0k|      as_digits.PrintAsHexUpper(static_cast<U>(v));
  373|  22.0k|      break;
  374|       |
  375|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::u):
  ------------------
  |  Branch (375:5): [True: 0, False: 22.0k]
  ------------------
  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: 22.0k]
  ------------------
  380|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (380:5): [True: 0, False: 22.0k]
  ------------------
  381|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (381:5): [True: 0, False: 22.0k]
  ------------------
  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: 22.0k]
  ------------------
  386|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (386:5): [True: 0, False: 22.0k]
  ------------------
  387|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (387:5): [True: 0, False: 22.0k]
  ------------------
  388|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (388:5): [True: 0, False: 22.0k]
  ------------------
  389|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (389:5): [True: 0, False: 22.0k]
  ------------------
  390|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (390:5): [True: 0, False: 22.0k]
  ------------------
  391|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (391:5): [True: 0, False: 22.0k]
  ------------------
  392|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (392:5): [True: 0, False: 22.0k]
  ------------------
  393|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  394|       |
  395|      0|    default:
  ------------------
  |  Branch (395:5): [True: 0, False: 22.0k]
  ------------------
  396|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  270|      0|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  397|  22.0k|  }
  398|       |
  399|  22.0k|  if (conv.is_basic()) {
  ------------------
  |  Branch (399:7): [True: 0, False: 22.0k]
  ------------------
  400|      0|    sink->Append(as_digits.with_neg_and_zero());
  401|      0|    return true;
  402|      0|  }
  403|  22.0k|  return ConvertIntImplInnerSlow(as_digits, conv, sink);
  404|  22.0k|}
_ZN4absl12lts_2026010719str_format_internal13ConvertIntArgIiEEbT_NS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  349|  1.86M|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  350|  1.86M|  using U = typename MakeUnsigned<T>::type;
  351|  1.86M|  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.86M|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  358|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (358:5): [True: 0, False: 1.86M]
  ------------------
  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.86M]
  ------------------
  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.86M]
  ------------------
  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.86M]
  ------------------
  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.86M]
  ------------------
  376|      0|      as_digits.PrintAsDec(static_cast<U>(v));
  377|      0|      break;
  378|       |
  379|  1.86M|    case static_cast<uint8_t>(FormatConversionCharInternal::d):
  ------------------
  |  Branch (379:5): [True: 1.86M, False: 0]
  ------------------
  380|  1.86M|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (380:5): [True: 0, False: 1.86M]
  ------------------
  381|  1.86M|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (381:5): [True: 0, False: 1.86M]
  ------------------
  382|  1.86M|      as_digits.PrintAsDec(v);
  383|  1.86M|      break;
  384|       |
  385|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::a):
  ------------------
  |  Branch (385:5): [True: 0, False: 1.86M]
  ------------------
  386|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (386:5): [True: 0, False: 1.86M]
  ------------------
  387|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (387:5): [True: 0, False: 1.86M]
  ------------------
  388|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (388:5): [True: 0, False: 1.86M]
  ------------------
  389|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (389:5): [True: 0, False: 1.86M]
  ------------------
  390|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (390:5): [True: 0, False: 1.86M]
  ------------------
  391|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (391:5): [True: 0, False: 1.86M]
  ------------------
  392|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (392:5): [True: 0, False: 1.86M]
  ------------------
  393|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  394|       |
  395|      0|    default:
  ------------------
  |  Branch (395:5): [True: 0, False: 1.86M]
  ------------------
  396|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  270|      0|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  397|  1.86M|  }
  398|       |
  399|  1.86M|  if (conv.is_basic()) {
  ------------------
  |  Branch (399:7): [True: 10.1k, False: 1.85M]
  ------------------
  400|  10.1k|    sink->Append(as_digits.with_neg_and_zero());
  401|  10.1k|    return true;
  402|  10.1k|  }
  403|  1.85M|  return ConvertIntImplInnerSlow(as_digits, conv, sink);
  404|  1.86M|}
_ZN4absl12lts_2026010719str_format_internal17FormatConvertImplEcNS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  537|   619k|                                    FormatSinkImpl *sink) {
  538|   619k|  return {ConvertIntArg(v, conv, sink)};
  539|   619k|}
_ZN4absl12lts_2026010719str_format_internal17FormatConvertImplEhNS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  554|  22.0k|                                        FormatSinkImpl *sink) {
  555|  22.0k|  return {ConvertIntArg(v, conv, sink)};
  556|  22.0k|}
_ZN4absl12lts_2026010719str_format_internal17FormatConvertImplEiNS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  569|  1.86M|                                        FormatSinkImpl *sink) {
  570|  1.86M|  return {ConvertIntArg(v, conv, sink)};
  571|  1.86M|}
arg.cc:_ZNK4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits17with_neg_and_zeroEv:
  174|  10.1k|  string_view with_neg_and_zero() const { return {start_, size_}; }
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_115ConvertCharImplEcNS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  225|   619k|                     FormatSinkImpl* sink) {
  226|   619k|  size_t fill = 0;
  227|   619k|  if (conv.width() >= 0)
  ------------------
  |  Branch (227:7): [True: 0, False: 619k]
  ------------------
  228|      0|    fill = static_cast<size_t>(conv.width());
  229|   619k|  ReducePadding(1, &fill);
  230|   619k|  if (!conv.has_left_flag()) sink->Append(fill, ' ');
  ------------------
  |  Branch (230:7): [True: 619k, False: 0]
  ------------------
  231|   619k|  sink->Append(1, v);
  232|   619k|  if (conv.has_left_flag()) sink->Append(fill, ' ');
  ------------------
  |  Branch (232:7): [True: 0, False: 619k]
  ------------------
  233|   619k|  return true;
  234|   619k|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_113ReducePaddingEmPm:
   53|  2.50M|void ReducePadding(size_t n, size_t *capacity) {
   54|  2.50M|  *capacity = Excess(n, *capacity);
   55|  2.50M|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_123ConvertIntImplInnerSlowERKNS2_9IntDigitsENS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  238|  1.88M|                             FormatSinkImpl *sink) {
  239|       |  // Print as a sequence of Substrings:
  240|       |  //   [left_spaces][sign][base_indicator][zeroes][formatted][right_spaces]
  241|  1.88M|  size_t fill = 0;
  242|  1.88M|  if (conv.width() >= 0)
  ------------------
  |  Branch (242:7): [True: 1.88M, False: 0]
  ------------------
  243|  1.88M|    fill = static_cast<size_t>(conv.width());
  244|       |
  245|  1.88M|  string_view formatted = as_digits.without_neg_or_zero();
  246|  1.88M|  ReducePadding(formatted, &fill);
  247|       |
  248|  1.88M|  string_view sign = SignColumn(as_digits.is_negative(), conv);
  249|  1.88M|  ReducePadding(sign, &fill);
  250|       |
  251|  1.88M|  string_view base_indicator = BaseIndicator(as_digits, conv);
  252|  1.88M|  ReducePadding(base_indicator, &fill);
  253|       |
  254|  1.88M|  bool precision_specified = conv.precision() >= 0;
  255|  1.88M|  size_t precision =
  256|  1.88M|      precision_specified ? static_cast<size_t>(conv.precision()) : size_t{1};
  ------------------
  |  Branch (256:7): [True: 0, False: 1.88M]
  ------------------
  257|       |
  258|  1.88M|  if (conv.has_alt_flag() &&
  ------------------
  |  Branch (258:7): [True: 0, False: 1.88M]
  ------------------
  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|  1.88M|  size_t num_zeroes = Excess(formatted.size(), precision);
  270|  1.88M|  ReducePadding(num_zeroes, &fill);
  271|       |
  272|  1.88M|  size_t num_left_spaces = !conv.has_left_flag() ? fill : 0;
  ------------------
  |  Branch (272:28): [True: 1.88M, False: 0]
  ------------------
  273|  1.88M|  size_t num_right_spaces = conv.has_left_flag() ? fill : 0;
  ------------------
  |  Branch (273:29): [True: 0, False: 1.88M]
  ------------------
  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|  1.88M|  if (!precision_specified && conv.has_zero_flag()) {
  ------------------
  |  Branch (278:7): [True: 1.88M, False: 0]
  |  Branch (278:31): [True: 1.26M, False: 619k]
  ------------------
  279|  1.26M|    num_zeroes += num_left_spaces;
  280|  1.26M|    num_left_spaces = 0;
  281|  1.26M|  }
  282|       |
  283|  1.88M|  sink->Append(num_left_spaces, ' ');
  284|  1.88M|  sink->Append(sign);
  285|  1.88M|  sink->Append(base_indicator);
  286|  1.88M|  sink->Append(num_zeroes, '0');
  287|  1.88M|  sink->Append(formatted);
  288|  1.88M|  sink->Append(num_right_spaces, ' ');
  289|  1.88M|  return true;
  290|  1.88M|}
arg.cc:_ZNK4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits19without_neg_or_zeroEv:
  178|  1.88M|  string_view without_neg_or_zero() const {
  179|  1.88M|    static_assert('-' < '0', "The check below verifies both.");
  180|  1.88M|    size_t advance = start_[0] <= '0' ? 1 : 0;
  ------------------
  |  Branch (180:22): [True: 86, False: 1.88M]
  ------------------
  181|  1.88M|    return {start_ + advance, size_ - advance};
  182|  1.88M|  }
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_113ReducePaddingENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPm:
   48|  5.64M|void ReducePadding(string_view s, size_t *capacity) {
   49|  5.64M|  *capacity = Excess(s.size(), *capacity);
   50|  5.64M|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_110SignColumnEbNS1_24FormatConversionSpecImplE:
  213|  1.88M|string_view SignColumn(bool neg, const FormatConversionSpecImpl conv) {
  214|  1.88M|  if (conv.conversion_char() == FormatConversionCharInternal::d ||
  ------------------
  |  Branch (214:7): [True: 1.85M, False: 22.0k]
  ------------------
  215|  1.85M|      conv.conversion_char() == FormatConversionCharInternal::i) {
  ------------------
  |  Branch (215:7): [True: 0, False: 22.0k]
  ------------------
  216|  1.85M|    if (neg) return "-";
  ------------------
  |  Branch (216:9): [True: 0, False: 1.85M]
  ------------------
  217|  1.85M|    if (conv.has_show_pos_flag()) return "+";
  ------------------
  |  Branch (217:9): [True: 0, False: 1.85M]
  ------------------
  218|  1.85M|    if (conv.has_sign_col_flag()) return " ";
  ------------------
  |  Branch (218:9): [True: 0, False: 1.85M]
  ------------------
  219|  1.85M|  }
  220|  1.88M|  return {};
  221|  1.88M|}
arg.cc:_ZNK4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits11is_negativeEv:
  184|  1.88M|  bool is_negative() const { return start_[0] == '-'; }
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_113BaseIndicatorERKNS2_9IntDigitsENS1_24FormatConversionSpecImplE:
  196|  1.88M|                          const FormatConversionSpecImpl conv) {
  197|       |  // always show 0x for %p.
  198|  1.88M|  bool alt = conv.has_alt_flag() ||
  ------------------
  |  Branch (198:14): [True: 0, False: 1.88M]
  ------------------
  199|  1.88M|             conv.conversion_char() == FormatConversionCharInternal::p;
  ------------------
  |  Branch (199:14): [True: 0, False: 1.88M]
  ------------------
  200|  1.88M|  bool hex = (conv.conversion_char() == FormatConversionCharInternal::x ||
  ------------------
  |  Branch (200:15): [True: 0, False: 1.88M]
  ------------------
  201|  1.88M|              conv.conversion_char() == FormatConversionCharInternal::X ||
  ------------------
  |  Branch (201:15): [True: 22.0k, False: 1.85M]
  ------------------
  202|  1.85M|              conv.conversion_char() == FormatConversionCharInternal::p);
  ------------------
  |  Branch (202:15): [True: 0, False: 1.85M]
  ------------------
  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|  1.88M|  if (alt && hex && !as_digits.without_neg_or_zero().empty()) {
  ------------------
  |  Branch (206:7): [True: 0, False: 1.88M]
  |  Branch (206:7): [True: 0, False: 1.88M]
  |  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|  1.88M|  return {};
  211|  1.88M|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits15PrintAsHexUpperIhEEvT_:
  159|  22.0k|  void PrintAsHexUpper(T v) {
  160|  22.0k|    static_assert(!IsSigned<T>::value, "");
  161|  22.0k|    char *p = storage_ + sizeof(storage_);
  162|       |
  163|       |    // kHexTable is only lowercase, so do it manually for uppercase.
  164|  42.6k|    do {
  165|  42.6k|      *--p = "0123456789ABCDEF"[static_cast<size_t>(v) & 15];
  166|  42.6k|      v >>= 4;
  167|  42.6k|    } while (v);
  ------------------
  |  Branch (167:14): [True: 20.6k, False: 22.0k]
  ------------------
  168|  22.0k|    start_ = p;
  169|  22.0k|    size_ = static_cast<size_t>(storage_ + sizeof(storage_) - p);
  170|  22.0k|  }
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits10PrintAsDecIiEEvT_:
   97|  1.86M|  void PrintAsDec(T v) {
   98|  1.86M|    static_assert(std::is_integral<T>::value, "");
   99|  1.86M|    start_ = storage_;
  100|  1.86M|    size_ = static_cast<size_t>(numbers_internal::FastIntToBuffer(v, storage_) -
  101|  1.86M|                                storage_);
  102|  1.86M|  }

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

_ZN4absl12lts_2026010719str_format_internal13FormatUntypedENS1_17FormatRawSinkImplENS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  214|   646k|                   absl::Span<const FormatArgImpl> args) {
  215|   646k|  FormatSinkImpl sink(raw_sink);
  216|   646k|  using Converter = DefaultConverter;
  217|   646k|  return ConvertAll(format, args, Converter(&sink));
  218|   646k|}
_ZN4absl12lts_2026010719str_format_internal10FormatPackENS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  235|  27.0k|                       absl::Span<const FormatArgImpl> args) {
  236|  27.0k|  std::string out;
  237|  27.0k|  if (ABSL_PREDICT_FALSE(!FormatUntyped(&out, format, args))) {
  ------------------
  |  |  189|  27.0k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 27.0k]
  |  |  |  Branch (189:49): [Folded, False: 27.0k]
  |  |  |  Branch (189:58): [True: 0, False: 27.0k]
  |  |  ------------------
  ------------------
  238|      0|    out.clear();
  239|      0|  }
  240|  27.0k|  return out;
  241|  27.0k|}
_ZN4absl12lts_2026010719str_format_internal8SnprintFEPcmNS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEE:
  262|   619k|             absl::Span<const FormatArgImpl> args) {
  263|   619k|  BufferRawSink sink(output, size ? size - 1 : 0);
  ------------------
  |  Branch (263:30): [True: 619k, False: 0]
  ------------------
  264|   619k|  if (!FormatUntyped(&sink, format, args)) {
  ------------------
  |  Branch (264:7): [True: 0, False: 619k]
  ------------------
  265|      0|    errno = EINVAL;
  266|      0|    return -1;
  267|      0|  }
  268|   619k|  size_t total = sink.total_written();
  269|   619k|  if (size) output[std::min(total, size - 1)] = 0;
  ------------------
  |  Branch (269:7): [True: 619k, False: 0]
  ------------------
  270|   619k|  return static_cast<int>(total);
  271|   619k|}
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_110ArgContextC2ENS0_4SpanIKNS1_13FormatArgImplEEE:
   55|   646k|  explicit ArgContext(absl::Span<const FormatArgImpl> pack) : pack_(pack) {}
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_110ArgContext4BindEPKNS1_17UnboundConversionEPNS1_15BoundConversionE:
   70|  2.51M|                             BoundConversion* bound) {
   71|  2.51M|  const FormatArgImpl* arg = nullptr;
   72|  2.51M|  int arg_position = unbound->arg_position;
   73|  2.51M|  if (static_cast<size_t>(arg_position - 1) >= pack_.size()) return false;
  ------------------
  |  Branch (73:7): [True: 0, False: 2.51M]
  ------------------
   74|  2.51M|  arg = &pack_[static_cast<size_t>(arg_position - 1)];  // 1-based
   75|       |
   76|  2.51M|  if (unbound->flags != Flags::kBasic) {
  ------------------
  |  Branch (76:7): [True: 1.88M, False: 630k]
  ------------------
   77|  1.88M|    int width = unbound->width.value();
   78|  1.88M|    bool force_left = false;
   79|  1.88M|    if (unbound->width.is_from_arg()) {
  ------------------
  |  Branch (79:9): [True: 0, False: 1.88M]
  ------------------
   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|  1.88M|    int precision = unbound->precision.value();
   92|  1.88M|    if (unbound->precision.is_from_arg()) {
  ------------------
  |  Branch (92:9): [True: 0, False: 1.88M]
  ------------------
   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|  1.88M|    FormatConversionSpecImplFriend::SetWidth(width, bound);
   99|  1.88M|    FormatConversionSpecImplFriend::SetPrecision(precision, bound);
  100|       |
  101|  1.88M|    if (force_left) {
  ------------------
  |  Branch (101:9): [True: 0, False: 1.88M]
  ------------------
  102|      0|      FormatConversionSpecImplFriend::SetFlags(unbound->flags | Flags::kLeft,
  103|      0|                                               bound);
  104|  1.88M|    } else {
  105|  1.88M|      FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
  106|  1.88M|    }
  107|       |
  108|  1.88M|    FormatConversionSpecImplFriend::SetLengthMod(unbound->length_mod, bound);
  109|  1.88M|  } else {
  110|   630k|    FormatConversionSpecImplFriend::SetFlags(unbound->flags, bound);
  111|   630k|    FormatConversionSpecImplFriend::SetWidth(-1, bound);
  112|   630k|    FormatConversionSpecImplFriend::SetPrecision(-1, bound);
  113|   630k|  }
  114|  2.51M|  FormatConversionSpecImplFriend::SetConversionChar(unbound->conv, bound);
  115|  2.51M|  bound->set_arg(arg);
  116|  2.51M|  return true;
  117|  2.51M|}
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_116DefaultConverterC2EPNS1_14FormatSinkImplE:
  154|   646k|  explicit DefaultConverter(FormatSinkImpl* sink) : sink_(sink) {}
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_110ConvertAllINS2_16DefaultConverterEEEbNS1_21UntypedFormatSpecImplENS0_4SpanIKNS1_13FormatArgImplEEET_:
  142|   646k|                absl::Span<const FormatArgImpl> args, Converter converter) {
  143|   646k|  if (format.has_parsed_conversion()) {
  ------------------
  |  Branch (143:7): [True: 0, False: 646k]
  ------------------
  144|      0|    return format.parsed_conversion()->ProcessFormat(
  145|      0|        ConverterConsumer<Converter>(converter, args));
  146|   646k|  } else {
  147|   646k|    return ParseFormatString(format.str(),
  148|   646k|                             ConverterConsumer<Converter>(converter, args));
  149|   646k|  }
  150|   646k|}
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEE10ConvertOneERKNS1_17UnboundConversionENSt3__117basic_string_viewIcNS9_11char_traitsIcEEEE:
  129|  2.51M|  bool ConvertOne(const UnboundConversion& conv, string_view conv_string) {
  130|  2.51M|    BoundConversion bound;
  131|  2.51M|    if (!arg_context_.Bind(&conv, &bound)) return false;
  ------------------
  |  Branch (131:9): [True: 0, False: 2.51M]
  ------------------
  132|  2.51M|    return converter_.ConvertOne(bound, conv_string);
  133|  2.51M|  }
bind.cc:_ZNK4absl12lts_2026010719str_format_internal12_GLOBAL__N_116DefaultConverter10ConvertOneERKNS1_15BoundConversionENSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
  158|  2.51M|  bool ConvertOne(const BoundConversion& bound, string_view /*conv*/) const {
  159|  2.51M|    return FormatArgImplFriend::Convert(*bound.arg(), bound, sink_);
  160|  2.51M|  }
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEE6AppendENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
  125|  3.15M|  bool Append(string_view s) {
  126|  3.15M|    converter_.Append(s);
  127|  3.15M|    return true;
  128|  3.15M|  }
bind.cc:_ZNK4absl12lts_2026010719str_format_internal12_GLOBAL__N_116DefaultConverter6AppendENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
  156|  3.15M|  void Append(string_view s) const { sink_->Append(s); }
bind.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_117ConverterConsumerINS2_16DefaultConverterEEC2ES4_NS0_4SpanIKNS1_13FormatArgImplEEE:
  123|   646k|      : converter_(converter), arg_context_(pack) {}

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

_ZN4absl12lts_2026010719str_format_internal17UnboundConversionC2Ev:
   36|  2.51M|  UnboundConversion() {}  // NOLINT
_ZN4absl12lts_2026010719str_format_internal17UnboundConversion10InputValue9set_valueEi:
   45|  1.88M|    constexpr void set_value(int value) {
   46|       |      assert(value >= 0);
   47|  1.88M|      value_ = value;
   48|  1.88M|    }
_ZNK4absl12lts_2026010719str_format_internal17UnboundConversion10InputValue5valueEv:
   49|  3.76M|    constexpr int value() const { return value_; }
_ZNK4absl12lts_2026010719str_format_internal17UnboundConversion10InputValue11is_from_argEv:
   60|  3.76M|    constexpr bool is_from_arg() const { return value_ < -1; }
_ZNK4absl12lts_2026010719str_format_internal7ConvTag7is_convEv:
   94|  4.39M|  constexpr bool is_conv() const { return (tag_ & 0x80) == 0; }
_ZNK4absl12lts_2026010719str_format_internal7ConvTag8is_flagsEv:
   96|  1.26M|  constexpr bool is_flags() const { return (tag_ & 0xE0) == 0xC0; }
_ZNK4absl12lts_2026010719str_format_internal7ConvTag7as_convEv:
   98|  2.51M|  constexpr FormatConversionChar as_conv() const {
   99|  2.51M|    assert(is_conv());
  100|  2.51M|    assert(!is_length());
  101|       |    assert(!is_flags());
  102|  2.51M|    return static_cast<FormatConversionChar>(tag_);
  103|  2.51M|  }
_ZNK4absl12lts_2026010719str_format_internal7ConvTag8as_flagsEv:
  110|  1.26M|  constexpr Flags as_flags() const {
  111|  1.26M|    assert(!is_conv());
  112|  1.26M|    assert(!is_length());
  113|       |    assert(is_flags());
  114|  1.26M|    return static_cast<Flags>(tag_ & 0x1F);
  115|  1.26M|  }
_ZN4absl12lts_2026010719str_format_internal17ConsumeConversionILb0EEEPKcS4_S4_PNS1_17UnboundConversionEPi:
  216|  1.88M|                                        int* next_arg) {
  217|  1.88M|  const char* const original_pos = pos;
  218|  1.88M|  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|  1.88M|#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR()          \
  222|  1.88M|  do {                                                  \
  223|  1.88M|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  224|  1.88M|    c = *pos++;                                         \
  225|  1.88M|  } while (0)
  226|       |
  227|  1.88M|  if (is_positional) {
  ------------------
  |  Branch (227:7): [Folded, False: 1.88M]
  ------------------
  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|  1.88M|  ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|  1.88M|  do {                                                  \
  |  |  223|  1.88M|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|  1.88M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 1.88M]
  |  |  |  |  |  Branch (189:49): [Folded, False: 1.88M]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 1.88M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|  1.88M|    c = *pos++;                                         \
  |  |  225|  1.88M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 1.88M]
  |  |  ------------------
  ------------------
  236|       |
  237|       |  // We should start with the basic flag on.
  238|  1.88M|  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|  1.88M|  if (c < 'A') {
  ------------------
  |  Branch (243:7): [True: 1.88M, False: 0]
  ------------------
  244|  3.14M|    while (c <= '0') {
  ------------------
  |  Branch (244:12): [True: 1.26M, False: 1.88M]
  ------------------
  245|  1.26M|      auto tag = GetTagForChar(c);
  246|  1.26M|      if (tag.is_flags()) {
  ------------------
  |  Branch (246:11): [True: 1.26M, False: 0]
  ------------------
  247|  1.26M|        conv->flags = conv->flags | tag.as_flags();
  248|  1.26M|        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|  1.26M|  do {                                                  \
  |  |  223|  1.26M|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  189|  1.26M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 1.26M]
  |  |  |  |  |  Branch (189:49): [Folded, False: 1.26M]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 1.26M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|  1.26M|    c = *pos++;                                         \
  |  |  225|  1.26M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 1.26M]
  |  |  ------------------
  ------------------
  249|  1.26M|      } else {
  250|      0|        break;
  251|      0|      }
  252|  1.26M|    }
  253|       |
  254|  1.88M|    if (c <= '9') {
  ------------------
  |  Branch (254:9): [True: 1.88M, False: 0]
  ------------------
  255|  1.88M|      if (c >= '0') {
  ------------------
  |  Branch (255:11): [True: 1.88M, False: 0]
  ------------------
  256|  1.88M|        int maybe_width = ParseDigits(c, pos, end);
  257|  1.88M|        if (!is_positional && c == '$') {
  ------------------
  |  Branch (257:13): [True: 1.88M, Folded]
  |  Branch (257:31): [True: 0, False: 1.88M]
  ------------------
  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|  1.88M|        conv->flags = conv->flags | Flags::kNonBasic;
  264|  1.88M|        conv->width.set_value(maybe_width);
  265|  1.88M|      } 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|  1.88M|    }
  278|       |
  279|  1.88M|    if (c == '.') {
  ------------------
  |  Branch (279:9): [True: 0, False: 1.88M]
  ------------------
  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|  1.88M|  }
  299|       |
  300|  1.88M|  auto tag = GetTagForChar(c);
  301|       |
  302|  1.88M|  if (ABSL_PREDICT_FALSE(c == 'v' && conv->flags != Flags::kBasic)) {
  ------------------
  |  |  189|  1.88M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1.88M]
  |  |  |  Branch (189:49): [Folded, False: 1.88M]
  |  |  |  Branch (189:59): [True: 0, False: 1.88M]
  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  303|      0|    return nullptr;
  304|      0|  }
  305|       |
  306|  1.88M|  if (ABSL_PREDICT_FALSE(!tag.is_conv())) {
  ------------------
  |  |  189|  1.88M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1.88M]
  |  |  |  Branch (189:49): [Folded, False: 1.88M]
  |  |  |  Branch (189:58): [True: 0, False: 1.88M]
  |  |  ------------------
  ------------------
  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|  1.88M|#undef ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR
  332|       |
  333|  1.88M|  assert(CheckFastPathSetting(*conv));
  334|  1.88M|  (void)(&CheckFastPathSetting);
  335|       |
  336|  1.88M|  conv->conv = tag.as_conv();
  337|  1.88M|  if (!is_positional) conv->arg_position = ++*next_arg;
  ------------------
  |  Branch (337:7): [True: 1.88M, Folded]
  ------------------
  338|  1.88M|  return pos;
  339|  1.88M|}
_ZN4absl12lts_2026010719str_format_internal13GetTagForCharEc:
  169|  5.65M|constexpr ConvTag GetTagForChar(char c) {
  170|  5.65M|  return ConvTagHolder::value[static_cast<unsigned char>(c)];
  171|  5.65M|}
_ZN4absl12lts_2026010719str_format_internal11ParseDigitsERcRPKcS4_:
  196|  1.88M|constexpr int ParseDigits(char& c, const char*& pos, const char* const end) {
  197|  1.88M|  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|  1.88M|  int num_digits = std::numeric_limits<int>::digits10;
  202|  1.88M|  for (;;) {
  203|  1.88M|    if (ABSL_PREDICT_FALSE(pos == end)) break;
  ------------------
  |  |  189|  1.88M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1.88M]
  |  |  |  Branch (189:49): [Folded, False: 1.88M]
  |  |  |  Branch (189:58): [True: 0, False: 1.88M]
  |  |  ------------------
  ------------------
  204|  1.88M|    c = *pos++;
  205|  1.88M|    if ('0' > c || c > '9') break;
  ------------------
  |  Branch (205:9): [True: 0, False: 1.88M]
  |  Branch (205:20): [True: 1.88M, 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|  1.88M|  return digits;
  211|  1.88M|}
_ZN4absl12lts_2026010719str_format_internal24ConsumeUnboundConversionEPKcS3_PNS1_17UnboundConversionEPi:
  348|  1.88M|                                               int* next_arg) {
  349|  1.88M|  if (*next_arg < 0) return ConsumeConversion<true>(p, end, conv, next_arg);
  ------------------
  |  Branch (349:7): [True: 0, False: 1.88M]
  ------------------
  350|  1.88M|  return ConsumeConversion<false>(p, end, conv, next_arg);
  351|  1.88M|}

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

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

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

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

bind.cc:_ZN4absl12lts_2026010719str_format_internal17ParseFormatStringINS1_12_GLOBAL__N_117ConverterConsumerINS3_16DefaultConverterEEEEEbNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEET_:
   57|   646k|bool ParseFormatString(string_view src, Consumer consumer) {
   58|   646k|  int next_arg = 0;
   59|   646k|  const char* p = src.data();
   60|   646k|  const char* const end = p + src.size();
   61|  3.15M|  while (p != end) {
  ------------------
  |  Branch (61:10): [True: 3.15M, False: 0]
  ------------------
   62|  3.15M|    const char* percent =
   63|  3.15M|        static_cast<const char*>(memchr(p, '%', static_cast<size_t>(end - p)));
   64|  3.15M|    if (!percent) {
  ------------------
  |  Branch (64:9): [True: 646k, False: 2.51M]
  ------------------
   65|       |      // We found the last substring.
   66|   646k|      return consumer.Append(string_view(p, static_cast<size_t>(end - p)));
   67|   646k|    }
   68|       |    // We found a percent, so push the text run then process the percent.
   69|  2.51M|    if (ABSL_PREDICT_FALSE(!consumer.Append(
  ------------------
  |  |  189|  2.51M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 2.51M]
  |  |  |  Branch (189:49): [Folded, False: 2.51M]
  |  |  |  Branch (189:58): [True: 0, False: 2.51M]
  |  |  ------------------
  ------------------
   70|  2.51M|            string_view(p, static_cast<size_t>(percent - p))))) {
   71|      0|      return false;
   72|      0|    }
   73|  2.51M|    if (ABSL_PREDICT_FALSE(percent + 1 >= end)) return false;
  ------------------
  |  |  189|  2.51M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 2.51M]
  |  |  |  Branch (189:49): [Folded, False: 2.51M]
  |  |  |  Branch (189:58): [True: 0, False: 2.51M]
  |  |  ------------------
  ------------------
   74|       |
   75|  2.51M|    auto tag = GetTagForChar(percent[1]);
   76|  2.51M|    if (tag.is_conv()) {
  ------------------
  |  Branch (76:9): [True: 630k, False: 1.88M]
  ------------------
   77|   630k|      if (ABSL_PREDICT_FALSE(next_arg < 0)) {
  ------------------
  |  |  189|   630k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 630k]
  |  |  |  Branch (189:49): [Folded, False: 630k]
  |  |  |  Branch (189:58): [True: 0, False: 630k]
  |  |  ------------------
  ------------------
   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|   630k|      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|   630k|      UnboundConversion conv;
   90|   630k|      conv.conv = tag.as_conv();
   91|   630k|      conv.arg_position = ++next_arg;
   92|   630k|      if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  189|   630k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 630k]
  |  |  |  Branch (189:49): [Folded, False: 630k]
  |  |  |  Branch (189:58): [True: 0, False: 630k]
  |  |  ------------------
  ------------------
   93|   630k|              !consumer.ConvertOne(conv, string_view(percent + 1, 1)))) {
   94|      0|        return false;
   95|      0|      }
   96|  1.88M|    } else if (percent[1] != '%') {
  ------------------
  |  Branch (96:16): [True: 1.88M, False: 0]
  ------------------
   97|  1.88M|      UnboundConversion conv;
   98|  1.88M|      p = ConsumeUnboundConversionNoInline(percent + 1, end, &conv, &next_arg);
   99|  1.88M|      if (ABSL_PREDICT_FALSE(p == nullptr)) return false;
  ------------------
  |  |  189|  1.88M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1.88M]
  |  |  |  Branch (189:49): [Folded, False: 1.88M]
  |  |  |  Branch (189:58): [True: 0, False: 1.88M]
  |  |  ------------------
  ------------------
  100|  1.88M|      if (ABSL_PREDICT_FALSE(!consumer.ConvertOne(
  ------------------
  |  |  189|  1.88M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1.88M]
  |  |  |  Branch (189:49): [Folded, False: 1.88M]
  |  |  |  Branch (189:58): [True: 0, False: 1.88M]
  |  |  ------------------
  ------------------
  101|  1.88M|              conv, string_view(percent + 1,
  102|  1.88M|                                static_cast<size_t>(p - (percent + 1)))))) {
  103|      0|        return false;
  104|      0|      }
  105|  1.88M|    } 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|  2.51M|  }
  111|      0|  return true;
  112|   646k|}

_ZN4absl12lts_2026010716EqualsIgnoreCaseENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_:
   32|  55.7k|                      absl::string_view piece2) noexcept {
   33|  55.7k|  return (piece1.size() == piece2.size() &&
  ------------------
  |  Branch (33:11): [True: 13.1k, False: 42.6k]
  ------------------
   34|  13.1k|          0 == absl::strings_internal::memcasecmp(piece1.data(), piece2.data(),
  ------------------
  |  Branch (34:11): [True: 13.1k, False: 0]
  ------------------
   35|  13.1k|                                                  piece1.size()));
   36|       |  // memcasecmp uses absl::ascii_tolower().
   37|  55.7k|}

_ZN4absl12lts_2026010710SimpleAtodENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPd:
   85|  2.54k|bool SimpleAtod(absl::string_view str, double* absl_nonnull out) {
   86|  2.54k|  *out = 0.0;
   87|  2.54k|  str = StripAsciiWhitespace(str);
   88|  2.54k|  if (str.empty()) {
  ------------------
  |  Branch (88:7): [True: 0, False: 2.54k]
  ------------------
   89|       |    // absl::from_chars doesn't accept empty strings.
   90|      0|    return false;
   91|      0|  }
   92|       |  // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one
   93|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   94|  2.54k|  if (str[0] == '+') {
  ------------------
  |  Branch (94:7): [True: 0, False: 2.54k]
  ------------------
   95|      0|    str.remove_prefix(1);
   96|      0|    if (str.empty() || str[0] == '-') {
  ------------------
  |  Branch (96:9): [True: 0, False: 0]
  |  Branch (96:24): [True: 0, False: 0]
  ------------------
   97|      0|      return false;
   98|      0|    }
   99|      0|  }
  100|  2.54k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
  101|  2.54k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (101:7): [True: 0, False: 2.54k]
  ------------------
  102|      0|    return false;
  103|      0|  }
  104|  2.54k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (104:7): [True: 0, False: 2.54k]
  ------------------
  105|       |    // not all non-whitespace characters consumed
  106|      0|    return false;
  107|      0|  }
  108|       |  // from_chars() with DR 3081's current wording will return max() on
  109|       |  // overflow.  SimpleAtod returns infinity instead.
  110|  2.54k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (110:7): [True: 0, False: 2.54k]
  ------------------
  111|      0|    if (*out > 1.0) {
  ------------------
  |  Branch (111:9): [True: 0, False: 0]
  ------------------
  112|      0|      *out = std::numeric_limits<double>::infinity();
  113|      0|    } else if (*out < -1.0) {
  ------------------
  |  Branch (113:16): [True: 0, False: 0]
  ------------------
  114|      0|      *out = -std::numeric_limits<double>::infinity();
  115|      0|    }
  116|      0|  }
  117|  2.54k|  return true;
  118|  2.54k|}
_ZN4absl12lts_2026010710SimpleAtobENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPb:
  120|  13.1k|bool SimpleAtob(absl::string_view str, bool* absl_nonnull out) {
  121|  13.1k|  ABSL_RAW_CHECK(out != nullptr, "Output pointer must not be nullptr.");
  ------------------
  |  |   60|  13.1k|  do {                                                                 \
  |  |   61|  13.1k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|  13.1k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 13.1k]
  |  |  |  |  |  Branch (189:49): [Folded, False: 13.1k]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 13.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|  13.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 13.1k]
  |  |  ------------------
  ------------------
  122|  13.1k|  if (EqualsIgnoreCase(str, "true") || EqualsIgnoreCase(str, "t") ||
  ------------------
  |  Branch (122:7): [True: 4.61k, False: 8.52k]
  |  Branch (122:40): [True: 0, False: 8.52k]
  ------------------
  123|  8.52k|      EqualsIgnoreCase(str, "yes") || EqualsIgnoreCase(str, "y") ||
  ------------------
  |  Branch (123:7): [True: 0, False: 8.52k]
  |  Branch (123:39): [True: 0, False: 8.52k]
  ------------------
  124|  8.52k|      EqualsIgnoreCase(str, "1")) {
  ------------------
  |  Branch (124:7): [True: 0, False: 8.52k]
  ------------------
  125|  4.61k|    *out = true;
  126|  4.61k|    return true;
  127|  4.61k|  }
  128|  8.52k|  if (EqualsIgnoreCase(str, "false") || EqualsIgnoreCase(str, "f") ||
  ------------------
  |  Branch (128:7): [True: 8.52k, False: 0]
  |  Branch (128:41): [True: 0, False: 0]
  ------------------
  129|      0|      EqualsIgnoreCase(str, "no") || EqualsIgnoreCase(str, "n") ||
  ------------------
  |  Branch (129:7): [True: 0, False: 0]
  |  Branch (129:38): [True: 0, False: 0]
  ------------------
  130|  8.52k|      EqualsIgnoreCase(str, "0")) {
  ------------------
  |  Branch (130:7): [True: 0, False: 0]
  ------------------
  131|  8.52k|    *out = false;
  132|  8.52k|    return true;
  133|  8.52k|  }
  134|      0|  return false;
  135|  8.52k|}
_ZN4absl12lts_2026010716numbers_internal15FastIntToBufferEiPc:
  348|  2.48M|    int32_t i, char* absl_nonnull buffer) {
  349|  2.48M|  uint32_t u = static_cast<uint32_t>(i);
  350|  2.48M|  if (i < 0) {
  ------------------
  |  Branch (350:7): [True: 0, False: 2.48M]
  ------------------
  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.48M|  buffer = EncodeFullU32(u, buffer);
  358|  2.48M|  *buffer = '\0';
  359|  2.48M|  return buffer;
  360|  2.48M|}
_ZN4absl12lts_2026010716numbers_internal17safe_strto32_baseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPii:
 1189|  20.2k|                       int base) {
 1190|  20.2k|  return safe_int_internal<int32_t>(text, value, base);
 1191|  20.2k|}
_ZN4absl12lts_2026010716numbers_internal18safe_strtou64_baseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPmi:
 1219|  2.04k|                        int base) {
 1220|  2.04k|  return safe_uint_internal<uint64_t>(text, value, base);
 1221|  2.04k|}
numbers.cc:_ZN4absl12lts_2026010712_GLOBAL__N_113EncodeFullU32EjPc:
  258|  2.48M|    uint32_t n, char* absl_nonnull out_str) {
  259|  2.48M|  if (n < 10) {
  ------------------
  |  Branch (259:7): [True: 1.76k, False: 2.48M]
  ------------------
  260|  1.76k|    *out_str = static_cast<char>('0' + n);
  261|  1.76k|    return out_str + 1;
  262|  1.76k|  }
  263|  2.48M|  if (n < 100'000'000) {
  ------------------
  |  Branch (263:7): [True: 1.86M, False: 619k]
  ------------------
  264|  1.86M|    uint64_t bottom = PrepareEightDigits(n);
  265|  1.86M|    ABSL_ASSUME(bottom != 0);
  ------------------
  |  |  270|  1.86M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  266|       |    // 0 minus 8 to make MSVC happy.
  267|  1.86M|    uint32_t zeroes =
  268|  1.86M|        static_cast<uint32_t>(absl::countr_zero(bottom)) & (0 - 8u);
  269|  1.86M|    little_endian::Store64(out_str, (bottom + kEightZeroBytes) >> zeroes);
  270|  1.86M|    return out_str + sizeof(bottom) - zeroes / 8;
  271|  1.86M|  }
  272|   619k|  uint32_t div08 = n / 100'000'000;
  273|   619k|  uint32_t mod08 = n % 100'000'000;
  274|   619k|  uint64_t bottom = PrepareEightDigits(mod08) + kEightZeroBytes;
  275|   619k|  out_str = EncodeHundred(div08, out_str);
  276|   619k|  little_endian::Store64(out_str, bottom);
  277|   619k|  return out_str + sizeof(bottom);
  278|  2.48M|}
numbers.cc:_ZN4absl12lts_2026010712_GLOBAL__N_118PrepareEightDigitsEj:
  229|  2.48M|inline uint64_t PrepareEightDigits(uint32_t i) {
  230|  2.48M|  ABSL_ASSUME(i < 10000'0000);
  ------------------
  |  |  270|  2.48M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  231|       |  // Prepare 2 blocks of 4 digits "in parallel".
  232|  2.48M|  uint32_t hi = i / 10000;
  233|  2.48M|  uint32_t lo = i % 10000;
  234|  2.48M|  uint64_t merged = hi | (uint64_t{lo} << 32);
  235|  2.48M|  uint64_t div100 = ((merged * kDivisionBy100Mul) / kDivisionBy100Div) &
  236|  2.48M|                    ((0x7Full << 32) | 0x7Full);
  237|  2.48M|  uint64_t mod100 = merged - 100ull * div100;
  238|  2.48M|  uint64_t hundreds = (mod100 << 16) + div100;
  239|  2.48M|  uint64_t tens = (hundreds * kDivisionBy10Mul) / kDivisionBy10Div;
  240|  2.48M|  tens &= (0xFull << 48) | (0xFull << 32) | (0xFull << 16) | 0xFull;
  241|  2.48M|  tens += (hundreds - 10ull * tens) << 8;
  242|  2.48M|  return tens;
  243|  2.48M|}
numbers.cc:_ZN4absl12lts_2026010712_GLOBAL__N_113EncodeHundredEjPc:
  179|   619k|inline char* EncodeHundred(uint32_t n, char* absl_nonnull out_str) {
  180|   619k|  int num_digits = static_cast<int>(n - 10) >> 8;
  181|   619k|  uint32_t div10 = (n * kDivisionBy10Mul) / kDivisionBy10Div;
  182|   619k|  uint32_t mod10 = n - 10u * div10;
  183|   619k|  uint32_t base = kTwoZeroBytes + div10 + (mod10 << 8);
  184|   619k|  base >>= num_digits & 8;
  185|   619k|  little_endian::Store16(out_str, static_cast<uint16_t>(base));
  186|   619k|  return out_str + 2 + num_digits;
  187|   619k|}
numbers.cc:_ZN4absl12lts_2026010712_GLOBAL__N_124safe_parse_sign_and_baseEPNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPiPb:
  762|  22.3k|    bool* absl_nonnull negative_ptr /*output*/) {
  763|  22.3k|  if (text->data() == nullptr) {
  ------------------
  |  Branch (763:7): [True: 0, False: 22.3k]
  ------------------
  764|      0|    return false;
  765|      0|  }
  766|       |
  767|  22.3k|  const char* start = text->data();
  768|  22.3k|  const char* end = start + text->size();
  769|  22.3k|  int base = *base_ptr;
  770|       |
  771|       |  // Consume whitespace.
  772|  22.3k|  while (start < end &&
  ------------------
  |  Branch (772:10): [True: 22.3k, False: 0]
  ------------------
  773|  22.3k|         absl::ascii_isspace(static_cast<unsigned char>(start[0]))) {
  ------------------
  |  Branch (773:10): [True: 0, False: 22.3k]
  ------------------
  774|      0|    ++start;
  775|      0|  }
  776|  22.3k|  while (start < end &&
  ------------------
  |  Branch (776:10): [True: 22.3k, False: 0]
  ------------------
  777|  22.3k|         absl::ascii_isspace(static_cast<unsigned char>(end[-1]))) {
  ------------------
  |  Branch (777:10): [True: 0, False: 22.3k]
  ------------------
  778|      0|    --end;
  779|      0|  }
  780|  22.3k|  if (start >= end) {
  ------------------
  |  Branch (780:7): [True: 0, False: 22.3k]
  ------------------
  781|      0|    return false;
  782|      0|  }
  783|       |
  784|       |  // Consume sign.
  785|  22.3k|  *negative_ptr = (start[0] == '-');
  786|  22.3k|  if (*negative_ptr || start[0] == '+') {
  ------------------
  |  Branch (786:7): [True: 0, False: 22.3k]
  |  Branch (786:24): [True: 0, False: 22.3k]
  ------------------
  787|      0|    ++start;
  788|      0|    if (start >= end) {
  ------------------
  |  Branch (788:9): [True: 0, False: 0]
  ------------------
  789|      0|      return false;
  790|      0|    }
  791|      0|  }
  792|       |
  793|       |  // Consume base-dependent prefix.
  794|       |  //  base 0: "0x" -> base 16, "0" -> base 8, default -> base 10
  795|       |  //  base 16: "0x" -> base 16
  796|       |  // Also validate the base.
  797|  22.3k|  if (base == 0) {
  ------------------
  |  Branch (797:7): [True: 0, False: 22.3k]
  ------------------
  798|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (798:9): [True: 0, False: 0]
  |  Branch (798:29): [True: 0, False: 0]
  ------------------
  799|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (799:10): [True: 0, False: 0]
  |  Branch (799:29): [True: 0, False: 0]
  ------------------
  800|      0|      base = 16;
  801|      0|      start += 2;
  802|      0|      if (start >= end) {
  ------------------
  |  Branch (802:11): [True: 0, False: 0]
  ------------------
  803|       |        // "0x" with no digits after is invalid.
  804|      0|        return false;
  805|      0|      }
  806|      0|    } else if (end - start >= 1 && start[0] == '0') {
  ------------------
  |  Branch (806:16): [True: 0, False: 0]
  |  Branch (806:36): [True: 0, False: 0]
  ------------------
  807|      0|      base = 8;
  808|      0|      start += 1;
  809|      0|    } else {
  810|      0|      base = 10;
  811|      0|    }
  812|  22.3k|  } else if (base == 16) {
  ------------------
  |  Branch (812:14): [True: 0, False: 22.3k]
  ------------------
  813|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (813:9): [True: 0, False: 0]
  |  Branch (813:29): [True: 0, False: 0]
  ------------------
  814|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (814:10): [True: 0, False: 0]
  |  Branch (814:29): [True: 0, False: 0]
  ------------------
  815|      0|      start += 2;
  816|      0|      if (start >= end) {
  ------------------
  |  Branch (816:11): [True: 0, False: 0]
  ------------------
  817|       |        // "0x" with no digits after is invalid.
  818|      0|        return false;
  819|      0|      }
  820|      0|    }
  821|  22.3k|  } else if (base >= 2 && base <= 36) {
  ------------------
  |  Branch (821:14): [True: 22.3k, False: 0]
  |  Branch (821:27): [True: 22.3k, False: 0]
  ------------------
  822|       |    // okay
  823|  22.3k|  } else {
  824|      0|    return false;
  825|      0|  }
  826|  22.3k|  *text = absl::string_view(start, static_cast<size_t>(end - start));
  827|  22.3k|  *base_ptr = base;
  828|  22.3k|  return true;
  829|  22.3k|}
numbers.cc:_ZN4absl12lts_2026010712_GLOBAL__N_117safe_int_internalIiEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
 1129|  20.2k|                              IntType* absl_nonnull value_p, int base) {
 1130|  20.2k|  *value_p = 0;
 1131|  20.2k|  bool negative;
 1132|  20.2k|  if (!safe_parse_sign_and_base(&text, &base, &negative)) {
  ------------------
  |  Branch (1132:7): [True: 0, False: 20.2k]
  ------------------
 1133|      0|    return false;
 1134|      0|  }
 1135|  20.2k|  if (!negative) {
  ------------------
  |  Branch (1135:7): [True: 20.2k, False: 0]
  ------------------
 1136|  20.2k|    return safe_parse_positive_int(text, base, value_p);
 1137|  20.2k|  } else {
 1138|      0|    return safe_parse_negative_int(text, base, value_p);
 1139|      0|  }
 1140|  20.2k|}
numbers.cc:_ZN4absl12lts_2026010712_GLOBAL__N_123safe_parse_positive_intIiEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiPT_:
 1047|  20.2k|                                    IntType* absl_nonnull value_p) {
 1048|  20.2k|  IntType value = 0;
 1049|  20.2k|  const IntType vmax = std::numeric_limits<IntType>::max();
 1050|  20.2k|  assert(vmax > 0);
 1051|  20.2k|  assert(base >= 0);
 1052|  20.2k|  const IntType base_inttype = static_cast<IntType>(base);
 1053|  20.2k|  assert(vmax >= base_inttype);
 1054|  20.2k|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1055|  20.2k|  assert(base < 2 ||
 1056|  20.2k|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1057|  20.2k|  const char* start = text.data();
 1058|  20.2k|  const char* end = start + text.size();
 1059|       |  // loop over digits
 1060|  50.6k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1060:10): [True: 30.4k, False: 20.2k]
  ------------------
 1061|  30.4k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1062|  30.4k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1063|  30.4k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1063:9): [True: 0, False: 30.4k]
  ------------------
 1064|      0|      *value_p = value;
 1065|      0|      return false;
 1066|      0|    }
 1067|  30.4k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1067:9): [True: 0, False: 30.4k]
  ------------------
 1068|      0|      *value_p = vmax;
 1069|      0|      return false;
 1070|      0|    }
 1071|  30.4k|    value *= base_inttype;
 1072|  30.4k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1072:9): [True: 0, False: 30.4k]
  ------------------
 1073|      0|      *value_p = vmax;
 1074|      0|      return false;
 1075|      0|    }
 1076|  30.4k|    value += digit;
 1077|  30.4k|  }
 1078|  20.2k|  *value_p = value;
 1079|  20.2k|  return true;
 1080|  20.2k|}
numbers.cc:_ZN4absl12lts_2026010712_GLOBAL__N_118safe_uint_internalImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
 1144|  2.04k|                               IntType* absl_nonnull value_p, int base) {
 1145|  2.04k|  *value_p = 0;
 1146|  2.04k|  bool negative;
 1147|  2.04k|  if (!safe_parse_sign_and_base(&text, &base, &negative) || negative) {
  ------------------
  |  Branch (1147:7): [True: 0, False: 2.04k]
  |  Branch (1147:61): [True: 0, False: 2.04k]
  ------------------
 1148|      0|    return false;
 1149|      0|  }
 1150|  2.04k|  return safe_parse_positive_int(text, base, value_p);
 1151|  2.04k|}
numbers.cc:_ZN4absl12lts_2026010712_GLOBAL__N_123safe_parse_positive_intImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiPT_:
 1047|  2.04k|                                    IntType* absl_nonnull value_p) {
 1048|  2.04k|  IntType value = 0;
 1049|  2.04k|  const IntType vmax = std::numeric_limits<IntType>::max();
 1050|  2.04k|  assert(vmax > 0);
 1051|  2.04k|  assert(base >= 0);
 1052|  2.04k|  const IntType base_inttype = static_cast<IntType>(base);
 1053|  2.04k|  assert(vmax >= base_inttype);
 1054|  2.04k|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1055|  2.04k|  assert(base < 2 ||
 1056|  2.04k|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1057|  2.04k|  const char* start = text.data();
 1058|  2.04k|  const char* end = start + text.size();
 1059|       |  // loop over digits
 1060|  8.19k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1060:10): [True: 6.14k, False: 2.04k]
  ------------------
 1061|  6.14k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1062|  6.14k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1063|  6.14k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1063:9): [True: 0, False: 6.14k]
  ------------------
 1064|      0|      *value_p = value;
 1065|      0|      return false;
 1066|      0|    }
 1067|  6.14k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1067:9): [True: 0, False: 6.14k]
  ------------------
 1068|      0|      *value_p = vmax;
 1069|      0|      return false;
 1070|      0|    }
 1071|  6.14k|    value *= base_inttype;
 1072|  6.14k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1072:9): [True: 0, False: 6.14k]
  ------------------
 1073|      0|      *value_p = vmax;
 1074|      0|      return false;
 1075|      0|    }
 1076|  6.14k|    value += digit;
 1077|  6.14k|  }
 1078|  2.04k|  *value_p = value;
 1079|  2.04k|  return true;
 1080|  2.04k|}

str_cat.cc:_ZN4absl12lts_2026010724StringResizeAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_6StrCatERKNS0_8AlphaNumESB_E3$_0EEvRT_NSD_9size_typeET0_:
  182|  10.1k|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  183|  10.1k|  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|  10.1k|}
str_cat.cc:_ZN4absl12lts_2026010716strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS0_6StrCatERKNS0_8AlphaNumESC_E3$_0EEvRT_NSE_9size_typeET0_:
  145|  10.1k|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|  10.1k|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  156|  10.1k|    str.__resize_default_init(n);
  157|  10.1k|    str.__resize_default_init(
  158|  10.1k|        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|  10.1k|#endif
  165|  10.1k|}

_ZN4absl12lts_202601076StrCatERKNS0_8AlphaNumES3_:
   58|  10.1k|std::string StrCat(const AlphaNum& a, const AlphaNum& b) {
   59|  10.1k|  std::string result;
   60|       |  // Use uint64_t to prevent size_t overflow. We assume it is not possible for
   61|       |  // in memory strings to overflow a uint64_t.
   62|  10.1k|  constexpr uint64_t kMaxSize = uint64_t{std::numeric_limits<size_t>::max()};
   63|  10.1k|  const uint64_t result_size =
   64|  10.1k|      static_cast<uint64_t>(a.size()) + static_cast<uint64_t>(b.size());
   65|  10.1k|  ABSL_INTERNAL_CHECK(result_size <= kMaxSize, "size_t overflow");
  ------------------
  |  |   85|  10.1k|  do {                                                             \
  |  |   86|  10.1k|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  189|  10.1k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 10.1k]
  |  |  |  |  |  Branch (189:49): [Folded, False: 10.1k]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 10.1k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|  10.1k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 10.1k]
  |  |  ------------------
  ------------------
   66|  10.1k|  absl::StringResizeAndOverwrite(result, static_cast<size_t>(result_size),
   67|  10.1k|                                 [&a, &b](char* const begin, size_t buf_size) {
   68|  10.1k|                                   char* out = begin;
   69|  10.1k|                                   out = Append(out, a);
   70|  10.1k|                                   out = Append(out, b);
   71|  10.1k|                                   assert(out == begin + buf_size);
   72|  10.1k|                                   return buf_size;
   73|  10.1k|                                 });
   74|  10.1k|  return result;
   75|  10.1k|}
str_cat.cc:_ZZN4absl12lts_202601076StrCatERKNS0_8AlphaNumES3_ENK3$_0clEPcm:
   67|  10.1k|                                 [&a, &b](char* const begin, size_t buf_size) {
   68|  10.1k|                                   char* out = begin;
   69|  10.1k|                                   out = Append(out, a);
   70|  10.1k|                                   out = Append(out, b);
   71|       |                                   assert(out == begin + buf_size);
   72|  10.1k|                                   return buf_size;
   73|  10.1k|                                 });
str_cat.cc:_ZN4absl12lts_2026010712_GLOBAL__N_16AppendEPcRKNS0_8AlphaNumE:
   46|  20.2k|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|  20.2k|  char* after = out + x.size();
   50|  20.2k|  if (x.size() != 0) {
  ------------------
  |  Branch (50:7): [True: 20.2k, False: 0]
  ------------------
   51|  20.2k|    memcpy(out, x.data(), x.size());
   52|  20.2k|  }
   53|  20.2k|  return after;
   54|  20.2k|}

_ZNK4absl12lts_202601078AlphaNum4sizeEv:
  395|  81.0k|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl12lts_202601078AlphaNum4dataEv:
  396|  20.2k|  const char* absl_nullable data() const { return piece_.data(); }

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

_ZN4absl12lts_202601078ByStringC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
   85|  10.1k|ByString::ByString(absl::string_view sp) : delimiter_(sp) {}
_ZNK4absl12lts_202601078ByString4FindENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEm:
   87|  48.1k|absl::string_view ByString::Find(absl::string_view text, size_t pos) const {
   88|  48.1k|  if (delimiter_.length() == 1) {
  ------------------
  |  Branch (88:7): [True: 48.1k, False: 0]
  ------------------
   89|       |    // Much faster to call find on a single character than on an
   90|       |    // absl::string_view.
   91|  48.1k|    size_t found_pos = text.find(delimiter_[0], pos);
   92|  48.1k|    if (found_pos == absl::string_view::npos)
  ------------------
  |  Branch (92:9): [True: 10.1k, False: 38.0k]
  ------------------
   93|  10.1k|      return absl::string_view(text.data() + text.size(), 0);
   94|  38.0k|    return text.substr(found_pos, 1);
   95|  48.1k|  }
   96|      0|  return GenericFind(text, delimiter_, pos, LiteralPolicy());
   97|  48.1k|}

_ZN4absl12lts_2026010724synchronization_internal25OneTimeInitThreadIdentityEPNS0_13base_internal14ThreadIdentityE:
   75|      2|void OneTimeInitThreadIdentity(base_internal::ThreadIdentity* identity) {
   76|      2|  PerThreadSem::Init(identity);
   77|      2|  identity->ticker.store(0, std::memory_order_relaxed);
   78|      2|  identity->wait_start.store(0, std::memory_order_relaxed);
   79|      2|  identity->is_idle.store(false, std::memory_order_relaxed);
   80|      2|}
_ZN4absl12lts_2026010724synchronization_internal20CreateThreadIdentityEv:
  141|     20|base_internal::ThreadIdentity* CreateThreadIdentity() {
  142|     20|  base_internal::ThreadIdentity* identity = NewThreadIdentity();
  143|       |  // Associate the value with the current thread, and attach our destructor.
  144|     20|  base_internal::SetCurrentThreadIdentity(identity, ReclaimThreadIdentity);
  145|     20|  return identity;
  146|     20|}
create_thread_identity.cc:_ZN4absl12lts_2026010724synchronization_internalL17NewThreadIdentityEv:
  106|     20|static base_internal::ThreadIdentity* NewThreadIdentity() {
  107|     20|  base_internal::ThreadIdentity* identity = nullptr;
  108|       |
  109|     20|  {
  110|       |    // Re-use a previously released object if possible.
  111|     20|    base_internal::SpinLockHolder l(freelist_lock);
  112|     20|    if (thread_identity_freelist) {
  ------------------
  |  Branch (112:9): [True: 18, False: 2]
  ------------------
  113|     18|      identity = thread_identity_freelist;  // Take list-head.
  114|     18|      thread_identity_freelist = thread_identity_freelist->next;
  115|     18|    }
  116|     20|  }
  117|       |
  118|     20|  if (identity == nullptr) {
  ------------------
  |  Branch (118:7): [True: 2, False: 18]
  ------------------
  119|       |    // Allocate enough space to align ThreadIdentity to a multiple of
  120|       |    // PerThreadSynch::kAlignment. This space is never released (it is
  121|       |    // added to a freelist by ReclaimThreadIdentity instead).
  122|      2|    void* allocation = base_internal::LowLevelAlloc::Alloc(
  123|      2|        sizeof(*identity) + base_internal::PerThreadSynch::kAlignment - 1);
  124|       |    // Round up the address to the required alignment.
  125|      2|    identity = reinterpret_cast<base_internal::ThreadIdentity*>(
  126|      2|        RoundUp(reinterpret_cast<intptr_t>(allocation),
  127|      2|                base_internal::PerThreadSynch::kAlignment));
  128|       |    // Note that *identity is never constructed.
  129|       |    // TODO(b/357097463): change this "one time init" to be a proper
  130|       |    // constructor.
  131|      2|    OneTimeInitThreadIdentity(identity);
  132|      2|  }
  133|     20|  ResetThreadIdentityBetweenReuse(identity);
  134|       |
  135|     20|  return identity;
  136|     20|}
create_thread_identity.cc:_ZN4absl12lts_2026010724synchronization_internalL7RoundUpEll:
   71|      2|static intptr_t RoundUp(intptr_t addr, intptr_t align) {
   72|      2|  return (addr + align - 1) & ~(align - 1);
   73|      2|}
create_thread_identity.cc:_ZN4absl12lts_2026010724synchronization_internalL31ResetThreadIdentityBetweenReuseEPNS0_13base_internal14ThreadIdentityE:
   83|     20|    base_internal::ThreadIdentity* identity) {
   84|     20|  base_internal::PerThreadSynch* pts = &identity->per_thread_synch;
   85|     20|  pts->next = nullptr;
   86|     20|  pts->skip = nullptr;
   87|     20|  pts->may_skip = false;
   88|     20|  pts->waitp = nullptr;
   89|     20|  pts->suppress_fatal_errors = false;
   90|     20|  pts->readers = 0;
   91|     20|  pts->priority = 0;
   92|     20|  pts->next_priority_read_cycles = 0;
   93|     20|  pts->state.store(base_internal::PerThreadSynch::State::kAvailable,
   94|     20|                   std::memory_order_relaxed);
   95|     20|  pts->maybe_unlocking = false;
   96|     20|  pts->wake = false;
   97|     20|  pts->cond_waiter = false;
   98|     20|  pts->all_locks = nullptr;
   99|     20|  identity->blocked_count_ptr = nullptr;
  100|     20|  identity->ticker.store(0, std::memory_order_relaxed);
  101|     20|  identity->wait_start.store(0, std::memory_order_relaxed);
  102|     20|  identity->is_idle.store(false, std::memory_order_relaxed);
  103|     20|  identity->next = nullptr;
  104|     20|}
create_thread_identity.cc:_ZN4absl12lts_2026010724synchronization_internalL21ReclaimThreadIdentityEPv:
   44|     19|static void ReclaimThreadIdentity(void* v) {
   45|     19|  base_internal::ThreadIdentity* identity =
   46|     19|      static_cast<base_internal::ThreadIdentity*>(v);
   47|       |
   48|       |  // all_locks might have been allocated by the Mutex implementation.
   49|       |  // We free it here when we are notified that our thread is dying.
   50|     19|  if (identity->per_thread_synch.all_locks != nullptr) {
  ------------------
  |  Branch (50:7): [True: 0, False: 19]
  ------------------
   51|      0|    base_internal::LowLevelAlloc::Free(identity->per_thread_synch.all_locks);
   52|      0|  }
   53|       |
   54|       |  // We must explicitly clear the current thread's identity:
   55|       |  // (a) Subsequent (unrelated) per-thread destructors may require an identity.
   56|       |  //     We must guarantee a new identity is used in this case (this instructor
   57|       |  //     will be reinvoked up to PTHREAD_DESTRUCTOR_ITERATIONS in this case).
   58|       |  // (b) ThreadIdentity implementations may depend on memory that is not
   59|       |  //     reinitialized before reuse.  We must allow explicit clearing of the
   60|       |  //     association state in this case.
   61|     19|  base_internal::ClearCurrentThreadIdentity();
   62|     19|  {
   63|     19|    base_internal::SpinLockHolder l(freelist_lock);
   64|     19|    identity->next = thread_identity_freelist;
   65|     19|    thread_identity_freelist = identity;
   66|     19|  }
   67|     19|}

_ZN4absl12lts_2026010724synchronization_internal32GetOrCreateCurrentThreadIdentityEv:
   43|     41|inline base_internal::ThreadIdentity* GetOrCreateCurrentThreadIdentity() {
   44|     41|  base_internal::ThreadIdentity* identity =
   45|     41|      base_internal::CurrentThreadIdentityIfPresent();
   46|     41|  if (ABSL_PREDICT_FALSE(identity == nullptr)) {
  ------------------
  |  |  189|     41|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 20, False: 21]
  |  |  |  Branch (189:49): [Folded, False: 41]
  |  |  |  Branch (189:58): [True: 20, False: 21]
  |  |  ------------------
  ------------------
   47|     20|    return CreateThreadIdentity();
   48|     20|  }
   49|     21|  return identity;
   50|     41|}

_ZN4absl12lts_2026010724synchronization_internal9FutexImpl4WaitEPNSt3__16atomicIiEEi:
  101|     18|  static int Wait(std::atomic<int32_t>* v, int32_t val) {
  102|     18|    return WaitAbsoluteTimeout(v, val, nullptr);
  103|     18|  }
_ZN4absl12lts_2026010724synchronization_internal9FutexImpl19WaitAbsoluteTimeoutEPNSt3__16atomicIiEEiPK8timespec:
  108|     18|                                 const struct timespec* abs_timeout) {
  109|     18|    FutexTimespec ts;
  110|       |    // https://locklessinc.com/articles/futex_cheat_sheet/
  111|       |    // Unlike FUTEX_WAIT, FUTEX_WAIT_BITSET uses absolute time.
  112|     18|    auto err = syscall(
  113|     18|        SYS_futex, reinterpret_cast<int32_t*>(v),
  114|     18|        FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG | FUTEX_CLOCK_REALTIME, val,
  115|     18|        ToFutexTimespec(abs_timeout, &ts), nullptr, FUTEX_BITSET_MATCH_ANY);
  116|     18|    if (err != 0) {
  ------------------
  |  Branch (116:9): [True: 0, False: 18]
  ------------------
  117|      0|      return -errno;
  118|      0|    }
  119|     18|    return 0;
  120|     18|  }
_ZN4absl12lts_2026010724synchronization_internal9FutexImpl4WakeEPNSt3__16atomicIiEEi:
  139|     18|  static int Wake(std::atomic<int32_t>* v, int32_t count) {
  140|     18|    auto err = syscall(SYS_futex, reinterpret_cast<int32_t*>(v),
  141|     18|                       FUTEX_WAKE | FUTEX_PRIVATE_FLAG, count);
  142|     18|    if (ABSL_PREDICT_FALSE(err < 0)) {
  ------------------
  |  |  189|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 18]
  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  Branch (189:58): [True: 0, False: 18]
  |  |  ------------------
  ------------------
  143|      0|      return -errno;
  144|      0|    }
  145|     18|    return 0;
  146|     18|  }
_ZN4absl12lts_2026010724synchronization_internal9FutexImpl15ToFutexTimespecEPK8timespecPNS1_13FutexTimespecE:
  150|     18|                                        FutexTimespec* futex_ts) {
  151|     18|    if (userspace_ts == nullptr) {
  ------------------
  |  Branch (151:9): [True: 18, False: 0]
  ------------------
  152|     18|      return nullptr;
  153|     18|    }
  154|       |
  155|      0|    using FutexSeconds = decltype(futex_ts->tv_sec);
  156|      0|    using FutexNanoseconds = decltype(futex_ts->tv_nsec);
  157|       |
  158|      0|    constexpr auto kMaxSeconds{(std::numeric_limits<FutexSeconds>::max)()};
  159|      0|    if (userspace_ts->tv_sec > kMaxSeconds) {
  ------------------
  |  Branch (159:9): [True: 0, False: 0]
  ------------------
  160|      0|      futex_ts->tv_sec = kMaxSeconds;
  161|      0|    } else {
  162|      0|      futex_ts->tv_sec = static_cast<FutexSeconds>(userspace_ts->tv_sec);
  163|      0|    }
  164|      0|    futex_ts->tv_nsec = static_cast<FutexNanoseconds>(userspace_ts->tv_nsec);
  165|      0|    return futex_ts;
  166|     18|  }

_ZN4absl12lts_2026010724synchronization_internal11FutexWaiter9WaitUntilEPNSt3__16atomicIiEEiNS1_13KernelTimeoutE:
   35|     18|                           KernelTimeout t) {
   36|     18|#ifdef CLOCK_MONOTONIC
   37|     18|  constexpr bool kHasClockMonotonic = true;
   38|       |#else
   39|       |  constexpr bool kHasClockMonotonic = false;
   40|       |#endif
   41|       |
   42|       |  // We can't call Futex::WaitUntil() here because the prodkernel implementation
   43|       |  // does not know about KernelTimeout::SupportsSteadyClock().
   44|     18|  if (!t.has_timeout()) {
  ------------------
  |  Branch (44:7): [True: 18, False: 0]
  ------------------
   45|     18|    return Futex::Wait(v, val);
   46|     18|  } else if (kHasClockMonotonic && KernelTimeout::SupportsSteadyClock() &&
  ------------------
  |  Branch (46:14): [True: 0, Folded]
  |  Branch (46:36): [True: 0, Folded]
  ------------------
   47|      0|             t.is_relative_timeout()) {
  ------------------
  |  Branch (47:14): [True: 0, False: 0]
  ------------------
   48|      0|    auto rel_timespec = t.MakeRelativeTimespec();
   49|      0|    return Futex::WaitRelativeTimeout(v, val, &rel_timespec);
   50|      0|  } else {
   51|      0|    auto abs_timespec = t.MakeAbsTimespec();
   52|      0|    return Futex::WaitAbsoluteTimeout(v, val, &abs_timespec);
   53|      0|  }
   54|     18|}
_ZN4absl12lts_2026010724synchronization_internal11FutexWaiter4WaitENS1_13KernelTimeoutE:
   56|     18|bool FutexWaiter::Wait(KernelTimeout t) {
   57|       |  // Loop until we can atomically decrement futex from a positive
   58|       |  // value, waiting on a futex while we believe it is zero.
   59|       |  // Note that, since the thread ticker is just reset, we don't need to check
   60|       |  // whether the thread is idle on the very first pass of the loop.
   61|     18|  bool first_pass = true;
   62|     36|  while (true) {
  ------------------
  |  Branch (62:10): [True: 36, Folded]
  ------------------
   63|     36|    int32_t x = futex_.load(std::memory_order_relaxed);
   64|     36|    while (x != 0) {
  ------------------
  |  Branch (64:12): [True: 18, False: 18]
  ------------------
   65|     18|      if (!futex_.compare_exchange_weak(x, x - 1,
  ------------------
  |  Branch (65:11): [True: 0, False: 18]
  ------------------
   66|     18|                                        std::memory_order_acquire,
   67|     18|                                        std::memory_order_relaxed)) {
   68|      0|        continue;  // Raced with someone, retry.
   69|      0|      }
   70|     18|      return true;  // Consumed a wakeup, we are done.
   71|     18|    }
   72|       |
   73|     18|    if (!first_pass) MaybeBecomeIdle();
  ------------------
  |  Branch (73:9): [True: 0, False: 18]
  ------------------
   74|     18|    const int err = WaitUntil(&futex_, 0, t);
   75|     18|    if (err != 0) {
  ------------------
  |  Branch (75:9): [True: 0, False: 18]
  ------------------
   76|      0|      if (err == -EINTR || err == -EWOULDBLOCK) {
  ------------------
  |  Branch (76:11): [True: 0, False: 0]
  |  Branch (76:28): [True: 0, False: 0]
  ------------------
   77|       |        // Do nothing, the loop will retry.
   78|      0|      } else if (err == -ETIMEDOUT) {
  ------------------
  |  Branch (78:18): [True: 0, False: 0]
  ------------------
   79|      0|        return false;
   80|      0|      } else {
   81|      0|        ABSL_RAW_LOG(FATAL, "Futex operation failed with error %d\n", err);
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
   82|      0|      }
   83|      0|    }
   84|     18|    first_pass = false;
   85|     18|  }
   86|     18|}
_ZN4absl12lts_2026010724synchronization_internal11FutexWaiter4PostEv:
   88|     18|void FutexWaiter::Post() {
   89|     18|  if (futex_.fetch_add(1, std::memory_order_release) == 0) {
  ------------------
  |  Branch (89:7): [True: 18, False: 0]
  ------------------
   90|       |    // We incremented from 0, need to wake a potential waiter.
   91|     18|    Poke();
   92|     18|  }
   93|     18|}
_ZN4absl12lts_2026010724synchronization_internal11FutexWaiter4PokeEv:
   95|     18|void FutexWaiter::Poke() {
   96|       |  // Wake one thread waiting on the futex.
   97|     18|  const int err = Futex::Wake(&futex_, 1);
   98|     18|  if (ABSL_PREDICT_FALSE(err < 0)) {
  ------------------
  |  |  189|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 18]
  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  Branch (189:58): [True: 0, False: 18]
  |  |  ------------------
  ------------------
   99|       |    ABSL_RAW_LOG(FATAL, "Futex operation failed with error %d\n", err);
  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
  100|      0|  }
  101|     18|}

_ZN4absl12lts_2026010724synchronization_internal11FutexWaiterC2Ev:
   37|      2|  FutexWaiter() : futex_(0) {}

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

_ZNK4absl12lts_2026010724synchronization_internal13KernelTimeout11has_timeoutEv:
   59|     18|  bool has_timeout() const { return rep_ != kNoTimeout; }

AbslInternalPerThreadSemInit_lts_20260107:
   61|      2|    absl::base_internal::ThreadIdentity *identity) {
   62|      2|  new (absl::synchronization_internal::Waiter::GetWaiter(identity))
   63|      2|      absl::synchronization_internal::Waiter();
   64|      2|}
AbslInternalPerThreadSemPost_lts_20260107:
   67|     18|    absl::base_internal::ThreadIdentity *identity) {
   68|     18|  absl::synchronization_internal::Waiter::GetWaiter(identity)->Post();
   69|     18|}
AbslInternalPerThreadSemWait_lts_20260107:
   77|     18|    absl::synchronization_internal::KernelTimeout t) {
   78|     18|  bool timeout = false;
   79|     18|  absl::base_internal::ThreadIdentity *identity;
   80|     18|  identity = absl::synchronization_internal::GetOrCreateCurrentThreadIdentity();
   81|       |
   82|       |  // Ensure wait_start != 0.
   83|     18|  int ticker = identity->ticker.load(std::memory_order_relaxed);
   84|     18|  identity->wait_start.store(ticker ? ticker : 1, std::memory_order_relaxed);
  ------------------
  |  Branch (84:30): [True: 0, False: 18]
  ------------------
   85|     18|  identity->is_idle.store(false, std::memory_order_relaxed);
   86|       |
   87|     18|  if (identity->blocked_count_ptr != nullptr) {
  ------------------
  |  Branch (87:7): [True: 0, False: 18]
  ------------------
   88|       |    // Increment count of threads blocked in a given thread pool.
   89|      0|    identity->blocked_count_ptr->fetch_add(1, std::memory_order_relaxed);
   90|      0|  }
   91|       |
   92|     18|  timeout =
   93|     18|      !absl::synchronization_internal::Waiter::GetWaiter(identity)->Wait(t);
   94|       |
   95|     18|  if (identity->blocked_count_ptr != nullptr) {
  ------------------
  |  Branch (95:7): [True: 0, False: 18]
  ------------------
   96|      0|    identity->blocked_count_ptr->fetch_sub(1, std::memory_order_relaxed);
   97|      0|  }
   98|       |
   99|     18|  identity->is_idle.store(false, std::memory_order_relaxed);
  100|     18|  identity->wait_start.store(0, std::memory_order_relaxed);
  101|     18|  return !timeout;
  102|     18|}

_ZN4absl12lts_2026010724synchronization_internal12PerThreadSem4InitEPNS0_13base_internal14ThreadIdentityE:
  105|      2|    absl::base_internal::ThreadIdentity* identity) {
  106|      2|  ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemInit)(identity);
  ------------------
  |  |  187|      2|  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
  |  |  ------------------
  |  |  |  |  185|      2|  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
  |  |  |  |  ------------------
  |  |  |  |  |  |  183|      2|#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  107|      2|}
_ZN4absl12lts_2026010724synchronization_internal12PerThreadSem4PostEPNS0_13base_internal14ThreadIdentityE:
  110|     18|    absl::base_internal::ThreadIdentity* identity) {
  111|     18|  ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(identity);
  ------------------
  |  |  187|     18|  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
  |  |  ------------------
  |  |  |  |  185|     18|  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
  |  |  |  |  ------------------
  |  |  |  |  |  |  183|     18|#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  112|     18|}
_ZN4absl12lts_2026010724synchronization_internal12PerThreadSem4WaitENS1_13KernelTimeoutE:
  115|     18|    absl::synchronization_internal::KernelTimeout t) {
  116|     18|  return ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(t);
  ------------------
  |  |  187|     18|  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
  |  |  ------------------
  |  |  |  |  185|     18|  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
  |  |  |  |  ------------------
  |  |  |  |  |  |  183|     18|#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  117|     18|}

_ZN4absl12lts_2026010724synchronization_internal10WaiterCrtpINS1_11FutexWaiterEE9GetWaiterEPNS0_13base_internal14ThreadIdentityE:
   78|     38|  static T* GetWaiter(base_internal::ThreadIdentity* identity) {
   79|     38|    static_assert(
   80|     38|        sizeof(T) <= sizeof(base_internal::ThreadIdentity::WaiterState),
   81|     38|        "Insufficient space for Waiter");
   82|     38|    return reinterpret_cast<T*>(identity->waiter_state.data);
   83|     38|  }

AbslInternalMutexYield_lts_20260107:
   76|     41|ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)() {
   77|     41|  std::this_thread::yield();
   78|     41|}
_ZN4absl12lts_2026010724synchronization_internal10MutexDelayEii:
  178|  10.4k|int MutexDelay(int32_t c, int mode) {
  179|  10.4k|  const int32_t limit = GetMutexGlobals().mutex_sleep_spins[mode];
  180|  10.4k|  const absl::Duration sleep_time = GetMutexGlobals().mutex_sleep_time;
  181|  10.4k|  if (c < limit) {
  ------------------
  |  Branch (181:7): [True: 10.3k, False: 80]
  ------------------
  182|       |    // Spin.
  183|  10.3k|    c++;
  184|  10.3k|  } else {
  185|     80|    SchedulingGuard::ScopedEnable enable_rescheduling;
  186|     80|    ABSL_TSAN_MUTEX_PRE_DIVERT(nullptr, 0);
  187|     80|    if (c == limit) {
  ------------------
  |  Branch (187:9): [True: 41, False: 39]
  ------------------
  188|       |      // Yield once.
  189|     41|      ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
  ------------------
  |  |  187|     41|  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
  |  |  ------------------
  |  |  |  |  185|     41|  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
  |  |  |  |  ------------------
  |  |  |  |  |  |  183|     41|#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  190|     41|      c++;
  191|     41|    } else {
  192|       |      // Then wait.
  193|     39|      absl::SleepFor(sleep_time);
  194|     39|      c = 0;
  195|     39|    }
  196|     80|    ABSL_TSAN_MUTEX_POST_DIVERT(nullptr, 0);
  197|     80|  }
  198|  10.4k|  return c;
  199|  10.4k|}
_ZN4absl12lts_202601075Mutex17IncrementSynchSemEPS1_PNS0_13base_internal14PerThreadSynchE:
  580|     18|void Mutex::IncrementSynchSem(Mutex* mu, PerThreadSynch* w) {
  581|     18|  static_cast<void>(mu);  // Prevent unused param warning in non-TSAN builds.
  582|     18|  ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
  583|       |  // We miss synchronization around passing PerThreadSynch between threads
  584|       |  // since it happens inside of the Mutex code, so we need to ignore all
  585|       |  // accesses to the object.
  586|     18|  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
  ------------------
  |  |  383|     18|  do {                                                \
  |  |  384|     18|    ABSL_ANNOTATE_IGNORE_READS_BEGIN();               \
  |  |  ------------------
  |  |  |  |  317|     18|  ABSL_INTERNAL_GLOBAL_SCOPED(                                      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|     18|#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
  |  |  |  |  ------------------
  |  |  |  |  318|     18|      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin)) \
  |  |  |  |  319|     18|  ()
  |  |  ------------------
  |  |  385|     18|    ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();              \
  |  |  386|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (386:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
  587|     18|  PerThreadSem::Post(w->thread_identity());
  588|     18|  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END();
  ------------------
  |  |  390|     18|  do {                                              \
  |  |  391|     18|    ABSL_ANNOTATE_IGNORE_WRITES_END();              \
  |  |  392|     18|    ABSL_ANNOTATE_IGNORE_READS_END();               \
  |  |  ------------------
  |  |  |  |  322|     18|  ABSL_INTERNAL_GLOBAL_SCOPED(                                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|     18|#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
  |  |  |  |  ------------------
  |  |  |  |  323|     18|      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \
  |  |  |  |  324|     18|  ()
  |  |  ------------------
  |  |  393|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (393:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
  589|     18|  ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
  590|     18|}
_ZN4absl12lts_202601075Mutex17DecrementSynchSemEPS1_PNS0_13base_internal14PerThreadSynchENS0_24synchronization_internal13KernelTimeoutE:
  593|     18|bool Mutex::DecrementSynchSem(Mutex* mu, PerThreadSynch* w, KernelTimeout t) {
  594|     18|  static_cast<void>(mu);  // Prevent unused param warning in non-TSAN builds.
  595|     18|  ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
  596|       |  assert(w == Synch_GetPerThread());
  597|     18|  static_cast<void>(w);
  598|     18|  bool res = PerThreadSem::Wait(t);
  599|     18|  ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
  600|     18|  return res;
  601|     18|}
_ZN4absl12lts_202601075Mutex5BlockEPNS0_13base_internal14PerThreadSynchE:
 1178|     18|void Mutex::Block(PerThreadSynch* s) {
 1179|     36|  while (s->state.load(std::memory_order_acquire) == PerThreadSynch::kQueued) {
  ------------------
  |  Branch (1179:10): [True: 18, False: 18]
  ------------------
 1180|     18|    if (!DecrementSynchSem(this, s, s->waitp->timeout)) {
  ------------------
  |  Branch (1180:9): [True: 0, False: 18]
  ------------------
 1181|       |      // After a timeout, we go into a spin loop until we remove ourselves
 1182|       |      // from the queue, or someone else removes us.  We can't be sure to be
 1183|       |      // able to remove ourselves in a single lock acquisition because this
 1184|       |      // mutex may be held, and the holder has the right to read the centre
 1185|       |      // of the waiter queue without holding the spinlock.
 1186|      0|      this->TryRemove(s);
 1187|      0|      int c = 0;
 1188|      0|      while (s->next != nullptr) {
  ------------------
  |  Branch (1188:14): [True: 0, False: 0]
  ------------------
 1189|      0|        c = synchronization_internal::MutexDelay(c, GENTLE);
 1190|      0|        this->TryRemove(s);
 1191|      0|      }
 1192|      0|      if (kDebugMode) {
  ------------------
  |  Branch (1192:11): [Folded, False: 0]
  ------------------
 1193|       |        // This ensures that we test the case that TryRemove() is called when s
 1194|       |        // is not on the queue.
 1195|      0|        this->TryRemove(s);
 1196|      0|      }
 1197|      0|      s->waitp->timeout = KernelTimeout::Never();  // timeout is satisfied
 1198|      0|      s->waitp->cond = nullptr;  // condition no longer relevant for wakeups
 1199|      0|    }
 1200|     18|  }
 1201|     18|  ABSL_RAW_CHECK(s->waitp != nullptr || s->suppress_fatal_errors,
  ------------------
  |  |   60|     18|  do {                                                                 \
  |  |   61|     18|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 18]
  |  |  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  |  |  Branch (189:59): [True: 18, False: 0]
  |  |  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
 1202|     18|                 "detected illegal recursion in Mutex code");
 1203|     18|  s->waitp = nullptr;
 1204|     18|}
_ZN4absl12lts_202601075Mutex6WakeupEPNS0_13base_internal14PerThreadSynchE:
 1207|     18|PerThreadSynch* Mutex::Wakeup(PerThreadSynch* w) {
 1208|     18|  PerThreadSynch* next = w->next;
 1209|     18|  w->next = nullptr;
 1210|     18|  w->state.store(PerThreadSynch::kAvailable, std::memory_order_release);
 1211|     18|  IncrementSynchSem(this, w);
 1212|       |
 1213|     18|  return next;
 1214|     18|}
_ZN4absl12lts_202601075Mutex4lockEv:
 1530|   222k|void Mutex::lock() {
 1531|   222k|  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
 1532|   222k|  GraphId id = DebugOnlyDeadlockCheck(this);
 1533|   222k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1534|       |  // try fast acquire, then spin loop
 1535|   222k|  if (ABSL_PREDICT_FALSE((v & (kMuWriter | kMuReader | kMuEvent)) != 0) ||
  ------------------
  |  |  189|   445k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 8, False: 222k]
  |  |  |  Branch (189:49): [Folded, False: 222k]
  |  |  |  Branch (189:58): [True: 8, False: 222k]
  |  |  ------------------
  ------------------
 1536|   222k|      ABSL_PREDICT_FALSE(!mu_.compare_exchange_strong(
  ------------------
  |  |  189|   222k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 222k]
  |  |  |  Branch (189:49): [Folded, False: 222k]
  |  |  |  Branch (189:58): [True: 0, False: 222k]
  |  |  ------------------
  ------------------
 1537|   222k|          v, kMuWriter | v, std::memory_order_acquire,
 1538|   222k|          std::memory_order_relaxed))) {
 1539|       |    // try spin acquire, then slow loop
 1540|      8|    if (ABSL_PREDICT_FALSE(!TryAcquireWithSpinning(&this->mu_))) {
  ------------------
  |  |  189|      8|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 5, False: 3]
  |  |  |  Branch (189:49): [Folded, False: 8]
  |  |  |  Branch (189:58): [True: 5, False: 3]
  |  |  ------------------
  ------------------
 1541|      5|      this->LockSlow(kExclusive, nullptr, 0);
 1542|      5|    }
 1543|      8|  }
 1544|   222k|  DebugOnlyLockEnter(this, id);
 1545|   222k|  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 1546|   222k|}
_ZN4absl12lts_202601075Mutex11lock_sharedEv:
 1548|   619k|void Mutex::lock_shared() {
 1549|   619k|  ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
 1550|   619k|  GraphId id = DebugOnlyDeadlockCheck(this);
 1551|   619k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1552|   619k|  for (;;) {
 1553|       |    // If there are non-readers holding the lock, use the slow loop.
 1554|   619k|    if (ABSL_PREDICT_FALSE(v & (kMuWriter | kMuWait | kMuEvent)) != 0) {
  ------------------
  |  |  189|   619k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:49): [Folded, False: 619k]
  |  |  |  Branch (189:58): [True: 0, False: 619k]
  |  |  ------------------
  ------------------
  |  Branch (1554:9): [True: 0, False: 619k]
  ------------------
 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|   619k|    if (ABSL_PREDICT_TRUE(mu_.compare_exchange_weak(
  ------------------
  |  |  190|   619k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 619k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 619k]
  |  |  |  Branch (190:57): [True: 619k, False: 0]
  |  |  ------------------
  ------------------
 1561|   619k|            v, (kMuReader | v) + kMuOne, std::memory_order_acquire,
 1562|   619k|            std::memory_order_relaxed))) {
 1563|   619k|      break;
 1564|   619k|    }
 1565|   619k|  }
 1566|   619k|  DebugOnlyLockEnter(this, id);
 1567|   619k|  ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
 1568|   619k|}
_ZN4absl12lts_202601075Mutex11AwaitCommonERKNS0_9ConditionENS0_24synchronization_internal13KernelTimeoutE:
 1582|   111k|bool Mutex::AwaitCommon(const Condition& cond, KernelTimeout t) {
 1583|   111k|  if (kDebugMode) {
  ------------------
  |  Branch (1583:7): [Folded, False: 111k]
  ------------------
 1584|      0|    this->AssertReaderHeld();
 1585|      0|  }
 1586|   111k|  if (cond.Eval()) {  // condition already true; nothing to do
  ------------------
  |  Branch (1586:7): [True: 111k, False: 18]
  ------------------
 1587|   111k|    return true;
 1588|   111k|  }
 1589|     18|  MuHow how =
 1590|     18|      (mu_.load(std::memory_order_relaxed) & kMuWriter) ? kExclusive : kShared;
  ------------------
  |  Branch (1590:7): [True: 18, False: 0]
  ------------------
 1591|     18|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, TsanFlags(how));
 1592|     18|  SynchWaitParams waitp(how, &cond, t, nullptr /*no cvmu*/,
 1593|     18|                        Synch_GetPerThreadAnnotated(this),
 1594|     18|                        nullptr /*no cv_word*/);
 1595|     18|  this->UnlockSlow(&waitp);
 1596|     18|  this->Block(waitp.thread);
 1597|     18|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, TsanFlags(how));
 1598|     18|  ABSL_TSAN_MUTEX_PRE_LOCK(this, TsanFlags(how));
 1599|     18|  this->LockSlowLoop(&waitp, kMuHasBlocked | kMuIsCond);
 1600|     18|  bool res = waitp.cond != nullptr ||  // => cond known true from LockSlowLoop
  ------------------
  |  Branch (1600:14): [True: 18, False: 0]
  ------------------
 1601|      0|             EvalConditionAnnotated(&cond, this, true, false, how == kShared);
  ------------------
  |  Branch (1601:14): [True: 0, False: 0]
  ------------------
 1602|     18|  ABSL_TSAN_MUTEX_POST_LOCK(this, TsanFlags(how), 0);
 1603|     18|  ABSL_RAW_CHECK(res || t.has_timeout(),
  ------------------
  |  |   60|     18|  do {                                                                 \
  |  |   61|     18|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 18]
  |  |  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  |  |  Branch (189:59): [True: 18, False: 0]
  |  |  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
 1604|     18|                 "condition untrue on return from Await");
 1605|     18|  return res;
 1606|     18|}
_ZN4absl12lts_202601075Mutex6unlockEv:
 1708|   222k|void Mutex::unlock() {
 1709|   222k|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
 1710|   222k|  DebugOnlyLockLeave(this);
 1711|   222k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1712|       |
 1713|   222k|  if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) {
  ------------------
  |  Branch (1713:7): [Folded, False: 222k]
  |  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|   222k|  bool should_try_cas = ((v & (kMuEvent | kMuWriter)) == kMuWriter &&
  ------------------
  |  Branch (1720:26): [True: 222k, False: 0]
  ------------------
 1721|   222k|                         (v & (kMuWait | kMuDesig)) != kMuWait);
  ------------------
  |  Branch (1721:26): [True: 222k, False: 18]
  ------------------
 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|   222k|  static_assert(kMuEvent > kMuWait, "Needed for should_try_cas_fast");
 1740|   222k|  static_assert(kMuEvent > kMuDesig, "Needed for should_try_cas_fast");
 1741|   222k|  static_assert(kMuWriter > kMuWait, "Needed for should_try_cas_fast");
 1742|   222k|  static_assert(kMuWriter > kMuDesig, "Needed for should_try_cas_fast");
 1743|       |
 1744|   222k|  bool should_try_cas_fast =
 1745|   222k|      ((v ^ (kMuWriter | kMuDesig)) &
 1746|   222k|       (kMuEvent | kMuWriter | kMuWait | kMuDesig)) < (kMuWait | kMuDesig);
 1747|       |
 1748|   222k|  if (kDebugMode && should_try_cas != should_try_cas_fast) {
  ------------------
  |  Branch (1748:7): [Folded, False: 222k]
  |  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|   222k|  if (should_try_cas_fast &&
  ------------------
  |  Branch (1756:7): [True: 222k, False: 18]
  ------------------
 1757|   222k|      mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
  ------------------
  |  Branch (1757:7): [True: 222k, False: 0]
  ------------------
 1758|   222k|                                  std::memory_order_release,
 1759|   222k|                                  std::memory_order_relaxed)) {
 1760|       |    // fast writer release (writer with no waiters or with designated waker)
 1761|   222k|  } else {
 1762|     18|    this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
 1763|     18|  }
 1764|   222k|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
 1765|   222k|}
_ZN4absl12lts_202601075Mutex13unlock_sharedEv:
 1778|   619k|void Mutex::unlock_shared() {
 1779|   619k|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, __tsan_mutex_read_lock);
 1780|   619k|  DebugOnlyLockLeave(this);
 1781|   619k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1782|   619k|  assert((v & (kMuWriter | kMuReader)) == kMuReader);
 1783|   619k|  for (;;) {
 1784|   619k|    if (ABSL_PREDICT_FALSE((v & (kMuReader | kMuWait | kMuEvent)) !=
  ------------------
  |  |  189|   619k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 619k]
  |  |  |  Branch (189:49): [Folded, False: 619k]
  |  |  |  Branch (189:58): [True: 0, False: 619k]
  |  |  ------------------
  ------------------
 1785|   619k|                           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|   619k|    intptr_t clear = ExactlyOneReader(v) ? kMuReader | kMuOne : kMuOne;
  ------------------
  |  Branch (1790:22): [True: 619k, False: 0]
  ------------------
 1791|   619k|    if (ABSL_PREDICT_TRUE(
  ------------------
  |  |  190|   619k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 619k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 619k]
  |  |  |  Branch (190:57): [True: 619k, False: 0]
  |  |  ------------------
  ------------------
 1792|   619k|            mu_.compare_exchange_strong(v, v - clear, std::memory_order_release,
 1793|   619k|                                        std::memory_order_relaxed))) {
 1794|   619k|      break;
 1795|   619k|    }
 1796|   619k|  }
 1797|   619k|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, __tsan_mutex_read_lock);
 1798|   619k|}
_ZN4absl12lts_202601075Mutex8LockSlowEPKNS0_6MuHowSEPKNS0_9ConditionEi:
 1830|      5|                                             int flags) {
 1831|       |  // Note: we specifically initialize spinloop_iterations after the first use
 1832|       |  // in TryAcquireWithSpinning so that Lock function does not have any non-tail
 1833|       |  // calls and consequently a stack frame. It's fine to have spinloop_iterations
 1834|       |  // uninitialized (meaning no spinning) in all initial uncontended Lock calls
 1835|       |  // and in the first contended call. After that we will have
 1836|       |  // spinloop_iterations properly initialized.
 1837|      5|  if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  189|      5|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 4]
  |  |  |  Branch (189:49): [Folded, False: 5]
  |  |  |  Branch (189:58): [True: 1, False: 4]
  |  |  ------------------
  ------------------
 1838|      5|          globals.spinloop_iterations.load(std::memory_order_relaxed) == 0)) {
 1839|      1|    if (absl::base_internal::NumCPUs() > 1) {
  ------------------
  |  Branch (1839:9): [True: 1, False: 0]
  ------------------
 1840|       |      // If this is multiprocessor, allow spinning.
 1841|      1|      globals.spinloop_iterations.store(1500, std::memory_order_relaxed);
 1842|      1|    } else {
 1843|       |      // If this a uniprocessor, only yield/sleep.
 1844|      0|      globals.spinloop_iterations.store(-1, std::memory_order_relaxed);
 1845|      0|    }
 1846|      1|  }
 1847|       |  ABSL_RAW_CHECK(
  ------------------
  |  |   60|      5|  do {                                                                 \
  |  |   61|      5|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|      5|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 5]
  |  |  |  |  |  Branch (189:49): [Folded, False: 5]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 5]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      5|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 5]
  |  |  ------------------
  ------------------
 1848|      5|      this->LockSlowWithDeadline(how, cond, KernelTimeout::Never(), flags),
 1849|      5|      "condition untrue on return from LockSlow");
 1850|      5|}
_ZN4absl12lts_202601075Mutex20LockSlowWithDeadlineEPKNS0_6MuHowSEPKNS0_9ConditionENS0_24synchronization_internal13KernelTimeoutEi:
 1929|      5|                                 KernelTimeout t, int flags) {
 1930|      5|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1931|      5|  bool unlock = false;
 1932|      5|  if ((v & how->fast_need_zero) == 0 &&  // try fast acquire
  ------------------
  |  Branch (1932:7): [True: 0, False: 5]
  ------------------
 1933|      0|      mu_.compare_exchange_strong(
  ------------------
  |  Branch (1933:7): [True: 0, False: 0]
  ------------------
 1934|      0|          v,
 1935|      0|          (how->fast_or |
 1936|      0|           (v & ClearDesignatedWakerMask(flags & kMuHasBlocked))) +
 1937|      0|              how->fast_add,
 1938|      0|          std::memory_order_acquire, std::memory_order_relaxed)) {
 1939|      0|    if (cond == nullptr ||
  ------------------
  |  Branch (1939:9): [True: 0, False: 0]
  ------------------
 1940|      0|        EvalConditionAnnotated(cond, this, true, false, how == kShared)) {
  ------------------
  |  Branch (1940:9): [True: 0, False: 0]
  ------------------
 1941|      0|      return true;
 1942|      0|    }
 1943|      0|    unlock = true;
 1944|      0|  }
 1945|      5|  SynchWaitParams waitp(how, cond, t, nullptr /*no cvmu*/,
 1946|      5|                        Synch_GetPerThreadAnnotated(this),
 1947|      5|                        nullptr /*no cv_word*/);
 1948|      5|  if (cond != nullptr) {
  ------------------
  |  Branch (1948:7): [True: 0, False: 5]
  ------------------
 1949|      0|    flags |= kMuIsCond;
 1950|      0|  }
 1951|      5|  if (unlock) {
  ------------------
  |  Branch (1951:7): [True: 0, False: 5]
  ------------------
 1952|      0|    this->UnlockSlow(&waitp);
 1953|      0|    this->Block(waitp.thread);
 1954|      0|    flags |= kMuHasBlocked;
 1955|      0|  }
 1956|      5|  this->LockSlowLoop(&waitp, flags);
 1957|      5|  return waitp.cond != nullptr ||  // => cond known true from LockSlowLoop
  ------------------
  |  Branch (1957:10): [True: 0, False: 5]
  ------------------
 1958|      5|         cond == nullptr ||
  ------------------
  |  Branch (1958:10): [True: 5, False: 0]
  ------------------
 1959|      0|         EvalConditionAnnotated(cond, this, true, false, how == kShared);
  ------------------
  |  Branch (1959:10): [True: 0, False: 0]
  ------------------
 1960|      5|}
_ZN4absl12lts_202601075Mutex12LockSlowLoopEPNS0_15SynchWaitParamsEi:
 1995|     23|void Mutex::LockSlowLoop(SynchWaitParams* waitp, int flags) {
 1996|     23|  SchedulingGuard::ScopedDisable disable_rescheduling;
 1997|     23|  int c = 0;
 1998|     23|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1999|     23|  if ((v & kMuEvent) != 0) {
  ------------------
  |  Branch (1999:7): [True: 0, False: 23]
  ------------------
 2000|      0|    PostSynchEvent(
 2001|      0|        this, waitp->how == kExclusive ? SYNCH_EV_LOCK : SYNCH_EV_READERLOCK);
  ------------------
  |  Branch (2001:15): [True: 0, False: 0]
  ------------------
 2002|      0|  }
 2003|     23|  ABSL_RAW_CHECK(
  ------------------
  |  |   60|     23|  do {                                                                 \
  |  |   61|     23|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     23|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 23]
  |  |  |  |  |  Branch (189:49): [Folded, False: 23]
  |  |  |  |  |  Branch (189:59): [True: 23, False: 0]
  |  |  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     23|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 23]
  |  |  ------------------
  ------------------
 2004|     23|      waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
 2005|     23|      "detected illegal recursion into Mutex code");
 2006|  10.4k|  for (;;) {
 2007|  10.4k|    v = mu_.load(std::memory_order_relaxed);
 2008|  10.4k|    CheckForMutexCorruption(v, "Lock");
 2009|  10.4k|    if ((v & waitp->how->slow_need_zero) == 0) {
  ------------------
  |  Branch (2009:9): [True: 23, False: 10.4k]
  ------------------
 2010|     23|      if (mu_.compare_exchange_strong(
  ------------------
  |  Branch (2010:11): [True: 23, False: 0]
  ------------------
 2011|     23|              v,
 2012|     23|              (waitp->how->fast_or |
 2013|     23|               (v & ClearDesignatedWakerMask(flags & kMuHasBlocked))) +
 2014|     23|                  waitp->how->fast_add,
 2015|     23|              std::memory_order_acquire, std::memory_order_relaxed)) {
 2016|     23|        if (waitp->cond == nullptr ||
  ------------------
  |  Branch (2016:13): [True: 5, False: 18]
  ------------------
 2017|     18|            EvalConditionAnnotated(waitp->cond, this, true, false,
  ------------------
  |  Branch (2017:13): [True: 18, False: 0]
  ------------------
 2018|     23|                                   waitp->how == kShared)) {
 2019|     23|          break;  // we timed out, or condition true, so return
 2020|     23|        }
 2021|      0|        this->UnlockSlow(waitp);  // got lock but condition false
 2022|      0|        this->Block(waitp->thread);
 2023|      0|        flags |= kMuHasBlocked;
 2024|      0|        c = 0;
 2025|      0|      }
 2026|  10.4k|    } else {  // need to access waiter list
 2027|  10.4k|      bool dowait = false;
 2028|  10.4k|      if ((v & (kMuSpin | kMuWait)) == 0) {  // no waiters
  ------------------
  |  Branch (2028:11): [True: 0, False: 10.4k]
  ------------------
 2029|       |        // This thread tries to become the one and only waiter.
 2030|      0|        PerThreadSynch* new_h = Enqueue(nullptr, waitp, v, flags);
 2031|      0|        intptr_t nv =
 2032|      0|            (v & ClearDesignatedWakerMask(flags & kMuHasBlocked) & kMuLow) |
 2033|      0|            kMuWait;
 2034|      0|        ABSL_RAW_CHECK(new_h != nullptr, "Enqueue to empty list failed");
  ------------------
  |  |   60|      0|  do {                                                                 \
  |  |   61|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2035|      0|        if (waitp->how == kExclusive && (v & kMuReader) != 0) {
  ------------------
  |  Branch (2035:13): [True: 0, False: 0]
  |  Branch (2035:41): [True: 0, False: 0]
  ------------------
 2036|      0|          nv |= kMuWrWait;
 2037|      0|        }
 2038|      0|        if (mu_.compare_exchange_strong(
  ------------------
  |  Branch (2038:13): [True: 0, False: 0]
  ------------------
 2039|      0|                v, reinterpret_cast<intptr_t>(new_h) | nv,
 2040|      0|                std::memory_order_release, std::memory_order_relaxed)) {
 2041|      0|          dowait = true;
 2042|      0|        } else {  // attempted Enqueue() failed
 2043|       |          // zero out the waitp field set by Enqueue()
 2044|      0|          waitp->thread->waitp = nullptr;
 2045|      0|        }
 2046|  10.4k|      } else if ((v & waitp->how->slow_inc_need_zero &
  ------------------
  |  Branch (2046:18): [True: 0, False: 10.4k]
  ------------------
 2047|  10.4k|                  IgnoreWaitingWritersMask(flags & kMuHasBlocked)) == 0) {
 2048|       |        // This is a reader that needs to increment the reader count,
 2049|       |        // but the count is currently held in the last waiter.
 2050|      0|        if (mu_.compare_exchange_strong(
  ------------------
  |  Branch (2050:13): [True: 0, False: 0]
  ------------------
 2051|      0|                v,
 2052|      0|                (v & ClearDesignatedWakerMask(flags & kMuHasBlocked)) |
 2053|      0|                    kMuSpin | kMuReader,
 2054|      0|                std::memory_order_acquire, std::memory_order_relaxed)) {
 2055|      0|          PerThreadSynch* h = GetPerThreadSynch(v);
 2056|      0|          h->readers += kMuOne;  // inc reader count in waiter
 2057|      0|          do {                   // release spinlock
 2058|      0|            v = mu_.load(std::memory_order_relaxed);
 2059|      0|          } while (!mu_.compare_exchange_weak(v, (v & ~kMuSpin) | kMuReader,
  ------------------
  |  Branch (2059:20): [True: 0, False: 0]
  ------------------
 2060|      0|                                              std::memory_order_release,
 2061|      0|                                              std::memory_order_relaxed));
 2062|      0|          if (waitp->cond == nullptr ||
  ------------------
  |  Branch (2062:15): [True: 0, False: 0]
  ------------------
 2063|      0|              EvalConditionAnnotated(waitp->cond, this, true, false,
  ------------------
  |  Branch (2063:15): [True: 0, False: 0]
  ------------------
 2064|      0|                                     waitp->how == kShared)) {
 2065|      0|            break;  // we timed out, or condition true, so return
 2066|      0|          }
 2067|      0|          this->UnlockSlow(waitp);  // got lock but condition false
 2068|      0|          this->Block(waitp->thread);
 2069|      0|          flags |= kMuHasBlocked;
 2070|      0|          c = 0;
 2071|      0|        }
 2072|  10.4k|      } else if ((v & kMuSpin) == 0 &&  // attempt to queue ourselves
  ------------------
  |  Branch (2072:18): [True: 0, False: 10.4k]
  ------------------
 2073|      0|                 mu_.compare_exchange_strong(
  ------------------
  |  Branch (2073:18): [True: 0, False: 0]
  ------------------
 2074|      0|                     v,
 2075|      0|                     (v & ClearDesignatedWakerMask(flags & kMuHasBlocked)) |
 2076|      0|                         kMuSpin | kMuWait,
 2077|      0|                     std::memory_order_acquire, std::memory_order_relaxed)) {
 2078|      0|        PerThreadSynch* h = GetPerThreadSynch(v);
 2079|      0|        PerThreadSynch* new_h = Enqueue(h, waitp, v, flags);
 2080|      0|        intptr_t wr_wait = 0;
 2081|      0|        ABSL_RAW_CHECK(new_h != nullptr, "Enqueue to list failed");
  ------------------
  |  |   60|      0|  do {                                                                 \
  |  |   61|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2082|      0|        if (waitp->how == kExclusive && (v & kMuReader) != 0) {
  ------------------
  |  Branch (2082:13): [True: 0, False: 0]
  |  Branch (2082:41): [True: 0, False: 0]
  ------------------
 2083|      0|          wr_wait = kMuWrWait;  // give priority to a waiting writer
 2084|      0|        }
 2085|      0|        do {  // release spinlock
 2086|      0|          v = mu_.load(std::memory_order_relaxed);
 2087|      0|        } while (!mu_.compare_exchange_weak(
  ------------------
  |  Branch (2087:18): [True: 0, False: 0]
  ------------------
 2088|      0|            v,
 2089|      0|            (v & (kMuLow & ~kMuSpin)) | kMuWait | wr_wait |
 2090|      0|                reinterpret_cast<intptr_t>(new_h),
 2091|      0|            std::memory_order_release, std::memory_order_relaxed));
 2092|      0|        dowait = true;
 2093|      0|      }
 2094|  10.4k|      if (dowait) {
  ------------------
  |  Branch (2094:11): [True: 0, False: 10.4k]
  ------------------
 2095|      0|        this->Block(waitp->thread);  // wait until removed from list or timeout
 2096|      0|        flags |= kMuHasBlocked;
 2097|      0|        c = 0;
 2098|      0|      }
 2099|  10.4k|    }
 2100|  10.4k|    ABSL_RAW_CHECK(
  ------------------
  |  |   60|  10.4k|  do {                                                                 \
  |  |   61|  10.4k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|  10.4k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 10.4k]
  |  |  |  |  |  Branch (189:49): [Folded, False: 10.4k]
  |  |  |  |  |  Branch (189:59): [True: 10.4k, False: 0]
  |  |  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|  10.4k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 10.4k]
  |  |  ------------------
  ------------------
 2101|  10.4k|        waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
 2102|  10.4k|        "detected illegal recursion into Mutex code");
 2103|       |    // delay, then try again
 2104|  10.4k|    c = synchronization_internal::MutexDelay(c, GENTLE);
 2105|  10.4k|  }
 2106|     23|  ABSL_RAW_CHECK(
  ------------------
  |  |   60|     23|  do {                                                                 \
  |  |   61|     23|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     23|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 23]
  |  |  |  |  |  Branch (189:49): [Folded, False: 23]
  |  |  |  |  |  Branch (189:59): [True: 23, False: 0]
  |  |  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     23|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 23]
  |  |  ------------------
  ------------------
 2107|     23|      waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
 2108|     23|      "detected illegal recursion into Mutex code");
 2109|     23|  if ((v & kMuEvent) != 0) {
  ------------------
  |  Branch (2109:7): [True: 0, False: 23]
  ------------------
 2110|      0|    PostSynchEvent(this, waitp->how == kExclusive
  ------------------
  |  Branch (2110:26): [True: 0, False: 0]
  ------------------
 2111|      0|                             ? SYNCH_EV_LOCK_RETURNING
 2112|      0|                             : SYNCH_EV_READERLOCK_RETURNING);
 2113|      0|  }
 2114|     23|}
_ZN4absl12lts_202601075Mutex10UnlockSlowEPNS0_15SynchWaitParamsE:
 2121|     36|ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams* waitp) {
 2122|     36|  SchedulingGuard::ScopedDisable disable_rescheduling;
 2123|     36|  intptr_t v = mu_.load(std::memory_order_relaxed);
 2124|     36|  this->AssertReaderHeld();
 2125|     36|  CheckForMutexCorruption(v, "Unlock");
 2126|     36|  if ((v & kMuEvent) != 0) {
  ------------------
  |  Branch (2126:7): [True: 0, False: 36]
  ------------------
 2127|      0|    PostSynchEvent(
 2128|      0|        this, (v & kMuWriter) != 0 ? SYNCH_EV_UNLOCK : SYNCH_EV_READERUNLOCK);
  ------------------
  |  Branch (2128:15): [True: 0, False: 0]
  ------------------
 2129|      0|  }
 2130|     36|  int c = 0;
 2131|       |  // the waiter under consideration to wake, or zero
 2132|     36|  PerThreadSynch* w = nullptr;
 2133|       |  // the predecessor to w or zero
 2134|     36|  PerThreadSynch* pw = nullptr;
 2135|       |  // head of the list searched previously, or zero
 2136|     36|  PerThreadSynch* old_h = nullptr;
 2137|       |  // a condition that's known to be false.
 2138|     36|  PerThreadSynch* wake_list = kPerThreadSynchNull;  // list of threads to wake
 2139|     36|  intptr_t wr_wait = 0;  // set to kMuWrWait if we wake a reader and a
 2140|       |                         // later writer could have acquired the lock
 2141|       |                         // (starvation avoidance)
 2142|     36|  ABSL_RAW_CHECK(waitp == nullptr || waitp->thread->waitp == nullptr ||
  ------------------
  |  |   60|     36|  do {                                                                 \
  |  |   61|     36|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     90|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 36]
  |  |  |  |  |  Branch (189:49): [Folded, False: 36]
  |  |  |  |  |  Branch (189:59): [True: 18, False: 18]
  |  |  |  |  |  Branch (189:59): [True: 18, False: 0]
  |  |  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     36|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 36]
  |  |  ------------------
  ------------------
 2143|     36|                     waitp->thread->suppress_fatal_errors,
 2144|     36|                 "detected illegal recursion into Mutex code");
 2145|       |  // This loop finds threads wake_list to wakeup if any, and removes them from
 2146|       |  // the list of waiters.  In addition, it places waitp.thread on the queue of
 2147|       |  // waiters if waitp is non-zero.
 2148|     54|  for (;;) {
 2149|     54|    v = mu_.load(std::memory_order_relaxed);
 2150|     54|    if ((v & kMuWriter) != 0 && (v & (kMuWait | kMuDesig)) != kMuWait &&
  ------------------
  |  Branch (2150:9): [True: 54, False: 0]
  |  Branch (2150:33): [True: 18, False: 36]
  ------------------
 2151|     18|        waitp == nullptr) {
  ------------------
  |  Branch (2151:9): [True: 0, False: 18]
  ------------------
 2152|       |      // fast writer release (writer with no waiters or with designated waker)
 2153|      0|      if (mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
  ------------------
  |  Branch (2153:11): [True: 0, False: 0]
  ------------------
 2154|      0|                                      std::memory_order_release,
 2155|      0|                                      std::memory_order_relaxed)) {
 2156|      0|        return;
 2157|      0|      }
 2158|     54|    } else if ((v & (kMuReader | kMuWait)) == kMuReader && waitp == nullptr) {
  ------------------
  |  Branch (2158:16): [True: 0, False: 54]
  |  Branch (2158:60): [True: 0, False: 0]
  ------------------
 2159|       |      // fast reader release (reader with no waiters)
 2160|      0|      intptr_t clear = ExactlyOneReader(v) ? kMuReader | kMuOne : kMuOne;
  ------------------
  |  Branch (2160:24): [True: 0, False: 0]
  ------------------
 2161|      0|      if (mu_.compare_exchange_strong(v, v - clear, std::memory_order_release,
  ------------------
  |  Branch (2161:11): [True: 0, False: 0]
  ------------------
 2162|      0|                                      std::memory_order_relaxed)) {
 2163|      0|        return;
 2164|      0|      }
 2165|     54|    } else if ((v & kMuSpin) == 0 &&  // attempt to get spinlock
  ------------------
  |  Branch (2165:16): [True: 54, False: 0]
  ------------------
 2166|     54|               mu_.compare_exchange_strong(v, v | kMuSpin,
  ------------------
  |  Branch (2166:16): [True: 54, False: 0]
  ------------------
 2167|     54|                                           std::memory_order_acquire,
 2168|     54|                                           std::memory_order_relaxed)) {
 2169|     54|      if ((v & kMuWait) == 0) {  // no one to wake
  ------------------
  |  Branch (2169:11): [True: 18, False: 36]
  ------------------
 2170|     18|        intptr_t nv;
 2171|     18|        bool do_enqueue = true;  // always Enqueue() the first time
 2172|     18|        ABSL_RAW_CHECK(waitp != nullptr,
  ------------------
  |  |   60|     18|  do {                                                                 \
  |  |   61|     18|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 18]
  |  |  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 18]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
 2173|     18|                       "UnlockSlow is confused");  // about to sleep
 2174|     18|        do {  // must loop to release spinlock as reader count may change
 2175|     18|          v = mu_.load(std::memory_order_relaxed);
 2176|       |          // decrement reader count if there are readers
 2177|     18|          intptr_t new_readers = (v >= kMuOne) ? v - kMuOne : v;
  ------------------
  |  Branch (2177:34): [True: 0, False: 18]
  ------------------
 2178|     18|          PerThreadSynch* new_h = nullptr;
 2179|     18|          if (do_enqueue) {
  ------------------
  |  Branch (2179:15): [True: 18, False: 0]
  ------------------
 2180|       |            // If we are enqueuing on a CondVar (waitp->cv_word != nullptr) then
 2181|       |            // we must not retry here.  The initial attempt will always have
 2182|       |            // succeeded, further attempts would enqueue us against *this due to
 2183|       |            // Fer() handling.
 2184|     18|            do_enqueue = (waitp->cv_word == nullptr);
 2185|     18|            new_h = Enqueue(nullptr, waitp, new_readers, kMuIsCond);
 2186|     18|          }
 2187|     18|          intptr_t clear = kMuWrWait | kMuWriter;  // by default clear write bit
 2188|     18|          if ((v & kMuWriter) == 0 && ExactlyOneReader(v)) {  // last reader
  ------------------
  |  Branch (2188:15): [True: 0, False: 18]
  |  Branch (2188:39): [True: 0, False: 0]
  ------------------
 2189|      0|            clear = kMuWrWait | kMuReader;                    // clear read bit
 2190|      0|          }
 2191|     18|          nv = (v & kMuLow & ~clear & ~kMuSpin);
 2192|     18|          if (new_h != nullptr) {
  ------------------
  |  Branch (2192:15): [True: 18, False: 0]
  ------------------
 2193|     18|            nv |= kMuWait | reinterpret_cast<intptr_t>(new_h);
 2194|     18|          } else {  // new_h could be nullptr if we queued ourselves on a
 2195|       |                    // CondVar
 2196|       |            // In that case, we must place the reader count back in the mutex
 2197|       |            // word, as Enqueue() did not store it in the new waiter.
 2198|      0|            nv |= new_readers & kMuHigh;
 2199|      0|          }
 2200|       |          // release spinlock & our lock; retry if reader-count changed
 2201|       |          // (writer count cannot change since we hold lock)
 2202|     18|        } while (!mu_.compare_exchange_weak(v, nv, std::memory_order_release,
  ------------------
  |  Branch (2202:18): [True: 0, False: 18]
  ------------------
 2203|     18|                                            std::memory_order_relaxed));
 2204|     18|        break;
 2205|     18|      }
 2206|       |
 2207|       |      // There are waiters.
 2208|       |      // Set h to the head of the circular waiter list.
 2209|     36|      PerThreadSynch* h = GetPerThreadSynch(v);
 2210|     36|      if ((v & kMuReader) != 0 && (h->readers & kMuHigh) > kMuOne) {
  ------------------
  |  Branch (2210:11): [True: 0, False: 36]
  |  Branch (2210:35): [True: 0, False: 0]
  ------------------
 2211|       |        // a reader but not the last
 2212|      0|        h->readers -= kMuOne;    // release our lock
 2213|      0|        intptr_t nv = v;         // normally just release spinlock
 2214|      0|        if (waitp != nullptr) {  // but waitp!=nullptr => must queue ourselves
  ------------------
  |  Branch (2214:13): [True: 0, False: 0]
  ------------------
 2215|      0|          PerThreadSynch* new_h = Enqueue(h, waitp, v, kMuIsCond);
 2216|      0|          ABSL_RAW_CHECK(new_h != nullptr,
  ------------------
  |  |   60|      0|  do {                                                                 \
  |  |   61|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2217|      0|                         "waiters disappeared during Enqueue()!");
 2218|      0|          nv &= kMuLow;
 2219|      0|          nv |= kMuWait | reinterpret_cast<intptr_t>(new_h);
 2220|      0|        }
 2221|      0|        mu_.store(nv, std::memory_order_release);  // release spinlock
 2222|       |        // can release with a store because there were waiters
 2223|      0|        break;
 2224|      0|      }
 2225|       |
 2226|       |      // Either we didn't search before, or we marked the queue
 2227|       |      // as "maybe_unlocking" and no one else should have changed it.
 2228|     36|      ABSL_RAW_CHECK(old_h == nullptr || h->maybe_unlocking,
  ------------------
  |  |   60|     36|  do {                                                                 \
  |  |   61|     36|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     54|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 36]
  |  |  |  |  |  Branch (189:49): [Folded, False: 36]
  |  |  |  |  |  Branch (189:59): [True: 18, False: 18]
  |  |  |  |  |  Branch (189:59): [True: 18, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     36|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 36]
  |  |  ------------------
  ------------------
 2229|     36|                     "Mutex queue changed beneath us");
 2230|       |
 2231|       |      // The lock is becoming free, and there's a waiter
 2232|     36|      if (old_h != nullptr &&
  ------------------
  |  Branch (2232:11): [True: 18, False: 18]
  ------------------
 2233|     18|          !old_h->may_skip) {    // we used old_h as a terminator
  ------------------
  |  Branch (2233:11): [True: 18, False: 0]
  ------------------
 2234|     18|        old_h->may_skip = true;  // allow old_h to skip once more
 2235|     18|        ABSL_RAW_CHECK(old_h->skip == nullptr, "illegal skip from head");
  ------------------
  |  |   60|     18|  do {                                                                 \
  |  |   61|     18|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 18]
  |  |  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 18]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
 2236|     18|        if (h != old_h && MuEquivalentWaiter(old_h, old_h->next)) {
  ------------------
  |  Branch (2236:13): [True: 0, False: 18]
  |  Branch (2236:27): [True: 0, False: 0]
  ------------------
 2237|      0|          old_h->skip = old_h->next;  // old_h not head & can skip to successor
 2238|      0|        }
 2239|     18|      }
 2240|     36|      if (h->next->waitp->how == kExclusive &&
  ------------------
  |  Branch (2240:11): [True: 36, False: 0]
  ------------------
 2241|     36|          h->next->waitp->cond == nullptr) {
  ------------------
  |  Branch (2241:11): [True: 0, False: 36]
  ------------------
 2242|       |        // easy case: writer with no condition; no need to search
 2243|      0|        pw = h;  // wake w, the successor of h (=pw)
 2244|      0|        w = h->next;
 2245|      0|        w->wake = true;
 2246|       |        // We are waking up a writer.  This writer may be racing against
 2247|       |        // an already awake reader for the lock.  We want the
 2248|       |        // writer to usually win this race,
 2249|       |        // because if it doesn't, we can potentially keep taking a reader
 2250|       |        // perpetually and writers will starve.  Worse than
 2251|       |        // that, this can also starve other readers if kMuWrWait gets set
 2252|       |        // later.
 2253|      0|        wr_wait = kMuWrWait;
 2254|     36|      } else if (w != nullptr && (w->waitp->how == kExclusive || h == old_h)) {
  ------------------
  |  Branch (2254:18): [True: 18, False: 18]
  |  Branch (2254:35): [True: 18, False: 0]
  |  Branch (2254:66): [True: 0, False: 0]
  ------------------
 2255|       |        // we found a waiter w to wake on a previous iteration and either it's
 2256|       |        // a writer, or we've searched the entire list so we have all the
 2257|       |        // readers.
 2258|     18|        if (pw == nullptr) {  // if w's predecessor is unknown, it must be h
  ------------------
  |  Branch (2258:13): [True: 18, False: 0]
  ------------------
 2259|     18|          pw = h;
 2260|     18|        }
 2261|     18|      } else {
 2262|       |        // At this point we don't know all the waiters to wake, and the first
 2263|       |        // waiter has a condition or is a reader.  We avoid searching over
 2264|       |        // waiters we've searched on previous iterations by starting at
 2265|       |        // old_h if it's set.  If old_h==h, there's no one to wakeup at all.
 2266|     18|        if (old_h == h) {  // we've searched before, and nothing's new
  ------------------
  |  Branch (2266:13): [True: 0, False: 18]
  ------------------
 2267|       |                           // so there's no one to wake.
 2268|      0|          intptr_t nv = (v & ~(kMuReader | kMuWriter | kMuWrWait));
 2269|      0|          h->readers = 0;
 2270|      0|          h->maybe_unlocking = false;  // finished unlocking
 2271|      0|          if (waitp != nullptr) {      // we must queue ourselves and sleep
  ------------------
  |  Branch (2271:15): [True: 0, False: 0]
  ------------------
 2272|      0|            PerThreadSynch* new_h = Enqueue(h, waitp, v, kMuIsCond);
 2273|      0|            nv &= kMuLow;
 2274|      0|            if (new_h != nullptr) {
  ------------------
  |  Branch (2274:17): [True: 0, False: 0]
  ------------------
 2275|      0|              nv |= kMuWait | reinterpret_cast<intptr_t>(new_h);
 2276|      0|            }  // else new_h could be nullptr if we queued ourselves on a
 2277|       |               // CondVar
 2278|      0|          }
 2279|       |          // release spinlock & lock
 2280|       |          // can release with a store because there were waiters
 2281|      0|          mu_.store(nv, std::memory_order_release);
 2282|      0|          break;
 2283|      0|        }
 2284|       |
 2285|       |        // set up to walk the list
 2286|     18|        PerThreadSynch* w_walk;   // current waiter during list walk
 2287|     18|        PerThreadSynch* pw_walk;  // previous waiter during list walk
 2288|     18|        if (old_h != nullptr) {   // we've searched up to old_h before
  ------------------
  |  Branch (2288:13): [True: 0, False: 18]
  ------------------
 2289|      0|          pw_walk = old_h;
 2290|      0|          w_walk = old_h->next;
 2291|     18|        } else {  // no prior search, start at beginning
 2292|     18|          pw_walk =
 2293|     18|              nullptr;  // h->next's predecessor may change; don't record it
 2294|     18|          w_walk = h->next;
 2295|     18|        }
 2296|       |
 2297|     18|        h->may_skip = false;  // ensure we never skip past h in future searches
 2298|       |                              // even if other waiters are queued after it.
 2299|     18|        ABSL_RAW_CHECK(h->skip == nullptr, "illegal skip from head");
  ------------------
  |  |   60|     18|  do {                                                                 \
  |  |   61|     18|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 18]
  |  |  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 18]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
 2300|       |
 2301|     18|        h->maybe_unlocking = true;  // we're about to scan the waiter list
 2302|       |                                    // without the spinlock held.
 2303|       |                                    // Enqueue must be conservative about
 2304|       |                                    // priority queuing.
 2305|       |
 2306|       |        // We must release the spinlock to evaluate the conditions.
 2307|     18|        mu_.store(v, std::memory_order_release);  // release just spinlock
 2308|       |        // can release with a store because there were waiters
 2309|       |
 2310|       |        // h is the last waiter queued, and w_walk the first unsearched waiter.
 2311|       |        // Without the spinlock, the locations mu_ and h->next may now change
 2312|       |        // underneath us, but since we hold the lock itself, the only legal
 2313|       |        // change is to add waiters between h and w_walk.  Therefore, it's safe
 2314|       |        // to walk the path from w_walk to h inclusive. (TryRemove() can remove
 2315|       |        // a waiter anywhere, but it acquires both the spinlock and the Mutex)
 2316|       |
 2317|     18|        old_h = h;  // remember we searched to here
 2318|       |
 2319|       |        // Walk the path upto and including h looking for waiters we can wake.
 2320|     18|        while (pw_walk != h) {
  ------------------
  |  Branch (2320:16): [True: 18, False: 0]
  ------------------
 2321|     18|          w_walk->wake = false;
 2322|     18|          if (w_walk->waitp->cond ==
  ------------------
  |  Branch (2322:15): [True: 0, False: 18]
  ------------------
 2323|     18|                  nullptr ||  // no condition => vacuously true OR
 2324|       |                              // this thread's condition is true
 2325|     18|              EvalConditionIgnored(this, w_walk->waitp->cond)) {
  ------------------
  |  Branch (2325:15): [True: 18, False: 0]
  ------------------
 2326|     18|            if (w == nullptr) {
  ------------------
  |  Branch (2326:17): [True: 18, False: 0]
  ------------------
 2327|     18|              w_walk->wake = true;  // can wake this waiter
 2328|     18|              w = w_walk;
 2329|     18|              pw = pw_walk;
 2330|     18|              if (w_walk->waitp->how == kExclusive) {
  ------------------
  |  Branch (2330:19): [True: 18, False: 0]
  ------------------
 2331|     18|                wr_wait = kMuWrWait;
 2332|     18|                break;  // bail if waking this writer
 2333|     18|              }
 2334|     18|            } else if (w_walk->waitp->how == kShared) {  // wake if a reader
  ------------------
  |  Branch (2334:24): [True: 0, False: 0]
  ------------------
 2335|      0|              w_walk->wake = true;
 2336|      0|            } else {  // writer with true condition
 2337|      0|              wr_wait = kMuWrWait;
 2338|      0|            }
 2339|     18|          }
 2340|      0|          if (w_walk->wake) {  // we're waking reader w_walk
  ------------------
  |  Branch (2340:15): [True: 0, False: 0]
  ------------------
 2341|      0|            pw_walk = w_walk;  // don't skip similar waiters
 2342|      0|          } else {             // not waking; skip as much as possible
 2343|      0|            pw_walk = Skip(w_walk);
 2344|      0|          }
 2345|       |          // If pw_walk == h, then load of pw_walk->next can race with
 2346|       |          // concurrent write in Enqueue(). However, at the same time
 2347|       |          // we do not need to do the load, because we will bail out
 2348|       |          // from the loop anyway.
 2349|      0|          if (pw_walk != h) {
  ------------------
  |  Branch (2349:15): [True: 0, False: 0]
  ------------------
 2350|      0|            w_walk = pw_walk->next;
 2351|      0|          }
 2352|      0|        }
 2353|       |
 2354|     18|        continue;  // restart for(;;)-loop to wakeup w or to find more waiters
 2355|     18|      }
 2356|     18|      ABSL_RAW_CHECK(pw->next == w, "pw not w's predecessor");
  ------------------
  |  |   60|     18|  do {                                                                 \
  |  |   61|     18|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 18]
  |  |  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 18]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
 2357|       |      // The first (and perhaps only) waiter we've chosen to wake is w, whose
 2358|       |      // predecessor is pw.  If w is a reader, we must wake all the other
 2359|       |      // waiters with wake==true as well.  We may also need to queue
 2360|       |      // ourselves if waitp != null.  The spinlock and the lock are still
 2361|       |      // held.
 2362|       |
 2363|       |      // This traverses the list in [ pw->next, h ], where h is the head,
 2364|       |      // removing all elements with wake==true and placing them in the
 2365|       |      // singly-linked list wake_list.  Returns the new head.
 2366|     18|      h = DequeueAllWakeable(h, pw, &wake_list);
 2367|       |
 2368|     18|      intptr_t nv = (v & kMuEvent) | kMuDesig;
 2369|       |      // assume no waiters left,
 2370|       |      // set kMuDesig for INV1a
 2371|       |
 2372|     18|      if (waitp != nullptr) {  // we must queue ourselves and sleep
  ------------------
  |  Branch (2372:11): [True: 0, False: 18]
  ------------------
 2373|      0|        h = Enqueue(h, waitp, v, kMuIsCond);
 2374|       |        // h is new last waiter; could be null if we queued ourselves on a
 2375|       |        // CondVar
 2376|      0|      }
 2377|       |
 2378|     18|      ABSL_RAW_CHECK(wake_list != kPerThreadSynchNull,
  ------------------
  |  |   60|     18|  do {                                                                 \
  |  |   61|     18|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 18]
  |  |  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 18]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
 2379|     18|                     "unexpected empty wake list");
 2380|       |
 2381|     18|      if (h != nullptr) {  // there are waiters left
  ------------------
  |  Branch (2381:11): [True: 0, False: 18]
  ------------------
 2382|      0|        h->readers = 0;
 2383|      0|        h->maybe_unlocking = false;  // finished unlocking
 2384|      0|        nv |= wr_wait | kMuWait | reinterpret_cast<intptr_t>(h);
 2385|      0|      }
 2386|       |
 2387|       |      // release both spinlock & lock
 2388|       |      // can release with a store because there were waiters
 2389|     18|      mu_.store(nv, std::memory_order_release);
 2390|     18|      break;  // out of for(;;)-loop
 2391|     18|    }
 2392|       |    // aggressive here; no one can proceed till we do
 2393|      0|    c = synchronization_internal::MutexDelay(c, AGGRESSIVE);
 2394|      0|  }  // end of for(;;)-loop
 2395|       |
 2396|     36|  if (wake_list != kPerThreadSynchNull) {
  ------------------
  |  Branch (2396:7): [True: 18, False: 18]
  ------------------
 2397|     18|    int64_t total_wait_cycles = 0;
 2398|     18|    int64_t max_wait_cycles = 0;
 2399|     18|    int64_t now = CycleClock::Now();
 2400|     18|    do {
 2401|       |      // Profile lock contention events only if the waiter was trying to acquire
 2402|       |      // the lock, not waiting on a condition variable or Condition.
 2403|     18|      if (!wake_list->cond_waiter) {
  ------------------
  |  Branch (2403:11): [True: 0, False: 18]
  ------------------
 2404|      0|        int64_t cycles_waited =
 2405|      0|            (now - wake_list->waitp->contention_start_cycles);
 2406|      0|        total_wait_cycles += cycles_waited;
 2407|      0|        if (max_wait_cycles == 0) max_wait_cycles = cycles_waited;
  ------------------
  |  Branch (2407:13): [True: 0, False: 0]
  ------------------
 2408|      0|        wake_list->waitp->contention_start_cycles = now;
 2409|      0|        wake_list->waitp->should_submit_contention_data = true;
 2410|      0|      }
 2411|     18|      wake_list = Wakeup(wake_list);  // wake waiters
 2412|     18|    } while (wake_list != kPerThreadSynchNull);
  ------------------
  |  Branch (2412:14): [True: 0, False: 18]
  ------------------
 2413|     18|    if (total_wait_cycles > 0) {
  ------------------
  |  Branch (2413:9): [True: 0, False: 18]
  ------------------
 2414|      0|      mutex_tracer("slow release", this, total_wait_cycles);
 2415|      0|      ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
 2416|      0|      submit_profile_data(total_wait_cycles);
 2417|      0|      ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
 2418|      0|    }
 2419|     18|  }
 2420|     36|}
_ZNK4absl12lts_202601075Mutex16AssertReaderHeldEv:
 2503|     36|void Mutex::AssertReaderHeld() const {
 2504|     36|  if ((mu_.load(std::memory_order_relaxed) & (kMuReader | kMuWriter)) == 0) {
  ------------------
  |  Branch (2504:7): [True: 0, False: 36]
  ------------------
 2505|      0|    SynchEvent* e = GetSynchEvent(this);
 2506|       |    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__);                             \
  |  |  ------------------
  |  |  |  Branch (50:38): [True: 0, False: 0]
  |  |  ------------------
  |  |   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]
  |  |  ------------------
  ------------------
 2507|      0|                 "thread should hold at least a read lock on Mutex %p %s",
 2508|      0|                 static_cast<const void*>(this), (e == nullptr ? "" : e->name));
 2509|      0|  }
 2510|     36|}
_ZNK4absl12lts_202601079Condition4EvalEv:
 2808|   111k|bool Condition::Eval() const { return (*this->eval_)(this); }
mutex.cc:_ZN4absl12lts_2026010712_GLOBAL__N_115GetMutexGlobalsEv:
  147|  20.8k|const MutexGlobals& GetMutexGlobals() {
  148|  20.8k|  absl::base_internal::LowLevelCallOnce(&globals.once, [&]() {
  149|  20.8k|    if (absl::base_internal::NumCPUs() > 1) {
  150|       |      // If the mode is aggressive then spin many times before yielding.
  151|       |      // If the mode is gentle then spin only a few times before yielding.
  152|       |      // Aggressive spinning is used to ensure that an Unlock() call,
  153|       |      // which must get the spin lock for any thread to make progress gets it
  154|       |      // without undue delay.
  155|  20.8k|      globals.mutex_sleep_spins[AGGRESSIVE] = 5000;
  156|  20.8k|      globals.mutex_sleep_spins[GENTLE] = 250;
  157|  20.8k|      globals.mutex_sleep_time = absl::Microseconds(10);
  158|  20.8k|    } else {
  159|       |      // If this a uniprocessor, only yield/sleep. Real-time threads are often
  160|       |      // unable to yield, so the sleep time needs to be long enough to keep
  161|       |      // the calling thread asleep until scheduling happens.
  162|  20.8k|      globals.mutex_sleep_spins[AGGRESSIVE] = 0;
  163|  20.8k|      globals.mutex_sleep_spins[GENTLE] = 0;
  164|  20.8k|      globals.mutex_sleep_time = MeasureTimeToYield() * 5;
  165|  20.8k|      globals.mutex_sleep_time =
  166|  20.8k|          std::min(globals.mutex_sleep_time, absl::Milliseconds(1));
  167|  20.8k|      globals.mutex_sleep_time =
  168|  20.8k|          std::max(globals.mutex_sleep_time, absl::Microseconds(10));
  169|  20.8k|    }
  170|  20.8k|  });
  171|  20.8k|  return globals;
  172|  20.8k|}
mutex.cc:_ZZN4absl12lts_2026010712_GLOBAL__N_115GetMutexGlobalsEvENK3$_0clEv:
  148|      1|  absl::base_internal::LowLevelCallOnce(&globals.once, [&]() {
  149|      1|    if (absl::base_internal::NumCPUs() > 1) {
  ------------------
  |  Branch (149:9): [True: 1, False: 0]
  ------------------
  150|       |      // If the mode is aggressive then spin many times before yielding.
  151|       |      // If the mode is gentle then spin only a few times before yielding.
  152|       |      // Aggressive spinning is used to ensure that an Unlock() call,
  153|       |      // which must get the spin lock for any thread to make progress gets it
  154|       |      // without undue delay.
  155|      1|      globals.mutex_sleep_spins[AGGRESSIVE] = 5000;
  156|      1|      globals.mutex_sleep_spins[GENTLE] = 250;
  157|      1|      globals.mutex_sleep_time = absl::Microseconds(10);
  158|      1|    } else {
  159|       |      // If this a uniprocessor, only yield/sleep. Real-time threads are often
  160|       |      // unable to yield, so the sleep time needs to be long enough to keep
  161|       |      // the calling thread asleep until scheduling happens.
  162|      0|      globals.mutex_sleep_spins[AGGRESSIVE] = 0;
  163|      0|      globals.mutex_sleep_spins[GENTLE] = 0;
  164|      0|      globals.mutex_sleep_time = MeasureTimeToYield() * 5;
  165|      0|      globals.mutex_sleep_time =
  166|      0|          std::min(globals.mutex_sleep_time, absl::Milliseconds(1));
  167|      0|      globals.mutex_sleep_time =
  168|      0|          std::max(globals.mutex_sleep_time, absl::Microseconds(10));
  169|      0|    }
  170|      1|  });
mutex.cc:_ZN4absl12lts_20260107L17GetPerThreadSynchEl:
  813|     36|static inline PerThreadSynch* GetPerThreadSynch(intptr_t v) {
  814|     36|  return reinterpret_cast<PerThreadSynch*>(v & kMuHigh);
  815|     36|}
mutex.cc:_ZN4absl12lts_20260107L7DequeueEPNS0_13base_internal14PerThreadSynchES3_:
 1061|     18|static PerThreadSynch* Dequeue(PerThreadSynch* head, PerThreadSynch* pw) {
 1062|     18|  PerThreadSynch* w = pw->next;
 1063|     18|  pw->next = w->next;                 // snip w out of list
 1064|     18|  if (head == w) {                    // we removed the head
  ------------------
  |  Branch (1064:7): [True: 18, False: 0]
  ------------------
 1065|     18|    head = (pw == w) ? nullptr : pw;  // either emptied list, or pw is new head
  ------------------
  |  Branch (1065:12): [True: 18, False: 0]
  ------------------
 1066|     18|  } else if (pw != head && MuEquivalentWaiter(pw, pw->next)) {
  ------------------
  |  Branch (1066:14): [True: 0, False: 0]
  |  Branch (1066:28): [True: 0, False: 0]
  ------------------
 1067|       |    // pw can skip to its new successor
 1068|      0|    if (pw->next->skip !=
  ------------------
  |  Branch (1068:9): [True: 0, False: 0]
  ------------------
 1069|      0|        nullptr) {  // either skip to its successors skip target
 1070|      0|      pw->skip = pw->next->skip;
 1071|      0|    } else {  // or to pw's successor
 1072|      0|      pw->skip = pw->next;
 1073|      0|    }
 1074|      0|  }
 1075|     18|  return head;
 1076|     18|}
mutex.cc:_ZN4absl12lts_20260107L22DebugOnlyDeadlockCheckEPNS0_5MutexE:
 1472|   842k|static inline GraphId DebugOnlyDeadlockCheck(Mutex* mu) {
 1473|   842k|  if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1473:7): [Folded, False: 842k]
  |  Branch (1473:21): [True: 0, False: 0]
  ------------------
 1474|      0|                        OnDeadlockCycle::kIgnore) {
 1475|      0|    return DeadlockCheck(mu);
 1476|   842k|  } else {
 1477|   842k|    return InvalidGraphId();
 1478|   842k|  }
 1479|   842k|}
mutex.cc:_ZN4absl12lts_20260107L22TryAcquireWithSpinningEPNSt3__16atomicIlEE:
 1514|      8|static bool TryAcquireWithSpinning(std::atomic<intptr_t>* mu) {
 1515|      8|  int c = globals.spinloop_iterations.load(std::memory_order_relaxed);
 1516|  7.31k|  do {  // do/while somewhat faster on AMD
 1517|  7.31k|    intptr_t v = mu->load(std::memory_order_relaxed);
 1518|  7.31k|    if ((v & (kMuReader | kMuEvent)) != 0) {
  ------------------
  |  Branch (1518:9): [True: 0, False: 7.31k]
  ------------------
 1519|      0|      return false;                       // a reader or tracing -> give up
 1520|  7.31k|    } else if (((v & kMuWriter) == 0) &&  // no holder -> try to acquire
  ------------------
  |  Branch (1520:16): [True: 3, False: 7.31k]
  ------------------
 1521|      3|               mu->compare_exchange_strong(v, kMuWriter | v,
  ------------------
  |  Branch (1521:16): [True: 3, False: 0]
  ------------------
 1522|      3|                                           std::memory_order_acquire,
 1523|      3|                                           std::memory_order_relaxed)) {
 1524|      3|      return true;
 1525|      3|    }
 1526|  7.31k|  } while (--c > 0);
  ------------------
  |  Branch (1526:12): [True: 7.30k, False: 5]
  ------------------
 1527|      5|  return false;
 1528|      8|}
mutex.cc:_ZN4absl12lts_20260107L18DebugOnlyLockEnterEPNS0_5MutexENS0_24synchronization_internal7GraphIdE:
 1305|   842k|static inline void DebugOnlyLockEnter(Mutex* mu, GraphId id) {
 1306|   842k|  if (kDebugMode) {
  ------------------
  |  Branch (1306:7): [Folded, False: 842k]
  ------------------
 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|   842k|}
mutex.cc:_ZN4absl12lts_20260107L27Synch_GetPerThreadAnnotatedEPNS0_5MutexE:
  560|     23|static PerThreadSynch* Synch_GetPerThreadAnnotated(Mutex* mu) {
  561|     23|  if (mu) {
  ------------------
  |  Branch (561:7): [True: 23, False: 0]
  ------------------
  562|     23|    ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
  563|     23|  }
  564|     23|  PerThreadSynch* w = Synch_GetPerThread();
  565|     23|  if (mu) {
  ------------------
  |  Branch (565:7): [True: 23, False: 0]
  ------------------
  566|     23|    ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
  567|     23|  }
  568|     23|  return w;
  569|     23|}
mutex.cc:_ZN4absl12lts_20260107L18Synch_GetPerThreadEv:
  555|     23|static PerThreadSynch* Synch_GetPerThread() {
  556|     23|  ThreadIdentity* identity = GetOrCreateCurrentThreadIdentity();
  557|     23|  return &identity->per_thread_synch;
  558|     23|}
_ZN4absl12lts_2026010715SynchWaitParamsC2EPKNS0_6MuHowSEPKNS0_9ConditionENS0_24synchronization_internal13KernelTimeoutEPNS0_5MutexEPNS0_13base_internal14PerThreadSynchEPNSt3__16atomicIlEE:
  499|     23|      : how(how_arg),
  500|     23|        cond(cond_arg),
  501|     23|        timeout(timeout_arg),
  502|     23|        cvmu(cvmu_arg),
  503|     23|        thread(thread_arg),
  504|     23|        cv_word(cv_word_arg),
  505|     23|        contention_start_cycles(CycleClock::Now()),
  506|     23|        should_submit_contention_data(false) {}
mutex.cc:_ZN4absl12lts_20260107L18DebugOnlyLockLeaveEPNS0_5MutexE:
 1315|   842k|static inline void DebugOnlyLockLeave(Mutex* mu) {
 1316|   842k|  if (kDebugMode) {
  ------------------
  |  Branch (1316:7): [Folded, False: 842k]
  ------------------
 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|   842k|}
mutex.cc:_ZN4absl12lts_20260107L16ExactlyOneReaderEl:
 1768|   619k|static bool ExactlyOneReader(intptr_t v) {
 1769|   619k|  assert((v & (kMuWriter | kMuReader)) == kMuReader);
 1770|   619k|  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|   619k|  constexpr intptr_t kMuMultipleWaitersMask = kMuHigh ^ kMuOne;
 1775|   619k|  return (v & kMuMultipleWaitersMask) == 0;
 1776|   619k|}
mutex.cc:_ZN4absl12lts_20260107L22EvalConditionAnnotatedEPKNS0_9ConditionEPNS0_5MutexEbbb:
 1855|     18|                                          bool read_lock) {
 1856|       |  // Delicate annotation dance.
 1857|       |  // We are currently inside of read/write lock/unlock operation.
 1858|       |  // All memory accesses are ignored inside of mutex operations + for unlock
 1859|       |  // operation tsan considers that we've already released the mutex.
 1860|     18|  bool res = false;
 1861|       |#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
 1862|       |  const uint32_t flags = read_lock ? __tsan_mutex_read_lock : 0;
 1863|       |  const uint32_t tryflags = flags | (trylock ? __tsan_mutex_try_lock : 0);
 1864|       |#endif
 1865|     18|  if (locking) {
  ------------------
  |  Branch (1865:7): [True: 18, False: 0]
  ------------------
 1866|       |    // For lock we pretend that we have finished the operation,
 1867|       |    // evaluate the predicate, then unlock the mutex and start locking it again
 1868|       |    // to match the annotation at the end of outer lock operation.
 1869|       |    // Note: we can't simply do POST_LOCK, Eval, PRE_LOCK, because then tsan
 1870|       |    // will think the lock acquisition is recursive which will trigger
 1871|       |    // deadlock detector.
 1872|     18|    ABSL_TSAN_MUTEX_POST_LOCK(mu, tryflags, 0);
 1873|     18|    res = cond->Eval();
 1874|       |    // There is no "try" version of Unlock, so use flags instead of tryflags.
 1875|     18|    ABSL_TSAN_MUTEX_PRE_UNLOCK(mu, flags);
 1876|     18|    ABSL_TSAN_MUTEX_POST_UNLOCK(mu, flags);
 1877|     18|    ABSL_TSAN_MUTEX_PRE_LOCK(mu, tryflags);
 1878|     18|  } else {
 1879|       |    // Similarly, for unlock we pretend that we have unlocked the mutex,
 1880|       |    // lock the mutex, evaluate the predicate, and start unlocking it again
 1881|       |    // to match the annotation at the end of outer unlock operation.
 1882|      0|    ABSL_TSAN_MUTEX_POST_UNLOCK(mu, flags);
 1883|      0|    ABSL_TSAN_MUTEX_PRE_LOCK(mu, flags);
 1884|      0|    ABSL_TSAN_MUTEX_POST_LOCK(mu, flags, 0);
 1885|      0|    res = cond->Eval();
 1886|      0|    ABSL_TSAN_MUTEX_PRE_UNLOCK(mu, flags);
 1887|      0|  }
 1888|       |  // Prevent unused param warnings in non-TSAN builds.
 1889|     18|  static_cast<void>(mu);
 1890|     18|  static_cast<void>(trylock);
 1891|     18|  static_cast<void>(read_lock);
 1892|     18|  return res;
 1893|     18|}
mutex.cc:_ZN4absl12lts_20260107L24ClearDesignatedWakerMaskEi:
 1802|     23|static intptr_t ClearDesignatedWakerMask(int flag) {
 1803|     23|  assert(flag >= 0);
 1804|     23|  assert(flag <= 1);
 1805|     23|  switch (flag) {
  ------------------
  |  Branch (1805:11): [True: 23, False: 0]
  ------------------
 1806|      5|    case 0:  // not blocked
  ------------------
  |  Branch (1806:5): [True: 5, False: 18]
  ------------------
 1807|      5|      return ~static_cast<intptr_t>(0);
 1808|     18|    case 1:  // blocked; turn off the designated waker bit
  ------------------
  |  Branch (1808:5): [True: 18, False: 5]
  ------------------
 1809|     18|      return ~static_cast<intptr_t>(kMuDesig);
 1810|     23|  }
 1811|      0|  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]
  |  |  ------------------
  ------------------
 1812|      0|}
mutex.cc:_ZN4absl12lts_20260107L23CheckForMutexCorruptionElPKc:
 1972|  10.4k|static void CheckForMutexCorruption(intptr_t v, const char* label) {
 1973|       |  // Test for either of two situations that should not occur in v:
 1974|       |  //   kMuWriter and kMuReader
 1975|       |  //   kMuWrWait and !kMuWait
 1976|  10.4k|  const uintptr_t w = static_cast<uintptr_t>(v ^ kMuWait);
 1977|       |  // By flipping that bit, we can now test for:
 1978|       |  //   kMuWriter and kMuReader in w
 1979|       |  //   kMuWrWait and kMuWait in w
 1980|       |  // We've chosen these two pairs of values to be so that they will overlap,
 1981|       |  // respectively, when the word is left shifted by three.  This allows us to
 1982|       |  // save a branch in the common (correct) case of them not being coincident.
 1983|  10.4k|  static_assert(kMuReader << 3 == kMuWriter, "must match");
 1984|  10.4k|  static_assert(kMuWait << 3 == kMuWrWait, "must match");
 1985|  10.4k|  if (ABSL_PREDICT_TRUE((w & (w << 3) & (kMuWriter | kMuWrWait)) == 0)) return;
  ------------------
  |  |  190|  10.4k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 10.4k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 10.4k]
  |  |  |  Branch (190:57): [True: 10.4k, False: 0]
  |  |  ------------------
  ------------------
 1986|      0|  RAW_CHECK_FMT((v & (kMuWriter | kMuReader)) != (kMuWriter | kMuReader),
  ------------------
  |  | 1966|      0|  do {                                                             \
  |  | 1967|      0|    if (ABSL_PREDICT_FALSE(!(cond))) {                             \
  |  |  ------------------
  |  |  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1968|      0|      ABSL_RAW_LOG(FATAL, "Check " #cond " failed: " __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1969|      0|    }                                                              \
  |  | 1970|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1970:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1987|      0|                "%s: Mutex corrupt: both reader and writer lock held: %p",
 1988|      0|                label, reinterpret_cast<void*>(v));
 1989|      0|  RAW_CHECK_FMT((v & (kMuWait | kMuWrWait)) != kMuWrWait,
  ------------------
  |  | 1966|      0|  do {                                                             \
  |  | 1967|      0|    if (ABSL_PREDICT_FALSE(!(cond))) {                             \
  |  |  ------------------
  |  |  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1968|      0|      ABSL_RAW_LOG(FATAL, "Check " #cond " failed: " __VA_ARGS__); \
  |  |  ------------------
  |  |  |  |   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]
  |  |  |  |  ------------------
  |  |  ------------------
  |  | 1969|      0|    }                                                              \
  |  | 1970|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (1970:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1990|      0|                "%s: Mutex corrupt: waiting writer with no waiters: %p", label,
 1991|      0|                reinterpret_cast<void*>(v));
 1992|      0|  assert(false);
 1993|      0|}
mutex.cc:_ZN4absl12lts_20260107L7EnqueueEPNS0_13base_internal14PerThreadSynchEPNS0_15SynchWaitParamsEli:
  925|     18|                               intptr_t mu, int flags) {
  926|       |  // If we have been given a cv_word, call CondVarEnqueue() and return
  927|       |  // the previous head of the Mutex waiter queue.
  928|     18|  if (waitp->cv_word != nullptr) {
  ------------------
  |  Branch (928:7): [True: 0, False: 18]
  ------------------
  929|      0|    CondVarEnqueue(waitp);
  930|      0|    return head;
  931|      0|  }
  932|       |
  933|     18|  PerThreadSynch* s = waitp->thread;
  934|     18|  ABSL_RAW_CHECK(
  ------------------
  |  |   60|     18|  do {                                                                 \
  |  |   61|     18|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     36|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 18]
  |  |  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  |  |  Branch (189:59): [True: 18, False: 0]
  |  |  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  |  |  |  Branch (189:59): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
  935|     18|      s->waitp == nullptr ||    // normal case
  936|     18|          s->waitp == waitp ||  // Fer()---transfer from condition variable
  937|     18|          s->suppress_fatal_errors,
  938|     18|      "detected illegal recursion into Mutex code");
  939|     18|  s->waitp = waitp;
  940|     18|  s->skip = nullptr;   // maintain skip invariant (see above)
  941|     18|  s->may_skip = true;  // always true on entering queue
  942|     18|  s->wake = false;     // not being woken
  943|     18|  s->cond_waiter = ((flags & kMuIsCond) != 0);
  944|     18|#ifdef ABSL_HAVE_PTHREAD_GETSCHEDPARAM
  945|     18|  if ((flags & kMuIsFer) == 0) {
  ------------------
  |  Branch (945:7): [True: 18, False: 0]
  ------------------
  946|     18|    assert(s == Synch_GetPerThread());
  947|     18|    int64_t now_cycles = CycleClock::Now();
  948|     18|    if (s->next_priority_read_cycles < now_cycles) {
  ------------------
  |  Branch (948:9): [True: 18, False: 0]
  ------------------
  949|       |      // Every so often, update our idea of the thread's priority.
  950|       |      // pthread_getschedparam() is 5% of the block/wakeup time;
  951|       |      // CycleClock::Now() is 0.5%.
  952|     18|      int policy;
  953|     18|      struct sched_param param;
  954|     18|      const int err = pthread_getschedparam(pthread_self(), &policy, &param);
  955|     18|      if (err != 0) {
  ------------------
  |  Branch (955:11): [True: 0, False: 18]
  ------------------
  956|      0|        ABSL_RAW_LOG(ERROR, "pthread_getschedparam failed: %d", err);
  ------------------
  |  |   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,         \
  |  |  ------------------
  |  |  |  |  109|      0|#define ABSL_RAW_LOG_INTERNAL_ERROR ::absl::LogSeverity::kError
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  957|     18|      } else {
  958|     18|        s->priority = param.sched_priority;
  959|     18|        s->next_priority_read_cycles =
  960|     18|            now_cycles + static_cast<int64_t>(CycleClock::Frequency());
  961|     18|      }
  962|     18|    }
  963|     18|  }
  964|     18|#endif
  965|     18|  if (head == nullptr) {         // s is the only waiter
  ------------------
  |  Branch (965:7): [True: 18, False: 0]
  ------------------
  966|     18|    s->next = s;                 // it's the only entry in the cycle
  967|     18|    s->readers = mu;             // reader count is from mu word
  968|     18|    s->maybe_unlocking = false;  // no one is searching an empty list
  969|     18|    head = s;                    // s is new head
  970|     18|  } else {
  971|      0|    PerThreadSynch* enqueue_after = nullptr;  // we'll put s after this element
  972|      0|#ifdef ABSL_HAVE_PTHREAD_GETSCHEDPARAM
  973|      0|    if (s->priority > head->priority) {  // s's priority is above head's
  ------------------
  |  Branch (973:9): [True: 0, False: 0]
  ------------------
  974|       |      // try to put s in priority-fifo order, or failing that at the front.
  975|      0|      if (!head->maybe_unlocking) {
  ------------------
  |  Branch (975:11): [True: 0, False: 0]
  ------------------
  976|       |        // No unlocker can be scanning the queue, so we can insert into the
  977|       |        // middle of the queue.
  978|       |        //
  979|       |        // Within a skip chain, all waiters have the same priority, so we can
  980|       |        // skip forward through the chains until we find one with a lower
  981|       |        // priority than the waiter to be enqueued.
  982|      0|        PerThreadSynch* advance_to = head;  // next value of enqueue_after
  983|      0|        do {
  984|      0|          enqueue_after = advance_to;
  985|       |          // (side-effect: optimizes skip chain)
  986|      0|          advance_to = Skip(enqueue_after->next);
  987|      0|        } while (s->priority <= advance_to->priority);
  ------------------
  |  Branch (987:18): [True: 0, False: 0]
  ------------------
  988|       |        // termination guaranteed because s->priority > head->priority
  989|       |        // and head is the end of a skip chain
  990|      0|      } else if (waitp->how == kExclusive && waitp->cond == nullptr) {
  ------------------
  |  Branch (990:18): [True: 0, False: 0]
  |  Branch (990:46): [True: 0, False: 0]
  ------------------
  991|       |        // An unlocker could be scanning the queue, but we know it will recheck
  992|       |        // the queue front for writers that have no condition, which is what s
  993|       |        // is, so an insert at front is safe.
  994|      0|        enqueue_after = head;  // add after head, at front
  995|      0|      }
  996|      0|    }
  997|      0|#endif
  998|      0|    if (enqueue_after != nullptr) {
  ------------------
  |  Branch (998:9): [True: 0, False: 0]
  ------------------
  999|      0|      s->next = enqueue_after->next;
 1000|      0|      enqueue_after->next = s;
 1001|       |
 1002|       |      // enqueue_after can be: head, Skip(...), or cur.
 1003|       |      // The first two imply enqueue_after->skip == nullptr, and
 1004|       |      // the last is used only if MuEquivalentWaiter(s, cur).
 1005|       |      // We require this because clearing enqueue_after->skip
 1006|       |      // is impossible; enqueue_after's predecessors might also
 1007|       |      // incorrectly skip over s if we were to allow other
 1008|       |      // insertion points.
 1009|      0|      ABSL_RAW_CHECK(enqueue_after->skip == nullptr ||
  ------------------
  |  |   60|      0|  do {                                                                 \
  |  |   61|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  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]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1010|      0|                         MuEquivalentWaiter(enqueue_after, s),
 1011|      0|                     "Mutex Enqueue failure");
 1012|       |
 1013|      0|      if (enqueue_after != head && enqueue_after->may_skip &&
  ------------------
  |  Branch (1013:11): [True: 0, False: 0]
  |  Branch (1013:36): [True: 0, False: 0]
  ------------------
 1014|      0|          MuEquivalentWaiter(enqueue_after, enqueue_after->next)) {
  ------------------
  |  Branch (1014:11): [True: 0, False: 0]
  ------------------
 1015|       |        // enqueue_after can skip to its new successor, s
 1016|      0|        enqueue_after->skip = enqueue_after->next;
 1017|      0|      }
 1018|      0|      if (MuEquivalentWaiter(s, s->next)) {  // s->may_skip is known to be true
  ------------------
  |  Branch (1018:11): [True: 0, False: 0]
  ------------------
 1019|      0|        s->skip = s->next;                   // s may skip to its successor
 1020|      0|      }
 1021|      0|    } else if ((flags & kMuHasBlocked) &&
  ------------------
  |  Branch (1021:16): [True: 0, False: 0]
  ------------------
 1022|      0|               (s->priority >= head->next->priority) &&
  ------------------
  |  Branch (1022:16): [True: 0, False: 0]
  ------------------
 1023|      0|               (!head->maybe_unlocking ||
  ------------------
  |  Branch (1023:17): [True: 0, False: 0]
  ------------------
 1024|      0|                (waitp->how == kExclusive &&
  ------------------
  |  Branch (1024:18): [True: 0, False: 0]
  ------------------
 1025|      0|                 Condition::GuaranteedEqual(waitp->cond, nullptr)))) {
  ------------------
  |  Branch (1025:18): [True: 0, False: 0]
  ------------------
 1026|       |      // This thread has already waited, then was woken, then failed to acquire
 1027|       |      // the mutex and now tries to requeue. Try to requeue it at head,
 1028|       |      // otherwise it can suffer bad latency (wait whole queue several times).
 1029|       |      // However, we need to be conservative. First, we need to ensure that we
 1030|       |      // respect priorities. Then, we need to be careful to not break wait
 1031|       |      // queue invariants: we require either that unlocker is not scanning
 1032|       |      // the queue or that the current thread is a writer with no condition
 1033|       |      // (unlocker will recheck the queue for such waiters).
 1034|      0|      s->next = head->next;
 1035|      0|      head->next = s;
 1036|      0|      if (MuEquivalentWaiter(s, s->next)) {  // s->may_skip is known to be true
  ------------------
  |  Branch (1036:11): [True: 0, False: 0]
  ------------------
 1037|      0|        s->skip = s->next;                   // s may skip to its successor
 1038|      0|      }
 1039|      0|    } else {  // enqueue not done any other way, so
 1040|       |              // we're inserting s at the back
 1041|       |      // s will become new head; copy data from head into it
 1042|      0|      s->next = head->next;  // add s after head
 1043|      0|      head->next = s;
 1044|      0|      s->readers = head->readers;  // reader count is from previous head
 1045|      0|      s->maybe_unlocking = head->maybe_unlocking;  // same for unlock hint
 1046|      0|      if (head->may_skip && MuEquivalentWaiter(head, s)) {
  ------------------
  |  Branch (1046:11): [True: 0, False: 0]
  |  Branch (1046:29): [True: 0, False: 0]
  ------------------
 1047|       |        // head now has successor; may skip
 1048|      0|        head->skip = s;
 1049|      0|      }
 1050|      0|      head = s;  // s is new head
 1051|      0|    }
 1052|      0|  }
 1053|     18|  s->state.store(PerThreadSynch::kQueued, std::memory_order_relaxed);
 1054|     18|  return head;
 1055|     18|}
mutex.cc:_ZN4absl12lts_20260107L24IgnoreWaitingWritersMaskEi:
 1816|  10.4k|static intptr_t IgnoreWaitingWritersMask(int flag) {
 1817|  10.4k|  assert(flag >= 0);
 1818|  10.4k|  assert(flag <= 1);
 1819|  10.4k|  switch (flag) {
  ------------------
  |  Branch (1819:11): [True: 10.4k, False: 0]
  ------------------
 1820|  10.4k|    case 0:  // not blocked
  ------------------
  |  Branch (1820:5): [True: 10.4k, False: 0]
  ------------------
 1821|  10.4k|      return ~static_cast<intptr_t>(0);
 1822|      0|    case 1:  // blocked; pretend there are no waiting writers
  ------------------
  |  Branch (1822:5): [True: 0, False: 10.4k]
  ------------------
 1823|      0|      return ~static_cast<intptr_t>(kMuWrWait);
 1824|  10.4k|  }
 1825|      0|  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]
  |  |  ------------------
  ------------------
 1826|      0|}
mutex.cc:_ZN4absl12lts_20260107L20EvalConditionIgnoredEPNS0_5MutexEPKNS0_9ConditionE:
 1903|     18|static inline bool EvalConditionIgnored(Mutex* mu, const Condition* cond) {
 1904|       |  // Memory accesses are already ignored inside of lock/unlock operations,
 1905|       |  // but synchronization operations are also ignored. When we evaluate the
 1906|       |  // predicate we must ignore only memory accesses but not synchronization,
 1907|       |  // because missed synchronization can lead to false reports later.
 1908|       |  // So we "divert" (which un-ignores both memory accesses and synchronization)
 1909|       |  // and then separately turn on ignores of memory accesses.
 1910|     18|  ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
 1911|     18|  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
  ------------------
  |  |  383|     18|  do {                                                \
  |  |  384|     18|    ABSL_ANNOTATE_IGNORE_READS_BEGIN();               \
  |  |  ------------------
  |  |  |  |  317|     18|  ABSL_INTERNAL_GLOBAL_SCOPED(                                      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|     18|#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
  |  |  |  |  ------------------
  |  |  |  |  318|     18|      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin)) \
  |  |  |  |  319|     18|  ()
  |  |  ------------------
  |  |  385|     18|    ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();              \
  |  |  386|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (386:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
 1912|     18|  bool res = cond->Eval();
 1913|     18|  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END();
  ------------------
  |  |  390|     18|  do {                                              \
  |  |  391|     18|    ABSL_ANNOTATE_IGNORE_WRITES_END();              \
  |  |  392|     18|    ABSL_ANNOTATE_IGNORE_READS_END();               \
  |  |  ------------------
  |  |  |  |  322|     18|  ABSL_INTERNAL_GLOBAL_SCOPED(                                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|     18|#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
  |  |  |  |  ------------------
  |  |  |  |  323|     18|      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \
  |  |  |  |  324|     18|  ()
  |  |  ------------------
  |  |  393|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (393:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
 1914|     18|  ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
 1915|     18|  static_cast<void>(mu);  // Prevent unused param warning in non-TSAN builds.
 1916|     18|  return res;
 1917|     18|}
mutex.cc:_ZN4absl12lts_20260107L18DequeueAllWakeableEPNS0_13base_internal14PerThreadSynchES3_PS3_:
 1086|     18|                                          PerThreadSynch** wake_tail) {
 1087|     18|  PerThreadSynch* orig_h = head;
 1088|     18|  PerThreadSynch* w = pw->next;
 1089|     18|  bool skipped = false;
 1090|     18|  do {
 1091|     18|    if (w->wake) {  // remove this element
  ------------------
  |  Branch (1091:9): [True: 18, False: 0]
  ------------------
 1092|     18|      ABSL_RAW_CHECK(pw->skip == nullptr, "bad skip in DequeueAllWakeable");
  ------------------
  |  |   60|     18|  do {                                                                 \
  |  |   61|     18|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|     18|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 18]
  |  |  |  |  |  Branch (189:49): [Folded, False: 18]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 18]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|     18|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 18]
  |  |  ------------------
  ------------------
 1093|       |      // we're removing pw's successor so either pw->skip is zero or we should
 1094|       |      // already have removed pw since if pw->skip!=null, pw has the same
 1095|       |      // condition as w.
 1096|     18|      head = Dequeue(head, pw);
 1097|     18|      w->next = *wake_tail;               // keep list terminated
 1098|     18|      *wake_tail = w;                     // add w to wake_list;
 1099|     18|      wake_tail = &w->next;               // next addition to end
 1100|     18|      if (w->waitp->how == kExclusive) {  // wake at most 1 writer
  ------------------
  |  Branch (1100:11): [True: 18, False: 0]
  ------------------
 1101|     18|        break;
 1102|     18|      }
 1103|     18|    } else {         // not waking this one; skip
 1104|      0|      pw = Skip(w);  // skip as much as possible
 1105|      0|      skipped = true;
 1106|      0|    }
 1107|      0|    w = pw->next;
 1108|       |    // We want to stop processing after we've considered the original head,
 1109|       |    // orig_h.  We can't test for w==orig_h in the loop because w may skip over
 1110|       |    // it; we are guaranteed only that w's predecessor will not skip over
 1111|       |    // orig_h.  When we've considered orig_h, either we've processed it and
 1112|       |    // removed it (so orig_h != head), or we considered it and skipped it (so
 1113|       |    // skipped==true && pw == head because skipping from head always skips by
 1114|       |    // just one, leaving pw pointing at head).  So we want to
 1115|       |    // continue the loop with the negation of that expression.
 1116|      0|  } while (orig_h == head && (pw != head || !skipped));
  ------------------
  |  Branch (1116:12): [True: 0, False: 0]
  |  Branch (1116:31): [True: 0, False: 0]
  |  Branch (1116:45): [True: 0, False: 0]
  ------------------
 1117|     18|  return head;
 1118|     18|}

_ZN4absl12lts_2026010715ReaderMutexLockC2ERNS0_5MutexE:
  659|   619k|      : mu_(mu) {
  660|   619k|    mu.lock_shared();
  661|   619k|  }
_ZN4absl12lts_2026010715ReaderMutexLockD2Ev:
  685|   619k|  ~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_202601073NowEv:
   39|   619k|Time Now() {
   40|       |  // TODO(bww): Get a timespec instead so we don't have to divide.
   41|   619k|  int64_t n = absl::GetCurrentTimeNanos();
   42|   619k|  if (n >= 0) {
  ------------------
  |  Branch (42:7): [True: 619k, False: 0]
  ------------------
   43|   619k|    return time_internal::FromUnixDuration(
   44|   619k|        time_internal::MakeDuration(n / 1000000000, n % 1000000000 * 4));
   45|   619k|  }
   46|      0|  return time_internal::FromUnixDuration(absl::Nanoseconds(n));
   47|   619k|}
_ZN4absl12lts_2026010719GetCurrentTimeNanosEv:
   77|   619k|int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); }
  ------------------
  |  |   71|   619k|  ::absl::time_internal::GetCurrentTimeNanosFromSystem()
  ------------------
AbslInternalSleepFor_lts_20260107:
  595|     39|    absl::Duration duration) {
  596|     78|  while (duration > absl::ZeroDuration()) {
  ------------------
  |  Branch (596:10): [True: 39, False: 39]
  ------------------
  597|     39|    absl::Duration to_sleep = std::min(duration, absl::MaxSleep());
  598|     39|    absl::SleepOnce(to_sleep);
  599|     39|    duration -= to_sleep;
  600|     39|  }
  601|     39|}
clock.cc:_ZN4absl12lts_2026010712_GLOBAL__N_18MaxSleepEv:
  565|     39|constexpr absl::Duration MaxSleep() {
  566|       |#ifdef _WIN32
  567|       |  // Windows Sleep() takes unsigned long argument in milliseconds.
  568|       |  return absl::Milliseconds(
  569|       |      std::numeric_limits<unsigned long>::max());  // NOLINT(runtime/int)
  570|       |#else
  571|     39|  return absl::Seconds(std::numeric_limits<time_t>::max());
  572|     39|#endif
  573|     39|}
clock.cc:_ZN4absl12lts_2026010712_GLOBAL__N_19SleepOnceENS0_8DurationE:
  577|     39|void SleepOnce(absl::Duration to_sleep) {
  578|       |#ifdef _WIN32
  579|       |  Sleep(static_cast<DWORD>(to_sleep / absl::Milliseconds(1)));
  580|       |#else
  581|     39|  struct timespec sleep_time = absl::ToTimespec(to_sleep);
  582|     39|  while (nanosleep(&sleep_time, &sleep_time) != 0 && errno == EINTR) {
  ------------------
  |  Branch (582:10): [True: 0, False: 39]
  |  Branch (582:54): [True: 0, False: 0]
  ------------------
  583|       |    // Ignore signals and wait for the full interval to elapse.
  584|      0|  }
  585|     39|#endif
  586|     39|}

_ZN4absl12lts_202601078SleepForENS0_8DurationE:
   74|     39|inline void absl::SleepFor(absl::Duration duration) {
   75|     39|  ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(duration);
  ------------------
  |  |  187|     39|  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
  |  |  ------------------
  |  |  |  |  185|     39|  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
  |  |  |  |  ------------------
  |  |  |  |  |  |  183|     39|#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   76|     39|}

_ZN4absl12lts_202601078DurationmIES1_:
  436|     39|Duration& Duration::operator-=(Duration rhs) {
  437|     39|  if (time_internal::IsInfiniteDuration(*this)) return *this;
  ------------------
  |  Branch (437:7): [True: 0, False: 39]
  ------------------
  438|     39|  if (time_internal::IsInfiniteDuration(rhs)) {
  ------------------
  |  Branch (438:7): [True: 0, False: 39]
  ------------------
  439|      0|    return *this = rhs.rep_hi_.Get() >= 0 ? -InfiniteDuration()
  ------------------
  |  Branch (439:20): [True: 0, False: 0]
  ------------------
  440|      0|                                          : InfiniteDuration();
  441|      0|  }
  442|     39|  const int64_t orig_rep_hi = rep_hi_.Get();
  443|     39|  rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_.Get()) -
  444|     39|                           EncodeTwosComp(rhs.rep_hi_.Get()));
  445|     39|  if (rep_lo_ < rhs.rep_lo_) {
  ------------------
  |  Branch (445:7): [True: 0, False: 39]
  ------------------
  446|      0|    rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_.Get()) - 1);
  447|      0|    rep_lo_ += kTicksPerSecond;
  448|      0|  }
  449|     39|  rep_lo_ -= rhs.rep_lo_;
  450|     39|  if (rhs.rep_hi_.Get() < 0 ? rep_hi_.Get() < orig_rep_hi
  ------------------
  |  Branch (450:7): [True: 0, False: 39]
  |  Branch (450:7): [True: 0, False: 39]
  ------------------
  451|     39|                            : rep_hi_.Get() > orig_rep_hi) {
  452|      0|    return *this = rhs.rep_hi_.Get() >= 0 ? -InfiniteDuration()
  ------------------
  |  Branch (452:20): [True: 0, False: 0]
  ------------------
  453|      0|                                          : InfiniteDuration();
  454|      0|  }
  455|     39|  return *this;
  456|     39|}
_ZN4absl12lts_2026010710ToTimespecENS0_8DurationE:
  569|     39|timespec ToTimespec(Duration d) {
  570|     39|  timespec ts;
  571|     39|  if (!time_internal::IsInfiniteDuration(d)) {
  ------------------
  |  Branch (571:7): [True: 39, False: 0]
  ------------------
  572|     39|    int64_t rep_hi = time_internal::GetRepHi(d);
  573|     39|    uint32_t rep_lo = time_internal::GetRepLo(d);
  574|     39|    if (rep_hi < 0) {
  ------------------
  |  Branch (574:9): [True: 0, False: 39]
  ------------------
  575|       |      // Tweak the fields so that unsigned division of rep_lo
  576|       |      // maps to truncation (towards zero) for the timespec.
  577|      0|      rep_lo += kTicksPerNanosecond - 1;
  578|      0|      if (rep_lo >= kTicksPerSecond) {
  ------------------
  |  Branch (578:11): [True: 0, False: 0]
  ------------------
  579|      0|        rep_hi += 1;
  580|      0|        rep_lo -= kTicksPerSecond;
  581|      0|      }
  582|      0|    }
  583|     39|    ts.tv_sec = static_cast<decltype(ts.tv_sec)>(rep_hi);
  584|     39|    if (ts.tv_sec == rep_hi) {  // no time_t narrowing
  ------------------
  |  Branch (584:9): [True: 39, False: 0]
  ------------------
  585|     39|      ts.tv_nsec = rep_lo / kTicksPerNanosecond;
  586|     39|      return ts;
  587|     39|    }
  588|     39|  }
  589|      0|  if (d >= ZeroDuration()) {
  ------------------
  |  Branch (589:7): [True: 0, False: 0]
  ------------------
  590|      0|    ts.tv_sec = std::numeric_limits<time_t>::max();
  591|      0|    ts.tv_nsec = 1000 * 1000 * 1000 - 1;
  592|      0|  } else {
  593|      0|    ts.tv_sec = std::numeric_limits<time_t>::min();
  594|      0|    ts.tv_nsec = 0;
  595|      0|  }
  596|      0|  return ts;
  597|     39|}
duration.cc:_ZN4absl12lts_2026010712_GLOBAL__N_114DecodeTwosCompEm:
  187|     39|inline int64_t DecodeTwosComp(uint64_t v) { return absl::bit_cast<int64_t>(v); }
duration.cc:_ZN4absl12lts_2026010712_GLOBAL__N_114EncodeTwosCompEl:
  184|     78|inline uint64_t EncodeTwosComp(int64_t v) {
  185|     78|  return absl::bit_cast<uint64_t>(v);
  186|     78|}

clock.cc:_ZN4absl12lts_2026010713time_internalL29GetCurrentTimeNanosFromSystemEv:
   13|   619k|static int64_t GetCurrentTimeNanosFromSystem() {
   14|   619k|  const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
   15|   619k|  struct timespec ts;
   16|   619k|  ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0,
  ------------------
  |  |   60|   619k|  do {                                                                 \
  |  |   61|   619k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  189|   619k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (189:31): [True: 0, False: 619k]
  |  |  |  |  |  Branch (189:49): [Folded, False: 619k]
  |  |  |  |  |  Branch (189:58): [True: 0, False: 619k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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|   619k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 619k]
  |  |  ------------------
  ------------------
   17|   619k|                 "Failed to read real-time clock.");
   18|   619k|  return (int64_t{ts.tv_sec} * kNanosPerSecond +
   19|   619k|          int64_t{ts.tv_nsec});
   20|   619k|}

_ZN4absl12lts_2026010711ToUnixNanosENS0_4TimeE:
  249|   619k|int64_t ToUnixNanos(Time t) {
  250|   619k|  if (time_internal::GetRepHi(time_internal::ToUnixDuration(t)) >= 0 &&
  ------------------
  |  Branch (250:7): [True: 619k, False: 0]
  ------------------
  251|   619k|      time_internal::GetRepHi(time_internal::ToUnixDuration(t)) >> 33 == 0) {
  ------------------
  |  Branch (251:7): [True: 619k, False: 0]
  ------------------
  252|   619k|    return (time_internal::GetRepHi(time_internal::ToUnixDuration(t)) * 1000 *
  253|   619k|            1000 * 1000) +
  254|   619k|           (time_internal::GetRepLo(time_internal::ToUnixDuration(t)) / 4);
  255|   619k|  }
  256|      0|  return FloorToUnit(time_internal::ToUnixDuration(t), absl::Nanoseconds(1));
  257|   619k|}
_ZN4absl12lts_2026010710ToTimespecENS0_4TimeE:
  302|   619k|timespec ToTimespec(Time t) {
  303|   619k|  timespec ts;
  304|   619k|  absl::Duration d = time_internal::ToUnixDuration(t);
  305|   619k|  if (!time_internal::IsInfiniteDuration(d)) {
  ------------------
  |  Branch (305:7): [True: 619k, False: 0]
  ------------------
  306|   619k|    ts.tv_sec = static_cast<decltype(ts.tv_sec)>(time_internal::GetRepHi(d));
  307|   619k|    if (ts.tv_sec == time_internal::GetRepHi(d)) {  // no time_t narrowing
  ------------------
  |  Branch (307:9): [True: 619k, False: 0]
  ------------------
  308|   619k|      ts.tv_nsec = time_internal::GetRepLo(d) / 4;  // floor
  309|   619k|      return ts;
  310|   619k|    }
  311|   619k|  }
  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|   619k|}
_ZN4absl12lts_202601079ToTimevalENS0_4TimeE:
  322|   619k|timeval ToTimeval(Time t) {
  323|   619k|  timeval tv;
  324|   619k|  timespec ts = absl::ToTimespec(t);
  325|   619k|  tv.tv_sec = static_cast<decltype(tv.tv_sec)>(ts.tv_sec);
  326|   619k|  if (tv.tv_sec != ts.tv_sec) {  // narrowing
  ------------------
  |  Branch (326:7): [True: 0, False: 619k]
  ------------------
  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|   619k|  tv.tv_usec = static_cast<int>(ts.tv_nsec / 1000);  // suseconds_t
  337|   619k|  return tv;
  338|   619k|}

_ZN4absl12lts_202601078DurationC2Ev:
  186|   619k|  constexpr Duration() : rep_hi_(0), rep_lo_(0) {}  // zero-length duration
_ZN4absl12lts_202601078DurationC2Elj:
  248|   619k|  constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
_ZN4absl12lts_202601078Duration5HiRepC2El:
  268|  1.23M|          lo_(0),
  269|  1.23M|          hi_(0)
  270|       |#endif
  271|  1.23M|    {
  272|  1.23M|      *this = value;
  273|  1.23M|    }
_ZNK4absl12lts_202601078Duration5HiRep3GetEv:
  275|  1.24M|    constexpr int64_t Get() const {
  276|  1.24M|      const uint64_t unsigned_value =
  277|  1.24M|          (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.24M|      static_assert(
  285|  1.24M|          (static_cast<int64_t>((std::numeric_limits<uint64_t>::max)()) ==
  286|  1.24M|           int64_t{-1}) &&
  287|  1.24M|              (static_cast<int64_t>(static_cast<uint64_t>(
  288|  1.24M|                                        (std::numeric_limits<int64_t>::max)()) +
  289|  1.24M|                                    1) ==
  290|  1.24M|               (std::numeric_limits<int64_t>::min)()),
  291|  1.24M|          "static_cast<int64_t>(uint64_t) does not have c++20 semantics");
  292|  1.24M|      return static_cast<int64_t>(unsigned_value);
  293|  1.24M|    }
_ZN4absl12lts_202601078Duration5HiRepaSEl:
  295|  1.23M|    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.23M|      const auto unsigned_value = static_cast<uint64_t>(value);
  301|  1.23M|      hi_ = static_cast<uint32_t>(unsigned_value >> 32);
  302|  1.23M|      lo_ = static_cast<uint32_t>(unsigned_value);
  303|  1.23M|      return *this;
  304|  1.23M|    }
_ZN4absl12lts_2026010712MicrosecondsIiTnNSt3__19enable_ifIXoosr3std11is_integralIT_EE5valuesr3std7is_enumIS4_EE5valueEiE4typeELi0EEENS0_8DurationES4_:
  543|      1|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration Microseconds(T n) {
  544|      1|  return time_internal::FromInt64(n, std::micro{});
  545|      1|}
_ZN4absl12lts_202601074TimeC2ENS0_8DurationE:
  878|   619k|  constexpr explicit Time(Duration rep) : rep_(rep) {}
_ZN4absl12lts_2026010713time_internal9FromInt64ILl1000000EEENS0_8DurationElNSt3__15ratioILl1EXT_EEE:
 1672|      1|                                                           std::ratio<1, N>) {
 1673|      1|  static_assert(0 < N && N <= 1000 * 1000 * 1000, "Unsupported ratio");
 1674|       |  // Subsecond ratios cannot overflow.
 1675|      1|  return MakeNormalizedDuration(
 1676|      1|      v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N);
 1677|      1|}
_ZN4absl12lts_2026010713time_internal9FromInt64ILl1EEENS0_8DurationElNSt3__15ratioILl1EXT_EEE:
 1672|     39|                                                           std::ratio<1, N>) {
 1673|     39|  static_assert(0 < N && N <= 1000 * 1000 * 1000, "Unsupported ratio");
 1674|       |  // Subsecond ratios cannot overflow.
 1675|     39|  return MakeNormalizedDuration(
 1676|     39|      v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N);
 1677|     39|}
_ZN4absl12lts_202601077SecondsIlTnNSt3__19enable_ifIXoosr3std11is_integralIT_EE5valuesr3std7is_enumIS4_EE5valueEiE4typeELi0EEENS0_8DurationES4_:
  551|     39|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration Seconds(T n) {
  552|     39|  return time_internal::FromInt64(n, std::ratio<1>{});
  553|     39|}
_ZN4absl12lts_20260107gtENS0_8DurationES1_:
  337|     78|                                                       Duration rhs) {
  338|     78|  return rhs < lhs;
  339|     78|}
_ZN4absl12lts_2026010712ZeroDurationEv:
  438|     78|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ZeroDuration() {
  439|     78|  return Duration();
  440|     78|}
_ZN4absl12lts_2026010713time_internal12MakeDurationElj:
 1598|   619k|                                                              uint32_t lo = 0) {
 1599|   619k|  return Duration(hi, lo);
 1600|   619k|}
_ZN4absl12lts_2026010713time_internal12MakeDurationEll:
 1603|   619k|                                                              int64_t lo) {
 1604|   619k|  return MakeDuration(hi, static_cast<uint32_t>(lo));
 1605|   619k|}
_ZN4absl12lts_2026010713time_internal22MakeNormalizedDurationEll:
 1624|     40|    int64_t sec, int64_t ticks) {
 1625|     40|  return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond)
  ------------------
  |  Branch (1625:10): [True: 0, False: 40]
  ------------------
 1626|     40|                     : MakeDuration(sec, ticks);
 1627|     40|}
_ZN4absl12lts_2026010713time_internal8GetRepHiENS0_8DurationE:
 1630|  1.23M|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr int64_t GetRepHi(Duration d) {
 1631|  1.23M|  return d.rep_hi_.Get();
 1632|  1.23M|}
_ZN4absl12lts_2026010713time_internal8GetRepLoENS0_8DurationE:
 1633|  1.85M|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr uint32_t GetRepLo(Duration d) {
 1634|  1.85M|  return d.rep_lo_;
 1635|  1.85M|}
_ZN4absl12lts_2026010713time_internal18IsInfiniteDurationENS0_8DurationE:
 1638|   619k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool IsInfiniteDuration(Duration d) {
 1639|   619k|  return GetRepLo(d) == ~uint32_t{0};
 1640|   619k|}
_ZN4absl12lts_2026010713time_internal16FromUnixDurationENS0_8DurationE:
 1663|   619k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixDuration(Duration d) {
 1664|   619k|  return Time(d);
 1665|   619k|}
_ZN4absl12lts_2026010713time_internal14ToUnixDurationENS0_4TimeE:
 1666|  1.23M|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ToUnixDuration(Time t) {
 1667|  1.23M|  return t.rep_;
 1668|  1.23M|}
_ZN4absl12lts_20260107ltENS0_8DurationES1_:
 1760|    117|                                                       Duration rhs) {
 1761|    117|  return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
  ------------------
  |  Branch (1761:10): [True: 39, False: 78]
  ------------------
 1762|    117|             ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
 1763|    117|         : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)()
  ------------------
  |  Branch (1763:12): [True: 0, False: 78]
  ------------------
 1764|     78|             ? time_internal::GetRepLo(lhs) + 1 <
 1765|      0|                   time_internal::GetRepLo(rhs) + 1
 1766|     78|             : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs);
 1767|    117|}
_ZN4absl12lts_202601074TimeC2Ev:
  803|   619k|  constexpr Time() = default;

_ZN4absl12lts_2026010713span_internal11GetDataImplIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEDTcldtfp_4dataEERT_c:
   39|  1.49M|    -> decltype(c.data()) {
   40|  1.49M|  return c.data();
   41|  1.49M|}
_ZN4absl12lts_2026010713span_internal7GetDataIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   51|  1.49M|    -> decltype(GetDataImpl(c, 0)) {
   52|  1.49M|  return GetDataImpl(c, 0);
   53|  1.49M|}
_ZN4absl12lts_2026010713span_internal7GetDataINSt3__15arrayIcLm15000EEEEEDTcl11GetDataImplfp_Li0EEERT_:
   51|  1.85M|    -> decltype(GetDataImpl(c, 0)) {
   52|  1.85M|  return GetDataImpl(c, 0);
   53|  1.85M|}
_ZN4absl12lts_2026010713span_internal11GetDataImplINSt3__15arrayIcLm15000EEEEEDTcldtfp_4dataEERT_c:
   39|  1.85M|    -> decltype(c.data()) {
   40|  1.85M|  return c.data();
   41|  1.85M|}
_ZN4absl12lts_2026010713span_internal7GetDataIKNS0_4SpanIcEEEEDTcl11GetDataImplfp_Li0EEERT_:
   51|   619k|    -> decltype(GetDataImpl(c, 0)) {
   52|   619k|  return GetDataImpl(c, 0);
   53|   619k|}
_ZN4absl12lts_2026010713span_internal11GetDataImplIKNS0_4SpanIcEEEEDTcldtfp_4dataEERT_c:
   39|   619k|    -> decltype(c.data()) {
   40|   619k|  return c.data();
   41|   619k|}
_ZN4absl12lts_2026010713span_internal7GetDataINS0_13InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS5_EEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   51|   619k|    -> decltype(GetDataImpl(c, 0)) {
   52|   619k|  return GetDataImpl(c, 0);
   53|   619k|}
_ZN4absl12lts_2026010713span_internal11GetDataImplINS0_13InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS5_EEEEEEDTcldtfp_4dataEERT_c:
   39|   619k|    -> decltype(c.data()) {
   40|   619k|  return c.data();
   41|   619k|}
_ZN4absl12lts_2026010713span_internal7GetDataIKNS0_4SpanIjEEEEDTcl11GetDataImplfp_Li0EEERT_:
   51|      8|    -> decltype(GetDataImpl(c, 0)) {
   52|      8|  return GetDataImpl(c, 0);
   53|      8|}
_ZN4absl12lts_2026010713span_internal11GetDataImplIKNS0_4SpanIjEEEEDTcldtfp_4dataEERT_c:
   39|      8|    -> decltype(c.data()) {
   40|      8|  return c.data();
   41|      8|}
_ZN4absl12lts_2026010713span_internal7GetDataINSt3__16vectorIPNS0_7LogSinkENS3_9allocatorIS6_EEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   51|   619k|    -> decltype(GetDataImpl(c, 0)) {
   52|   619k|  return GetDataImpl(c, 0);
   53|   619k|}
_ZN4absl12lts_2026010713span_internal11GetDataImplINSt3__16vectorIPNS0_7LogSinkENS3_9allocatorIS6_EEEEEEDTcldtfp_4dataEERT_c:
   39|   619k|    -> decltype(c.data()) {
   40|   619k|  return c.data();
   41|   619k|}

_ZNK4absl12lts_202601074SpanIKcE4dataEv:
  318|  7.36M|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202601074SpanIKcE4sizeEv:
  323|  47.5M|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202601074SpanIjE4dataEv:
  318|  2.93k|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202601074SpanIjE5beginEv:
  376|  1.46k|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202601074SpanIjE4sizeEv:
  323|  1.47k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202601074SpanIjE3endEv:
  389|  1.46k|  constexpr iterator end() const noexcept { return data() + size(); }
_ZNK4absl12lts_202601074SpanIKNS0_19str_format_internal13FormatArgImplEE4sizeEv:
  323|  2.51M|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202601074SpanIcE4sizeEv:
  323|  24.6M|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202601074SpanIcE4dataEv:
  318|  24.3M|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202601074SpanIcE7subspanEmm:
  468|  2.06M|  constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
  469|  2.06M|    return (pos <= size())
  ------------------
  |  Branch (469:12): [True: 2.06M, False: 0]
  ------------------
  470|  2.06M|               ? Span(data() + pos, (std::min)(size() - pos, len))
  471|  2.06M|               : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
  472|  2.06M|  }
_ZN4absl12lts_202601074SpanIKcEC2INSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEvS9_TnNS5_9enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKSB_:
  269|  1.49M|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202601074SpanIKcEC2EPS2_m:
  230|  8.34M|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202601074SpanIKcEC2Ev:
  227|  2.39M|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZN4absl12lts_202601074SpanIcEC2Ev:
  227|  1.19M|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZN4absl12lts_202601074SpanIcEC2EPcm:
  230|  5.11M|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202601078MakeSpanITpTnRiJENSt3__15arrayIcLm15000EEEEENS3_9enable_ifIXntsr13span_internal6IsViewIT0_EE5valueEDTclsr4abslE8MakeSpanclsr13span_internalE7GetDatafp_Ecldtfp_4sizeEEEE4typeERS7_:
  762|  1.23M|                                                c.size()))> {
  763|  1.23M|  return MakeSpan(span_internal::GetData(c), c.size());
  764|  1.23M|}
_ZN4absl12lts_202601078MakeSpanITpTnRiJEcEENS0_4SpanIT0_EEPS4_m:
  738|  1.23M|                           size_t size) noexcept {
  739|  1.23M|  return Span<T>(ptr, size);
  740|  1.23M|}
_ZN4absl12lts_202601074SpanIKcEC2INS1_IcEEvS5_TnNSt3__19enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKS8_:
  269|   619k|      : Span(span_internal::GetData(v), v.size()) {}
_ZNK4absl12lts_202601074SpanIKcE5emptyEv:
  333|  7.47M|  constexpr bool empty() const noexcept { return size() == 0; }
_ZN4absl12lts_202601078MakeSpanITpTnRiJENS0_13InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS5_EEEEEENS6_9enable_ifIXntsr13span_internal6IsViewIT0_EE5valueEDTclsr4abslE8MakeSpanclsr13span_internalE7GetDatafp_Ecldtfp_4sizeEEEE4typeERSB_:
  762|   619k|                                                c.size()))> {
  763|   619k|  return MakeSpan(span_internal::GetData(c), c.size());
  764|   619k|}
_ZN4absl12lts_202601078MakeSpanITpTnRiJEPNS0_7LogSinkEEENS0_4SpanIT0_EEPS6_m:
  738|  1.23M|                           size_t size) noexcept {
  739|  1.23M|  return Span<T>(ptr, size);
  740|  1.23M|}
_ZN4absl12lts_202601074SpanIPNS0_7LogSinkEEC2EPS3_m:
  230|  1.23M|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202601074SpanIcE13remove_prefixEm:
  433|  17.0M|  void remove_prefix(size_type n) noexcept {
  434|  17.0M|    ABSL_HARDENING_ASSERT(size() >= n);
  ------------------
  |  |  140|  17.0M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  17.0M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 17.0M]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  435|  17.0M|    ptr_ += n;
  436|  17.0M|    len_ -= n;
  437|  17.0M|  }
_ZN4absl12lts_202601074SpanIcEC2INSt3__15arrayIcLm15000EEEvS6_iEERT_:
  246|   619k|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202601074SpanIcE13remove_suffixEm:
  442|   619k|  void remove_suffix(size_type n) noexcept {
  443|   619k|    ABSL_HARDENING_ASSERT(size() >= n);
  ------------------
  |  |  140|   619k|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|   619k|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 619k]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  444|   619k|    len_ -= n;
  445|   619k|  }
_ZNK4absl12lts_202601074SpanIcEixEm:
  338|  19.6M|  constexpr reference operator[](size_type i) const noexcept {
  339|  19.6M|    ABSL_HARDENING_ASSERT(i < size());
  ------------------
  |  |  140|  19.6M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  19.6M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 19.6M]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  340|  19.6M|    return ptr_[i];
  341|  19.6M|  }
_ZNK4absl12lts_202601074SpanIKcEixEm:
  338|  35.2M|  constexpr reference operator[](size_type i) const noexcept {
  339|  35.2M|    ABSL_HARDENING_ASSERT(i < size());
  ------------------
  |  |  140|  35.2M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  35.2M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 35.2M]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  340|  35.2M|    return ptr_[i];
  341|  35.2M|  }
_ZNK4absl12lts_202601074SpanIKcE7subspanEmm:
  468|  2.93M|  constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
  469|  2.93M|    return (pos <= size())
  ------------------
  |  Branch (469:12): [True: 2.93M, False: 0]
  ------------------
  470|  2.93M|               ? Span(data() + pos, (std::min)(size() - pos, len))
  471|  2.93M|               : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
  472|  2.93M|  }
_ZN4absl12lts_202601074SpanIKcE13remove_prefixEm:
  433|  13.7M|  void remove_prefix(size_type n) noexcept {
  434|  13.7M|    ABSL_HARDENING_ASSERT(size() >= n);
  ------------------
  |  |  140|  13.7M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  13.7M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 13.7M]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  435|  13.7M|    ptr_ += n;
  436|  13.7M|    len_ -= n;
  437|  13.7M|  }
_ZN4absl12lts_202601078MakeSpanITpTnRiJEjLm512EEENS0_4SpanIT0_EERAT1__S4_:
  768|      1|    T (&array ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept {
  769|      1|  return Span<T>(array, N);
  770|      1|}
_ZNK4absl12lts_202601074SpanIKjE5beginEv:
  376|  1.47k|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202601074SpanIKjE4dataEv:
  318|  2.94k|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202601074SpanIKjE3endEv:
  389|  1.47k|  constexpr iterator end() const noexcept { return data() + size(); }
_ZNK4absl12lts_202601074SpanIKjE4sizeEv:
  323|  1.47k|  constexpr size_type size() const noexcept { return len_; }
_ZN4absl12lts_202601078MakeSpanITpTnRiJEjEENS0_4SpanIT0_EEPS4_m:
  738|      9|                           size_t size) noexcept {
  739|      9|  return Span<T>(ptr, size);
  740|      9|}
_ZN4absl12lts_202601074SpanIKjEC2INS1_IjEEvS5_TnNSt3__19enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKS8_:
  269|      8|      : Span(span_internal::GetData(v), v.size()) {}
_ZNK4absl12lts_202601074SpanIjE5emptyEv:
  333|      2|  constexpr bool empty() const noexcept { return size() == 0; }
_ZNK4absl12lts_202601074SpanIKNS0_19str_format_internal13FormatArgImplEEixEm:
  338|  2.51M|  constexpr reference operator[](size_type i) const noexcept {
  339|  2.51M|    ABSL_HARDENING_ASSERT(i < size());
  ------------------
  |  |  140|  2.51M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  2.51M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 2.51M]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  340|  2.51M|    return ptr_[i];
  341|  2.51M|  }
_ZNK4absl12lts_202601074SpanIPNS0_7LogSinkEE5beginEv:
  376|  1.23M|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202601074SpanIPNS0_7LogSinkEE4dataEv:
  318|  2.47M|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202601074SpanIPNS0_7LogSinkEE3endEv:
  389|  1.23M|  constexpr iterator end() const noexcept { return data() + size(); }
_ZNK4absl12lts_202601074SpanIPNS0_7LogSinkEE4sizeEv:
  323|  1.23M|  constexpr size_type size() const noexcept { return len_; }
_ZN4absl12lts_202601078MakeSpanITpTnRiJENSt3__16vectorIPNS0_7LogSinkENS3_9allocatorIS6_EEEEEENS3_9enable_ifIXntsr13span_internal6IsViewIT0_EE5valueEDTclsr4abslE8MakeSpanclsr13span_internalE7GetDatafp_Ecldtfp_4sizeEEEE4typeERSB_:
  762|   619k|                                                c.size()))> {
  763|   619k|  return MakeSpan(span_internal::GetData(c), c.size());
  764|   619k|}

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

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

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

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

_ZN4absl12lts_202601079btree_setIPN13sentencepiece3bpe7Trainer6SymbolENSt3__14lessIS6_EENS7_9allocatorIS6_EEEC2Ev:
  164|  1.81k|  btree_set() {}
_ZN4absl12lts_2026010718container_internal15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEE7destroyINSt3__19allocatorIS7_EEEEvPT_PS7_:
  823|   438k|  static void destroy(Alloc *alloc, slot_type *slot) {
  824|   438k|    absl::allocator_traits<Alloc>::destroy(*alloc, slot);
  825|   438k|  }
_ZN4absl12lts_2026010718container_internal15set_slot_policyImE7destroyINSt3__19allocatorImEEEEvPT_Pm:
  823|  2.53M|  static void destroy(Alloc *alloc, slot_type *slot) {
  824|  2.53M|    absl::allocator_traits<Alloc>::destroy(*alloc, slot);
  825|  2.53M|  }
_ZN4absl12lts_202601079btree_setImNSt3__14lessImEENS2_9allocatorImEEEC2Ev:
  164|   359k|  btree_set() {}
_ZN4absl12lts_2026010718container_internal15set_slot_policyImE7elementEPm:
  803|  32.0M|  static value_type &element(slot_type *slot) { return *slot; }
_ZN4absl12lts_2026010718container_internal15set_slot_policyImE9constructINSt3__19allocatorImEEEEvPT_PmSA_:
  813|  70.2k|  static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
  814|  70.2k|    absl::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other));
  815|  70.2k|  }
_ZN4absl12lts_2026010718container_internal15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEE3keyEPKS7_:
  863|  19.0M|  static const Key &key(const slot_type *slot) { return *slot; }
_ZN4absl12lts_2026010718container_internal15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEE7elementEPS7_:
  803|  21.6M|  static value_type &element(slot_type *slot) { return *slot; }
_ZN4absl12lts_2026010718container_internal15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEE9constructINSt3__19allocatorIS7_EEEEvPT_PS7_SF_:
  813|  13.9k|  static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
  814|  13.9k|    absl::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other));
  815|  13.9k|  }
_ZN4absl12lts_2026010718container_internal15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEE9constructINSt3__19allocatorIS7_EEJRKS7_EEEvPT_PS7_DpOT0_:
  807|   323k|  static void construct(Alloc *alloc, slot_type *slot, Args &&...args) {
  808|   323k|    absl::allocator_traits<Alloc>::construct(*alloc, slot,
  809|   323k|                                             std::forward<Args>(args)...);
  810|   323k|  }
_ZN4absl12lts_2026010718container_internal15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEE3keyIS7_EERKT_SC_:
  860|  2.56M|  static const V &key(const V &value) {
  861|  2.56M|    return value;
  862|  2.56M|  }
_ZN4absl12lts_2026010718container_internal15set_params_implImJEE3keyEPKm:
  863|  41.9M|  static const Key &key(const slot_type *slot) { return *slot; }
_ZN4absl12lts_2026010718container_internal15set_slot_policyImE9constructINSt3__19allocatorImEEJmEEEvPT_PmDpOT0_:
  807|  2.46M|  static void construct(Alloc *alloc, slot_type *slot, Args &&...args) {
  808|  2.46M|    absl::allocator_traits<Alloc>::construct(*alloc, slot,
  809|  2.46M|                                             std::forward<Args>(args)...);
  810|  2.46M|  }
_ZN4absl12lts_2026010718container_internal15set_params_implImJEE3keyImEERKT_S7_:
  860|  2.46M|  static const V &key(const V &value) {
  861|  2.46M|    return value;
  862|  2.46M|  }
_ZN4absl12lts_2026010718container_internal15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEE9constructINSt3__19allocatorIS7_EEJRS7_EEEvPT_PS7_DpOT0_:
  807|   101k|  static void construct(Alloc *alloc, slot_type *slot, Args &&...args) {
  808|   101k|    absl::allocator_traits<Alloc>::construct(*alloc, slot,
  809|   101k|                                             std::forward<Args>(args)...);
  810|   101k|  }

_ZN4absl12lts_2026010713flat_hash_mapImPN13sentencepiece3bpe7Trainer6SymbolENS0_13hash_internal4HashImEENSt3__18equal_toImEENSA_9allocatorINSA_4pairIKmS6_EEEEEC2Ev:
  184|  1.81k|  flat_hash_map() {}
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE7destroyINSt3__19allocatorINSA_4pairIKmS7_EEEEEEDaPT_PNS1_13map_slot_typeImS7_EE:
  655|  56.8k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  656|  56.8k|    return slot_policy::destroy(alloc, slot);
  657|  56.8k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjlE7destroyINSt3__19allocatorINS5_4pairIKjlEEEEEEDaPT_PNS1_13map_slot_typeIjlEE:
  655|     83|  static auto destroy(Allocator* alloc, slot_type* slot) {
  656|     83|    return slot_policy::destroy(alloc, slot);
  657|     83|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjNSt3__14pairIblEEE7destroyINS3_9allocatorINS4_IKjS5_EEEEEEDaPT_PNS1_13map_slot_typeIjS5_EE:
  655|     49|  static auto destroy(Allocator* alloc, slot_type* slot) {
  656|     49|    return slot_policy::destroy(alloc, slot);
  657|     49|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE7destroyINS7_INS3_4pairIKS9_lEEEEEEDaPT_PNS1_13map_slot_typeIS9_lEE:
  655|  2.13M|  static auto destroy(Allocator* alloc, slot_type* slot) {
  656|  2.13M|    return slot_policy::destroy(alloc, slot);
  657|  2.13M|  }
_ZN4absl12lts_2026010713flat_hash_mapIjlNS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS5_9allocatorINS5_4pairIKjlEEEEEC2Ev:
  184|  10.1k|  flat_hash_map() {}
_ZN4absl12lts_2026010713flat_hash_mapIjNSt3__14pairIblEENS0_13hash_internal4HashIjEENS2_8equal_toIjEENS2_9allocatorINS3_IKjS4_EEEEEC2Ev:
  184|  10.1k|  flat_hash_map() {}
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjNSt3__14pairIblEEE5valueEPNS4_IKjS5_EE:
  684|  9.22M|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjNSt3__14pairIblEEE7elementEPNS1_13map_slot_typeIjS5_EE:
  682|  18.9M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjNSt3__14pairIblEEE5applyINS1_12EqualElementIjNS3_8equal_toIjEEEEJRNS4_IKjS5_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSF_DpOSG_:
  668|  9.04M|  apply(F&& f, Args&&... args) {
  669|  9.04M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  9.04M|                                                   std::forward<Args>(args)...);
  671|  9.04M|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjNSt3__14pairIblEEE8transferINS3_9allocatorINS4_IKjS5_EEEEEEDaPT_PNS1_13map_slot_typeIjS5_EESG_:
  661|   439k|                       slot_type* old_slot) {
  662|   439k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  663|   439k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjNSt3__14pairIblEEE5applyINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEEJRNS4_IKjS5_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSG_DpOSH_:
  668|   352k|  apply(F&& f, Args&&... args) {
  669|   352k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|   352k|                                                   std::forward<Args>(args)...);
  671|   352k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjNSt3__14pairIblEEE9constructINS3_9allocatorINS4_IKjS5_EEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRS9_EEENSF_IJEEEEEEvPT_PNS1_13map_slot_typeIjS5_EEDpOT0_:
  649|   330k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|   330k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|   330k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjlE5applyINS1_12raw_hash_setIS3_JEE19EmplaceDecomposableEJRKjRKlEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSC_DpOSD_:
  668|   298k|  apply(F&& f, Args&&... args) {
  669|   298k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|   298k|                                                   std::forward<Args>(args)...);
  671|   298k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjlE5applyINS1_12EqualElementIjNSt3__18equal_toIjEEEEJRNS6_4pairIKjlEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSE_DpOSF_:
  668|  10.6M|  apply(F&& f, Args&&... args) {
  669|  10.6M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  10.6M|                                                   std::forward<Args>(args)...);
  671|  10.6M|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjlE7elementEPNS1_13map_slot_typeIjlEE:
  682|  12.6M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjlE5applyINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEEJRNSt3__14pairIKjlEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSF_DpOSG_:
  668|   302k|  apply(F&& f, Args&&... args) {
  669|   302k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|   302k|                                                   std::forward<Args>(args)...);
  671|   302k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjlE8transferINSt3__19allocatorINS5_4pairIKjlEEEEEEDaPT_PNS1_13map_slot_typeIjlEESF_:
  661|   300k|                       slot_type* old_slot) {
  662|   300k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  663|   300k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjlE9constructINSt3__19allocatorINS5_4pairIKjlEEEEJRKNS5_21piecewise_construct_tENS5_5tupleIJRS8_EEENSE_IJRKlEEEEEEvPT_PNS1_13map_slot_typeIjlEEDpOT0_:
  649|   298k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|   298k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|   298k|  }
_ZN4absl12lts_2026010713flat_hash_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElNS0_18container_internal10StringHashENS9_8StringEqENS6_INS2_4pairIKS8_lEEEEEC2Ev:
  184|  21.2k|  flat_hash_map() {}
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE5valueEPNS3_4pairIKS9_lEE:
  684|  13.0M|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE7elementEPNS1_13map_slot_typeIS9_lEE:
  682|  29.4M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE5applyINS1_12EqualElementINS3_17basic_string_viewIcS6_EENS1_8StringEqEEEJRNS3_4pairIKS9_lEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSL_DpOSM_:
  668|   107k|  apply(F&& f, Args&&... args) {
  669|   107k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|   107k|                                                   std::forward<Args>(args)...);
  671|   107k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE8transferINS7_INS3_4pairIKS9_lEEEEEEDaPT_PNS1_13map_slot_typeIS9_lEESK_:
  661|  3.02M|                       slot_type* old_slot) {
  662|  3.02M|    return slot_policy::transfer(alloc, new_slot, old_slot);
  663|  3.02M|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS3_4pairIKS9_lEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|  2.87M|  apply(F&& f, Args&&... args) {
  669|  2.87M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  2.87M|                                                   std::forward<Args>(args)...);
  671|  2.87M|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE9constructINS7_INS3_4pairIKS9_lEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKNS3_17basic_string_viewIcS6_EEEEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_lEEDpOT0_:
  649|   189k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|   189k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|   189k|  }
_ZN4absl12lts_2026010713flat_hash_mapINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEiNS0_18container_internal10StringHashENS7_8StringEqENS2_9allocatorINS2_4pairIKS6_iEEEEEC2Ev:
  184|  13.7k|  flat_hash_map() {}
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE8transferINS7_INS3_4pairIKS9_fEEEEEEDaPT_PNS1_13map_slot_typeIS9_fEESK_:
  661|   315k|                       slot_type* old_slot) {
  662|   315k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  663|   315k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS3_4pairIKS9_fEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|   252k|  apply(F&& f, Args&&... args) {
  669|   252k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|   252k|                                                   std::forward<Args>(args)...);
  671|   252k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE7elementEPNS1_13map_slot_typeIS9_fEE:
  682|  1.33M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE5applyINS1_12raw_hash_setISA_JEE19EmplaceDecomposableEJRKNS3_4pairIS9_fEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|   258k|  apply(F&& f, Args&&... args) {
  669|   258k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|   258k|                                                   std::forward<Args>(args)...);
  671|   258k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE5applyINS1_12EqualElementIS9_NS1_8StringEqEEEJRNS3_4pairIKS9_fEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|   436k|  apply(F&& f, Args&&... args) {
  669|   436k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|   436k|                                                   std::forward<Args>(args)...);
  671|   436k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE9constructINS7_INS3_4pairIKS9_fEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJRKfEEEEEEvPT_PNS1_13map_slot_typeIS9_fEEDpOT0_:
  649|   258k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|   258k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|   258k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE7destroyINS7_INS3_4pairIKS9_fEEEEEEDaPT_PNS1_13map_slot_typeIS9_fEE:
  655|   505k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  656|   505k|    return slot_policy::destroy(alloc, slot);
  657|   505k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE5applyINS1_12EqualElementIS9_NS1_8StringEqEEEJRNS3_4pairIKS9_lEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|  11.3M|  apply(F&& f, Args&&... args) {
  669|  11.3M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  11.3M|                                                   std::forward<Args>(args)...);
  671|  11.3M|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE9constructINS7_INS3_4pairIKS9_lEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOS9_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_lEEDpOT0_:
  649|   187k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|   187k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|   187k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE9constructINS7_INS3_4pairIKS9_lEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_lEEDpOT0_:
  649|  1.76M|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|  1.76M|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|  1.76M|  }
_ZN4absl12lts_2026010713flat_hash_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEfNS0_18container_internal10StringHashENS9_8StringEqENS6_INS2_4pairIKS8_fEEEEEC2Ev:
  184|  6.79k|  flat_hash_map() {}
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE5valueEPNS3_4pairIKS9_fEE:
  684|   396k|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE9constructINS7_INS3_4pairIKS9_fEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_fEEDpOT0_:
  649|   247k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|   247k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|   247k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE7destroyINS7_INS3_4pairIKS9_mEEEEEEDaPT_PNS1_13map_slot_typeIS9_mEE:
  655|   103k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  656|   103k|    return slot_policy::destroy(alloc, slot);
  657|   103k|  }
_ZN4absl12lts_2026010713flat_hash_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEmNS0_18container_internal10StringHashENS9_8StringEqENS6_INS2_4pairIKS8_mEEEEEC2Ev:
  184|  1.16k|  flat_hash_map() {}
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE5valueEPNS3_4pairIKS9_mEE:
  684|   164k|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE7elementEPNS1_13map_slot_typeIS9_mEE:
  682|   582k|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE5applyINS1_12EqualElementINS3_17basic_string_viewIcS6_EENS1_8StringEqEEEJRNS3_4pairIKS9_mEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSL_DpOSM_:
  668|  72.0k|  apply(F&& f, Args&&... args) {
  669|  72.0k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  72.0k|                                                   std::forward<Args>(args)...);
  671|  72.0k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE8transferINS7_INS3_4pairIKS9_mEEEEEEDaPT_PNS1_13map_slot_typeIS9_mEESK_:
  661|   150k|                       slot_type* old_slot) {
  662|   150k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  663|   150k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS3_4pairIKS9_mEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|   140k|  apply(F&& f, Args&&... args) {
  669|   140k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|   140k|                                                   std::forward<Args>(args)...);
  671|   140k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE9constructINS7_INS3_4pairIKS9_mEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKNS3_17basic_string_viewIcS6_EEEEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_mEEDpOT0_:
  649|   103k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|   103k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|   103k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE5applyINS1_12EqualElementImNSt3__18equal_toImEEEEJRNSB_4pairIKmS7_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|  5.03M|  apply(F&& f, Args&&... args) {
  669|  5.03M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  5.03M|                                                   std::forward<Args>(args)...);
  671|  5.03M|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE7elementEPNS1_13map_slot_typeImS7_EE:
  682|  10.4M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE5applyINS1_12raw_hash_setIS8_JEE19EmplaceDecomposableEJRKNSt3__14pairIKmS7_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|   359k|  apply(F&& f, Args&&... args) {
  669|   359k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|   359k|                                                   std::forward<Args>(args)...);
  671|   359k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE5applyINS1_11HashElementINS0_13hash_internal4HashImEELb1EEEJRNSt3__14pairIKmS7_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSK_DpOSL_:
  668|   468k|  apply(F&& f, Args&&... args) {
  669|   468k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|   468k|                                                   std::forward<Args>(args)...);
  671|   468k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE8transferINSt3__19allocatorINSA_4pairIKmS7_EEEEEEDaPT_PNS1_13map_slot_typeImS7_EESK_:
  661|   465k|                       slot_type* old_slot) {
  662|   465k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  663|   465k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE9constructINSt3__19allocatorINSA_4pairIKmS7_EEEEJRKNSA_21piecewise_construct_tENSA_5tupleIJRSD_EEENSJ_IJRKS7_EEEEEEvPT_PNS1_13map_slot_typeImS7_EEDpOT0_:
  649|   359k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|   359k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|   359k|  }
_ZN4absl12lts_2026010713flat_hash_mapIjN13sentencepiece14unicode_script10ScriptTypeENS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS8_9allocatorINS8_4pairIKjS4_EEEEEC2Ev:
  184|      1|  flat_hash_map() {}
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEE5valueEPNSt3__14pairIKjS5_EE:
  684|   128k|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEE7elementEPNS1_13map_slot_typeIjS5_EE:
  682|  62.9M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEE5applyINS1_12EqualElementIjNSt3__18equal_toIjEEEEJRNS9_4pairIKjS5_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSH_DpOSI_:
  668|  31.3M|  apply(F&& f, Args&&... args) {
  669|  31.3M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|  31.3M|                                                   std::forward<Args>(args)...);
  671|  31.3M|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEE5applyINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEEJRNSt3__14pairIKjS5_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSI_DpOSJ_:
  668|   229k|  apply(F&& f, Args&&... args) {
  669|   229k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|   229k|                                                   std::forward<Args>(args)...);
  671|   229k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEE8transferINSt3__19allocatorINS8_4pairIKjS5_EEEEEEDaPT_PNS1_13map_slot_typeIjS5_EESI_:
  661|   229k|                       slot_type* old_slot) {
  662|   229k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  663|   229k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEE9constructINSt3__19allocatorINS8_4pairIKjS5_EEEEJRKNS8_21piecewise_construct_tENS8_5tupleIJRSB_EEENSH_IJEEEEEEvPT_PNS1_13map_slot_typeIjS5_EEDpOT0_:
  649|   127k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|   127k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|   127k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEE9constructINSt3__19allocatorINS8_4pairIKjS5_EEEEJRKNS8_21piecewise_construct_tENS8_5tupleIJOjEEENSH_IJEEEEEEvPT_PNS1_13map_slot_typeIjS5_EEDpOT0_:
  649|    697|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|    697|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|    697|  }

_ZN4absl12lts_2026010718container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE7destroyINS7_IS9_EEEEDaPT_PS9_:
  554|   134k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  555|   134k|    absl::allocator_traits<Allocator>::destroy(*alloc, slot);
  556|   134k|    return IsDestructionTrivial<Allocator, slot_type>();
  557|   134k|  }
_ZN4absl12lts_2026010713flat_hash_setINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_18container_internal10StringHashENS9_8StringEqENS6_IS8_EEEC2Ev:
  180|  1.79k|  flat_hash_set() {}
_ZN4absl12lts_2026010718container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE5applyINS1_12raw_hash_setISA_JEE19EmplaceDecomposableEJS9_EEEDTclsr4absl18container_internalE14DecomposeValueclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSF_DpOSG_:
  564|  56.8k|  apply(F&& f, Args&&... args) {
  565|  56.8k|    return absl::container_internal::DecomposeValue(
  566|  56.8k|        std::forward<F>(f), std::forward<Args>(args)...);
  567|  56.8k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE5applyINS1_12EqualElementIS9_NS1_8StringEqEEEJRS9_EEEDTclsr4absl18container_internalE14DecomposeValueclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSG_DpOSH_:
  564|  5.62k|  apply(F&& f, Args&&... args) {
  565|  5.62k|    return absl::container_internal::DecomposeValue(
  566|  5.62k|        std::forward<F>(f), std::forward<Args>(args)...);
  567|  5.62k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE7elementEPS9_:
  559|   143k|  static T& element(slot_type* slot) { return *slot; }
_ZN4absl12lts_2026010718container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE9constructINS7_IS9_EEJS9_EEEvPT_PS9_DpOT0_:
  547|   134k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  548|   134k|    absl::allocator_traits<Allocator>::construct(*alloc, slot,
  549|   134k|                                                 std::forward<Args>(args)...);
  550|   134k|  }
_ZN4absl12lts_2026010718container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRS9_EEEDTclsr4absl18container_internalE14DecomposeValueclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSG_DpOSH_:
  564|  60.9k|  apply(F&& f, Args&&... args) {
  565|  60.9k|    return absl::container_internal::DecomposeValue(
  566|  60.9k|        std::forward<F>(f), std::forward<Args>(args)...);
  567|  60.9k|  }

_ZN4absl12lts_2026010713InlinedVectorIjLm8ENSt3__19allocatorIjEEE5beginEv:
  437|  1.46k|  iterator begin() noexcept ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
_ZN4absl12lts_2026010713InlinedVectorIjLm8ENSt3__19allocatorIjEEE4dataEv:
  347|  2.92k|  pointer data() noexcept ABSL_ATTRIBUTE_LIFETIME_BOUND {
  348|  2.92k|    return storage_.GetIsAllocated() ? storage_.GetAllocatedData()
  ------------------
  |  Branch (348:12): [True: 0, False: 2.92k]
  ------------------
  349|  2.92k|                                     : storage_.GetInlinedData();
  350|  2.92k|  }
_ZN4absl12lts_2026010713InlinedVectorIjLm8ENSt3__19allocatorIjEEE3endEv:
  448|  1.46k|  iterator end() noexcept ABSL_ATTRIBUTE_LIFETIME_BOUND {
  449|  1.46k|    return data() + size();
  450|  1.46k|  }
_ZNK4absl12lts_2026010713InlinedVectorIjLm8ENSt3__19allocatorIjEEE4sizeEv:
  313|  1.46k|  size_type size() const noexcept { return storage_.GetSize(); }
_ZN4absl12lts_2026010713InlinedVectorIjLm8ENSt3__19allocatorIjEEEC2Ev:
  127|  1.46k|  InlinedVector() noexcept(noexcept(allocator_type())) : storage_() {}
_ZN4absl12lts_2026010713InlinedVectorIjLm8ENSt3__19allocatorIjEEE9push_backERKj:
  753|  1.46k|  void push_back(const_reference v) { static_cast<void>(emplace_back(v)); }
_ZN4absl12lts_2026010713InlinedVectorIjLm8ENSt3__19allocatorIjEEE12emplace_backIJRKjEEERjDpOT_:
  746|  1.46k|  reference emplace_back(Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
  747|  1.46k|    return storage_.EmplaceBack(std::forward<Args>(args)...);
  748|  1.46k|  }
_ZN4absl12lts_2026010713InlinedVectorIjLm8ENSt3__19allocatorIjEEED2Ev:
  299|  1.46k|  ~InlinedVector() {}

_ZN4absl12lts_2026010718container_internal19key_compare_adapterINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEES9_E15checked_compareC2ESA_:
  228|  1.81k|    checked_compare(Compare cmp) : Base(std::move(cmp)) {}  // NOLINT
_ZN4absl12lts_2026010718container_internal20checked_compare_baseINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEELb1EEC2ESA_:
  175|  1.81k|  explicit checked_compare_base(Compare c) : Compare(std::move(c)) {}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEC2ERKNS1_19key_compare_adapterINSt3__14lessIS8_EES8_E15checked_compareERKNSC_9allocatorIS8_EE:
 1420|  1.81k|      : root_(EmptyNode()), rightmost_(comp, alloc, EmptyNode()), size_(0) {}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE9EmptyNodeEv:
 1358|  9.71k|  static node_type *EmptyNode() {
 1359|  9.71k|    alignas(node_type::Alignment()) static constexpr EmptyNodeType empty_node;
 1360|  9.71k|    return const_cast<EmptyNodeType *>(&empty_node);
 1361|  9.71k|  }
_ZN4absl12lts_2026010718container_internal39btree_iterator_generation_info_disabledC2Ej:
 1092|  16.3M|  explicit btree_iterator_generation_info_disabled(uint32_t) {}
_ZN4absl12lts_2026010718container_internal39btree_iterator_generation_info_disabled17update_generationEPKv:
 1093|  9.92M|  static void update_generation(const void *) {}
_ZN4absl12lts_2026010718container_internal39btree_iterator_generation_info_disabled10generationEv:
 1094|  56.8k|  static uint32_t generation() { return 0; }
_ZN4absl12lts_2026010718container_internal39btree_iterator_generation_info_disabled23assert_valid_generationEPKv:
 1095|  65.6M|  static void assert_valid_generation(const void *) {}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10LeafLayoutEm:
  633|  62.3k|      const size_type slot_count = kNodeSlots) {
  634|  62.3k|    return leaf_layout_type(slot_count, 0);
  635|  62.3k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE14InternalLayoutEv:
  636|  84.8M|  constexpr static auto InternalLayout() { return internal_layout_type(); }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE5clearEv:
 2673|  6.08k|void btree<P>::clear() {
 2674|  6.08k|  if (!empty()) {
  ------------------
  |  Branch (2674:7): [True: 3.52k, False: 2.56k]
  ------------------
 2675|  3.52k|    node_type::clear_and_delete(root(), mutable_allocator());
 2676|  3.52k|  }
 2677|  6.08k|  mutable_root() = mutable_rightmost() = EmptyNode();
 2678|  6.08k|  size_ = 0;
 2679|  6.08k|}
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE5emptyEv:
 1601|  2.68M|  bool empty() const { return size_ == 0; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8LeafSizeEm:
  637|  62.3k|  constexpr static size_type LeafSize(const size_type slot_count = kNodeSlots) {
  638|  62.3k|    return LeafLayout(slot_count).AllocSize();
  639|  62.3k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE12InternalSizeEv:
  640|  4.50k|  constexpr static size_type InternalSize() {
  641|  4.50k|    return InternalLayout().AllocSize();
  642|  4.50k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE16clear_and_deleteEPSA_PNSt3__19allocatorIS8_EE:
 2026|  19.2k|void btree_node<P>::clear_and_delete(btree_node *node, allocator_type *alloc) {
 2027|  19.2k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2027:7): [True: 17.2k, False: 2.03k]
  ------------------
 2028|  17.2k|    node->value_destroy_n(node->start(), node->count(), alloc);
 2029|  17.2k|    deallocate(LeafSize(node->max_count()), node, alloc);
 2030|  17.2k|    return;
 2031|  17.2k|  }
 2032|  2.03k|  if (node->count() == 0) {
  ------------------
  |  Branch (2032:7): [True: 407, False: 1.62k]
  ------------------
 2033|    407|    deallocate(InternalSize(), node, alloc);
 2034|    407|    return;
 2035|    407|  }
 2036|       |
 2037|       |  // The parent of the root of the subtree we are deleting.
 2038|  1.62k|  btree_node *delete_root_parent = node->parent();
 2039|       |
 2040|       |  // Navigate to the leftmost leaf under node, and then delete upwards.
 2041|  3.35k|  while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (2041:10): [True: 1.72k, False: 1.62k]
  ------------------
 2042|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2043|       |  // When generations are enabled, we delete the leftmost leaf last in case it's
 2044|       |  // the parent of the root and we need to check whether it's a leaf before we
 2045|       |  // can update the root's generation.
 2046|       |  // TODO(ezb): if we change btree_node::is_root to check a bool inside the node
 2047|       |  // instead of checking whether the parent is a leaf, we can remove this logic.
 2048|       |  btree_node *leftmost_leaf = node;
 2049|       |#endif
 2050|       |  // Use `size_type` because `pos` needs to be able to hold `kNodeSlots+1`,
 2051|       |  // which isn't guaranteed to be a valid `field_type`.
 2052|  1.62k|  size_type pos = node->position();
 2053|  1.62k|  btree_node *parent = node->parent();
 2054|  1.74k|  for (;;) {
 2055|       |    // In each iteration of the next loop, we delete one leaf node and go right.
 2056|  1.74k|    assert(pos <= parent->finish());
 2057|  13.9k|    do {
 2058|  13.9k|      node = parent->child(static_cast<field_type>(pos));
 2059|  13.9k|      if (node->is_internal()) {
  ------------------
  |  Branch (2059:11): [True: 122, False: 13.8k]
  ------------------
 2060|       |        // Navigate to the leftmost leaf under node.
 2061|    244|        while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (2061:16): [True: 122, False: 122]
  ------------------
 2062|    122|        pos = node->position();
 2063|    122|        parent = node->parent();
 2064|    122|      }
 2065|  13.9k|      node->value_destroy_n(node->start(), node->count(), alloc);
 2066|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2067|       |      if (leftmost_leaf != node)
 2068|       |#endif
 2069|  13.9k|        deallocate(LeafSize(node->max_count()), node, alloc);
 2070|  13.9k|      ++pos;
 2071|  13.9k|    } while (pos <= parent->finish());
  ------------------
  |  Branch (2071:14): [True: 12.2k, False: 1.74k]
  ------------------
 2072|       |
 2073|       |    // Once we've deleted all children of parent, delete parent and go up/right.
 2074|  1.74k|    assert(pos > parent->finish());
 2075|  1.84k|    do {
 2076|  1.84k|      node = parent;
 2077|  1.84k|      pos = node->position();
 2078|  1.84k|      parent = node->parent();
 2079|  1.84k|      node->value_destroy_n(node->start(), node->count(), alloc);
 2080|  1.84k|      deallocate(InternalSize(), node, alloc);
 2081|  1.84k|      if (parent == delete_root_parent) {
  ------------------
  |  Branch (2081:11): [True: 1.62k, False: 222]
  ------------------
 2082|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2083|       |        deallocate(LeafSize(leftmost_leaf->max_count()), leftmost_leaf, alloc);
 2084|       |#endif
 2085|  1.62k|        return;
 2086|  1.62k|      }
 2087|    222|      ++pos;
 2088|    222|    } while (pos > parent->finish());
  ------------------
  |  Branch (2088:14): [True: 100, False: 122]
  ------------------
 2089|  1.74k|  }
 2090|  1.62k|}
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE7is_leafEv:
  679|  17.1M|  bool is_leaf() const { return GetField<2>()[3] != kInternalNodeMaxCount; }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8GetFieldILm2EEEPKNSt3__113tuple_elementIXT_ENSC_5tupleIJPSA_jhS8_SF_EEEE4typeEv:
  659|  48.8M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  660|       |    assert(N < 4 || is_internal());
  661|  48.8M|    return InternalLayout().template Pointer<N>(
  662|  48.8M|        reinterpret_cast<const char *>(this));
  663|  48.8M|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE15value_destroy_nEhhPNSt3__19allocatorIS8_EE:
  991|  88.7k|                       allocator_type *alloc) {
  992|  88.7k|    next_generation();
  993|   512k|    for (slot_type *s = slot(i), *end = slot(i + n); s != end; ++s) {
  ------------------
  |  Branch (993:54): [True: 424k, False: 88.7k]
  ------------------
  994|   424k|      params_type::destroy(alloc, s);
  995|   424k|      absl::container_internal::SanitizerPoisonObject(s);
  996|   424k|    }
  997|  88.7k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE15next_generationEv:
  743|  1.20M|  void next_generation() {
  744|  1.20M|    if (BtreeGenerationsEnabled()) ++*get_root_generation();
  ------------------
  |  Branch (744:9): [Folded, False: 1.20M]
  ------------------
  745|  1.20M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE7is_rootEv:
  718|   439k|  bool is_root() const { return parent()->is_leaf(); }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE4slotEm:
  666|  12.1M|  slot_type *slot(size_type i) { return &GetField<3>()[i]; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8GetFieldILm3EEEPNSt3__113tuple_elementIXT_ENSC_5tupleIJPSA_jhS8_SF_EEEE4typeEv:
  653|  12.1M|  inline typename layout_type::template ElementType<N> *GetField() {
  654|       |    // We assert that we don't read from values that aren't there.
  655|       |    assert(N < 4 || is_internal());
  656|  12.1M|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  657|  12.1M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE5startEv:
  688|  9.11M|  field_type start() const {
  689|       |    // TODO(ezb): when floating storage is implemented, return GetField<2>()[1];
  690|       |    assert(GetField<2>()[1] == 0);
  691|  9.11M|    return 0;
  692|  9.11M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE5countEv:
  698|   806k|  field_type count() const {
  699|       |    assert(finish() >= start());
  700|   806k|    return finish() - start();
  701|   806k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10deallocateEmPSA_PNSt3__19allocatorIS8_EE:
  970|  33.4k|                         allocator_type *alloc) {
  971|  33.4k|    absl::container_internal::SanitizerUnpoisonMemoryRegion(node, size);
  972|  33.4k|    absl::container_internal::Deallocate<Alignment()>(alloc, node, size);
  973|  33.4k|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE9max_countEv:
  702|   455k|  field_type max_count() const {
  703|       |    // Internal nodes have max_count==kInternalNodeMaxCount.
  704|       |    // Leaf nodes have max_count in [1, kNodeSlots].
  705|   455k|    const field_type max_count = GetField<2>()[3];
  706|   455k|    return max_count == field_type{kInternalNodeMaxCount}
  ------------------
  |  Branch (706:12): [True: 0, False: 455k]
  ------------------
  707|   455k|               ? field_type{kNodeSlots}
  708|   455k|               : max_count;
  709|   455k|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE6parentEv:
  714|  1.33M|  btree_node *parent() const { return *GetField<0>(); }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8GetFieldILm0EEEPKNSt3__113tuple_elementIXT_ENSC_5tupleIJPSA_jhS8_SF_EEEE4typeEv:
  659|  1.33M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  660|       |    assert(N < 4 || is_internal());
  661|  1.33M|    return InternalLayout().template Pointer<N>(
  662|  1.33M|        reinterpret_cast<const char *>(this));
  663|  1.33M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE11is_internalEv:
  682|  1.34M|  bool is_internal() const { return !is_leaf(); }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE11start_childEv:
  756|  5.75k|  btree_node *start_child() const { return child(start()); }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8positionEv:
  685|   858k|  field_type position() const { return GetField<2>()[0]; }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE5childEh:
  755|  2.44M|  btree_node *child(field_type i) const { return GetField<4>()[i]; }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8GetFieldILm4EEEPKNSt3__113tuple_elementIXT_ENSC_5tupleIJPSA_jhS8_SF_EEEE4typeEv:
  659|  2.44M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  660|       |    assert(N < 4 || is_internal());
  661|  2.44M|    return InternalLayout().template Pointer<N>(
  662|  2.44M|        reinterpret_cast<const char *>(this));
  663|  2.44M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE6finishEv:
  695|  30.3M|  field_type finish() const { return GetField<2>()[2]; }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE4rootEv:
 1677|   300k|  node_type *root() { return root_; }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE17mutable_allocatorEv:
 1694|   587k|  allocator_type *mutable_allocator() noexcept {
 1695|   587k|    return &rightmost_.template get<1>();
 1696|   587k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE12mutable_rootEv:
 1679|  26.7k|  node_type *&mutable_root() noexcept { return root_; }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE17mutable_rightmostEv:
 1682|  30.3k|  node_type *&mutable_rightmost() noexcept {
 1683|  30.3k|    return rightmost_.template get<2>();
 1684|  30.3k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE10LeafLayoutEm:
  633|  1.37M|      const size_type slot_count = kNodeSlots) {
  634|  1.37M|    return leaf_layout_type(slot_count, 0);
  635|  1.37M|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE14InternalLayoutEv:
  636|   150M|  constexpr static auto InternalLayout() { return internal_layout_type(); }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE9EmptyNodeEv:
 1358|  1.15M|  static node_type *EmptyNode() {
 1359|  1.15M|    alignas(node_type::Alignment()) static constexpr EmptyNodeType empty_node;
 1360|  1.15M|    return const_cast<EmptyNodeType *>(&empty_node);
 1361|  1.15M|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE5clearEv:
 2673|   359k|void btree<P>::clear() {
 2674|   359k|  if (!empty()) {
  ------------------
  |  Branch (2674:7): [True: 243k, False: 116k]
  ------------------
 2675|   243k|    node_type::clear_and_delete(root(), mutable_allocator());
 2676|   243k|  }
 2677|   359k|  mutable_root() = mutable_rightmost() = EmptyNode();
 2678|   359k|  size_ = 0;
 2679|   359k|}
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE5emptyEv:
 1601|  3.25M|  bool empty() const { return size_ == 0; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8LeafSizeEm:
  637|  1.37M|  constexpr static size_type LeafSize(const size_type slot_count = kNodeSlots) {
  638|  1.37M|    return LeafLayout(slot_count).AllocSize();
  639|  1.37M|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE12InternalSizeEv:
  640|  23.4k|  constexpr static size_type InternalSize() {
  641|  23.4k|    return InternalLayout().AllocSize();
  642|  23.4k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE16clear_and_deleteEPS5_PNSt3__19allocatorImEE:
 2026|   662k|void btree_node<P>::clear_and_delete(btree_node *node, allocator_type *alloc) {
 2027|   662k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2027:7): [True: 651k, False: 11.1k]
  ------------------
 2028|   651k|    node->value_destroy_n(node->start(), node->count(), alloc);
 2029|   651k|    deallocate(LeafSize(node->max_count()), node, alloc);
 2030|   651k|    return;
 2031|   651k|  }
 2032|  11.1k|  if (node->count() == 0) {
  ------------------
  |  Branch (2032:7): [True: 5.87k, False: 5.25k]
  ------------------
 2033|  5.87k|    deallocate(InternalSize(), node, alloc);
 2034|  5.87k|    return;
 2035|  5.87k|  }
 2036|       |
 2037|       |  // The parent of the root of the subtree we are deleting.
 2038|  5.25k|  btree_node *delete_root_parent = node->parent();
 2039|       |
 2040|       |  // Navigate to the leftmost leaf under node, and then delete upwards.
 2041|  10.7k|  while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (2041:10): [True: 5.44k, False: 5.25k]
  ------------------
 2042|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2043|       |  // When generations are enabled, we delete the leftmost leaf last in case it's
 2044|       |  // the parent of the root and we need to check whether it's a leaf before we
 2045|       |  // can update the root's generation.
 2046|       |  // TODO(ezb): if we change btree_node::is_root to check a bool inside the node
 2047|       |  // instead of checking whether the parent is a leaf, we can remove this logic.
 2048|       |  btree_node *leftmost_leaf = node;
 2049|       |#endif
 2050|       |  // Use `size_type` because `pos` needs to be able to hold `kNodeSlots+1`,
 2051|       |  // which isn't guaranteed to be a valid `field_type`.
 2052|  5.25k|  size_type pos = node->position();
 2053|  5.25k|  btree_node *parent = node->parent();
 2054|  5.63k|  for (;;) {
 2055|       |    // In each iteration of the next loop, we delete one leaf node and go right.
 2056|  5.63k|    assert(pos <= parent->finish());
 2057|  33.7k|    do {
 2058|  33.7k|      node = parent->child(static_cast<field_type>(pos));
 2059|  33.7k|      if (node->is_internal()) {
  ------------------
  |  Branch (2059:11): [True: 383, False: 33.3k]
  ------------------
 2060|       |        // Navigate to the leftmost leaf under node.
 2061|    766|        while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (2061:16): [True: 383, False: 383]
  ------------------
 2062|    383|        pos = node->position();
 2063|    383|        parent = node->parent();
 2064|    383|      }
 2065|  33.7k|      node->value_destroy_n(node->start(), node->count(), alloc);
 2066|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2067|       |      if (leftmost_leaf != node)
 2068|       |#endif
 2069|  33.7k|        deallocate(LeafSize(node->max_count()), node, alloc);
 2070|  33.7k|      ++pos;
 2071|  33.7k|    } while (pos <= parent->finish());
  ------------------
  |  Branch (2071:14): [True: 28.1k, False: 5.63k]
  ------------------
 2072|       |
 2073|       |    // Once we've deleted all children of parent, delete parent and go up/right.
 2074|  5.63k|    assert(pos > parent->finish());
 2075|  5.82k|    do {
 2076|  5.82k|      node = parent;
 2077|  5.82k|      pos = node->position();
 2078|  5.82k|      parent = node->parent();
 2079|  5.82k|      node->value_destroy_n(node->start(), node->count(), alloc);
 2080|  5.82k|      deallocate(InternalSize(), node, alloc);
 2081|  5.82k|      if (parent == delete_root_parent) {
  ------------------
  |  Branch (2081:11): [True: 5.25k, False: 572]
  ------------------
 2082|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2083|       |        deallocate(LeafSize(leftmost_leaf->max_count()), leftmost_leaf, alloc);
 2084|       |#endif
 2085|  5.25k|        return;
 2086|  5.25k|      }
 2087|    572|      ++pos;
 2088|    572|    } while (pos > parent->finish());
  ------------------
  |  Branch (2088:14): [True: 189, False: 383]
  ------------------
 2089|  5.63k|  }
 2090|  5.25k|}
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE7is_leafEv:
  679|  21.2M|  bool is_leaf() const { return GetField<2>()[3] != kInternalNodeMaxCount; }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm2EEEPKNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  659|  70.9M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  660|       |    assert(N < 4 || is_internal());
  661|  70.9M|    return InternalLayout().template Pointer<N>(
  662|  70.9M|        reinterpret_cast<const char *>(this));
  663|  70.9M|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE15value_destroy_nEhhPNSt3__19allocatorImEE:
  991|   711k|                       allocator_type *alloc) {
  992|   711k|    next_generation();
  993|  2.21M|    for (slot_type *s = slot(i), *end = slot(i + n); s != end; ++s) {
  ------------------
  |  Branch (993:54): [True: 1.50M, False: 711k]
  ------------------
  994|  1.50M|      params_type::destroy(alloc, s);
  995|  1.50M|      absl::container_internal::SanitizerPoisonObject(s);
  996|  1.50M|    }
  997|   711k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE15next_generationEv:
  743|  6.02M|  void next_generation() {
  744|  6.02M|    if (BtreeGenerationsEnabled()) ++*get_root_generation();
  ------------------
  |  Branch (744:9): [Folded, False: 6.02M]
  ------------------
  745|  6.02M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE7is_rootEv:
  718|   606k|  bool is_root() const { return parent()->is_leaf(); }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE4slotEm:
  666|  18.2M|  slot_type *slot(size_type i) { return &GetField<3>()[i]; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm3EEEPNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  653|  18.2M|  inline typename layout_type::template ElementType<N> *GetField() {
  654|       |    // We assert that we don't read from values that aren't there.
  655|       |    assert(N < 4 || is_internal());
  656|  18.2M|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  657|  18.2M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE5startEv:
  688|  18.2M|  field_type start() const {
  689|       |    // TODO(ezb): when floating storage is implemented, return GetField<2>()[1];
  690|       |    assert(GetField<2>()[1] == 0);
  691|  18.2M|    return 0;
  692|  18.2M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE5countEv:
  698|  5.52M|  field_type count() const {
  699|       |    assert(finish() >= start());
  700|  5.52M|    return finish() - start();
  701|  5.52M|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE10deallocateEmPS5_PNSt3__19allocatorImEE:
  970|   696k|                         allocator_type *alloc) {
  971|   696k|    absl::container_internal::SanitizerUnpoisonMemoryRegion(node, size);
  972|   696k|    absl::container_internal::Deallocate<Alignment()>(alloc, node, size);
  973|   696k|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE9max_countEv:
  702|  3.15M|  field_type max_count() const {
  703|       |    // Internal nodes have max_count==kInternalNodeMaxCount.
  704|       |    // Leaf nodes have max_count in [1, kNodeSlots].
  705|  3.15M|    const field_type max_count = GetField<2>()[3];
  706|  3.15M|    return max_count == field_type{kInternalNodeMaxCount}
  ------------------
  |  Branch (706:12): [True: 0, False: 3.15M]
  ------------------
  707|  3.15M|               ? field_type{kNodeSlots}
  708|  3.15M|               : max_count;
  709|  3.15M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE6parentEv:
  714|  8.15M|  btree_node *parent() const { return *GetField<0>(); }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm0EEEPKNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  659|  8.15M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  660|       |    assert(N < 4 || is_internal());
  661|  8.15M|    return InternalLayout().template Pointer<N>(
  662|  8.15M|        reinterpret_cast<const char *>(this));
  663|  8.15M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE11is_internalEv:
  682|  6.28M|  bool is_internal() const { return !is_leaf(); }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE11start_childEv:
  756|  12.3k|  btree_node *start_child() const { return child(start()); }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8positionEv:
  685|  5.26M|  field_type position() const { return GetField<2>()[0]; }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE5childEh:
  755|  2.22M|  btree_node *child(field_type i) const { return GetField<4>()[i]; }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm4EEEPKNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  659|  2.22M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  660|       |    assert(N < 4 || is_internal());
  661|  2.22M|    return InternalLayout().template Pointer<N>(
  662|  2.22M|        reinterpret_cast<const char *>(this));
  663|  2.22M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE6finishEv:
  695|  41.3M|  field_type finish() const { return GetField<2>()[2]; }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE4rootEv:
 1677|  4.47M|  node_type *root() { return root_; }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE17mutable_allocatorEv:
 1694|  5.61M|  allocator_type *mutable_allocator() noexcept {
 1695|  5.61M|    return &rightmost_.template get<1>();
 1696|  5.61M|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE12mutable_rootEv:
 1679|  1.09M|  node_type *&mutable_root() noexcept { return root_; }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE17mutable_rightmostEv:
 1682|  1.13M|  node_type *&mutable_rightmost() noexcept {
 1683|  1.13M|    return rightmost_.template get<2>();
 1684|  1.13M|  }
_ZN4absl12lts_2026010718container_internal19key_compare_adapterINSt3__14lessImEEmE15checked_compareC2ES5_:
  228|   359k|    checked_compare(Compare cmp) : Base(std::move(cmp)) {}  // NOLINT
_ZN4absl12lts_2026010718container_internal20checked_compare_baseINSt3__14lessImEELb1EEC2ES5_:
  175|   359k|  explicit checked_compare_base(Compare c) : Compare(std::move(c)) {}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEEC2ERKNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareERKNS7_9allocatorImEE:
 1420|   359k|      : root_(EmptyNode()), rightmost_(comp, alloc, EmptyNode()), size_(0) {}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEED2Ev:
 1443|  1.81k|  ~btree() {
 1444|       |    // Put static_asserts in destructor to avoid triggering them before the type
 1445|       |    // is complete.
 1446|  1.81k|    static_assert(static_assert_validation(), "This call must be elided.");
 1447|  1.81k|    clear();
 1448|  1.81k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE5beginEv:
 1454|  2.69M|  iterator begin() { return iterator(leftmost()); }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE8leftmostEv:
 1690|  2.69M|  node_type *leftmost() { return root()->parent(); }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EC2EPS6_:
 1138|  5.15M|  explicit btree_iterator(Node *n) : btree_iterator(n, n->start()) {}
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EC2EPS6_i:
 1140|  12.5M|      : btree_iterator_generation_info(n != nullptr ? n->generation()
  ------------------
  |  Branch (1140:40): [True: 12.5M, False: 0]
  ------------------
 1141|  12.5M|                                                    : ~uint32_t{}),
 1142|  12.5M|        node_(n),
 1143|  12.5M|        position_(p) {}
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE10generationEv:
  734|  12.8M|  uint32_t generation() const {
  735|  12.8M|    return BtreeGenerationsEnabled() ? *get_root_generation() : 0;
  ------------------
  |  Branch (735:12): [Folded, False: 12.8M]
  ------------------
  736|  12.8M|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE3endEv:
 1456|  7.16M|  iterator end() { return iterator(rightmost(), rightmost()->finish()); }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE9rightmostEv:
 1680|  14.3M|  node_type *rightmost() { return rightmost_.template get<2>(); }
_ZNK4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EneERKSA_:
 1164|  8.12M|  bool operator!=(const iterator &other) const {
 1165|  8.12M|    return !Equals(other);
 1166|  8.12M|  }
_ZNK4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E6EqualsENS2_IKS6_S8_S9_EE:
 1264|  8.12M|  bool Equals(const const_iterator other) const {
 1265|  8.12M|    ABSL_HARDENING_ASSERT(((node_ == nullptr && other.node_ == nullptr) ||
  ------------------
  |  |  140|  8.12M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  8.12M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 8.12M]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1266|  8.12M|                           (node_ != nullptr && other.node_ != nullptr)) &&
 1267|  8.12M|                          "Comparing default-constructed iterator with "
 1268|  8.12M|                          "non-default-constructed iterator.");
 1269|       |    // Note: we use assert instead of ABSL_HARDENING_ASSERT here because this
 1270|       |    // changes the complexity of Equals from O(1) to O(log(N) + log(M)) where
 1271|       |    // N/M are sizes of the containers containing node_/other.node_.
 1272|  8.12M|    assert(AreNodesFromSameContainer(node_, other.node_) &&
 1273|  8.12M|           "Comparing iterators from different containers.");
 1274|  8.12M|    assert_valid_generation(node_);
 1275|  8.12M|    other.assert_valid_generation(other.node_);
 1276|  8.12M|    return node_ == other.node_ && position_ == other.position_;
  ------------------
  |  Branch (1276:12): [True: 5.18M, False: 2.93M]
  |  Branch (1276:36): [True: 2.69M, False: 2.49M]
  ------------------
 1277|  8.12M|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorIKNS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS8_EC2IS6_S9_SA_TnNSt3__19enable_ifIXaasr3std7is_sameINS2_IT_T0_T1_EENS2_IS6_S9_SA_EEEE5valueL_ZNSD_17integral_constantIbLb1EE5valueEEEiE4typeELi0EEESI_:
 1154|  8.12M|      : btree_iterator_generation_info(other),
 1155|  8.12M|        node_(other.node_),
 1156|  8.12M|        position_(other.position_) {}
_ZNK4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EdeEv:
 1202|  5.43M|  reference operator*() const {
 1203|  5.43M|    ABSL_HARDENING_ASSERT(node_ != nullptr);
  ------------------
  |  |  140|  5.43M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  5.43M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 5.43M]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1204|  5.43M|    assert_valid_generation(node_);
 1205|  5.43M|    ABSL_HARDENING_ASSERT(position_ >= node_->start());
  ------------------
  |  |  140|  5.43M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  5.43M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 5.43M]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1206|  5.43M|    if (position_ >= node_->finish()) {
  ------------------
  |  Branch (1206:9): [True: 0, False: 5.43M]
  ------------------
 1207|      0|      ABSL_HARDENING_ASSERT(!IsEndIterator() && "Dereferencing end() iterator");
  ------------------
  |  |  140|      0|#define ABSL_HARDENING_ASSERT(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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1208|      0|      ABSL_HARDENING_ASSERT(position_ < node_->finish());
  ------------------
  |  |  140|      0|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|      0|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 0]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1209|      0|    }
 1210|  5.43M|    return node_->value(static_cast<field_type>(position_));
 1211|  5.43M|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE5valueEm:
  749|  5.43M|  reference value(size_type i) { return params_type::element(slot(i)); }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE5eraseENS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPS9_EE:
 2535|   981k|auto btree<P>::erase(iterator iter) -> iterator {
 2536|   981k|  iter.node_->value_destroy(static_cast<field_type>(iter.position_),
 2537|   981k|                            mutable_allocator());
 2538|   981k|  iter.update_generation();
 2539|       |
 2540|   981k|  const bool internal_delete = iter.node_->is_internal();
 2541|   981k|  if (internal_delete) {
  ------------------
  |  Branch (2541:7): [True: 7.00k, False: 974k]
  ------------------
 2542|       |    // Deletion of a value on an internal node. First, transfer the largest
 2543|       |    // value from our left child here, then erase/rebalance from that position.
 2544|       |    // We can get to the largest value from our left child by decrementing iter.
 2545|  7.00k|    iterator internal_iter(iter);
 2546|  7.00k|    --iter;
 2547|  7.00k|    assert(iter.node_->is_leaf());
 2548|  7.00k|    internal_iter.node_->transfer(
 2549|  7.00k|        static_cast<size_type>(internal_iter.position_),
 2550|  7.00k|        static_cast<size_type>(iter.position_), iter.node_,
 2551|  7.00k|        mutable_allocator());
 2552|   974k|  } else {
 2553|       |    // Shift values after erased position in leaf. In the internal case, we
 2554|       |    // don't need to do this because the leaf position is the end of the node.
 2555|   974k|    const field_type transfer_from =
 2556|   974k|        static_cast<field_type>(iter.position_ + 1);
 2557|   974k|    const field_type num_to_transfer = iter.node_->finish() - transfer_from;
 2558|   974k|    iter.node_->transfer_n(num_to_transfer,
 2559|   974k|                           static_cast<size_type>(iter.position_),
 2560|   974k|                           transfer_from, iter.node_, mutable_allocator());
 2561|   974k|  }
 2562|       |  // Update node finish and container size.
 2563|   981k|  iter.node_->set_finish(iter.node_->finish() - 1);
 2564|   981k|  --size_;
 2565|       |
 2566|       |  // We want to return the next value after the one we just erased. If we
 2567|       |  // erased from an internal node (internal_delete == true), then the next
 2568|       |  // value is ++(++iter). If we erased from a leaf node (internal_delete ==
 2569|       |  // false) then the next value is ++iter. Note that ++iter may point to an
 2570|       |  // internal node and the value in the internal node may move to a leaf node
 2571|       |  // (iter.node_) when rebalancing is performed at the leaf level.
 2572|       |
 2573|   981k|  iterator res = rebalance_after_delete(iter);
 2574|       |
 2575|       |  // If we erased from an internal node, advance the iterator.
 2576|   981k|  if (internal_delete) {
  ------------------
  |  Branch (2576:7): [True: 7.00k, False: 974k]
  ------------------
 2577|  7.00k|    ++res;
 2578|  7.00k|  }
 2579|   981k|  return res;
 2580|   981k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE13value_destroyEhPNSt3__19allocatorImEE:
  985|  1.03M|  void value_destroy(const field_type i, allocator_type *alloc) {
  986|  1.03M|    next_generation();
  987|  1.03M|    params_type::destroy(alloc, slot(i));
  988|  1.03M|    absl::container_internal::SanitizerPoisonObject(slot(i));
  989|  1.03M|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E17update_generationEv:
 1322|  6.81M|  void update_generation() {
 1323|  6.81M|    btree_iterator_generation_info::update_generation(node_);
 1324|  6.81M|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EmmEv:
 1218|  7.00k|  btree_iterator &operator--() {
 1219|  7.00k|    decrement();
 1220|  7.00k|    return *this;
 1221|  7.00k|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E9decrementEv:
 1305|  7.00k|  void decrement() {
 1306|  7.00k|    assert_valid_generation(node_);
 1307|  7.00k|    if (node_->is_leaf() && --position_ >= node_->start()) {
  ------------------
  |  Branch (1307:9): [True: 0, False: 7.00k]
  |  Branch (1307:29): [True: 0, False: 0]
  ------------------
 1308|      0|      return;
 1309|      0|    }
 1310|  7.00k|    decrement_slow();
 1311|  7.00k|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E14decrement_slowEv:
 2179|  7.00k|void btree_iterator<N, R, P>::decrement_slow() {
 2180|  7.00k|  N* node = node_;
 2181|  7.00k|  int position = position_;
 2182|  7.00k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2182:7): [True: 0, False: 7.00k]
  ------------------
 2183|      0|    assert(position <= -1);
 2184|      0|    while (position < node->start() && !node->is_root()) {
  ------------------
  |  Branch (2184:12): [True: 0, False: 0]
  |  Branch (2184:40): [True: 0, False: 0]
  ------------------
 2185|      0|      assert(node->parent()->child(node->position()) == node);
 2186|      0|      position = node->position() - 1;
 2187|      0|      node = node->parent();
 2188|      0|    }
 2189|       |    // TODO(ezb): assert we aren't decrementing begin() instead of handling.
 2190|      0|    if (position < node->start()) {
  ------------------
  |  Branch (2190:9): [True: 0, False: 0]
  ------------------
 2191|      0|      return;
 2192|      0|    }
 2193|  7.00k|  } else {
 2194|  7.00k|    assert(position >= node->start());
 2195|  7.00k|    node = node->child(static_cast<field_type>(position));
 2196|  7.02k|    while (node->is_internal()) {
  ------------------
  |  Branch (2196:12): [True: 22, False: 7.00k]
  ------------------
 2197|     22|      node = node->child(node->finish());
 2198|     22|    }
 2199|  7.00k|    position = node->finish() - 1;
 2200|  7.00k|  }
 2201|  7.00k|  *this = {node, position};
 2202|  7.00k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8transferEmmPS5_PNSt3__19allocatorImEE:
 1007|   185k|                btree_node *src_node, allocator_type *alloc) {
 1008|   185k|    next_generation();
 1009|   185k|    transfer(slot(dest_i), src_node->slot(src_i), alloc);
 1010|   185k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8transferEPmS6_PNSt3__19allocatorImEE:
  999|  13.2M|  static void transfer(slot_type *dest, slot_type *src, allocator_type *alloc) {
 1000|  13.2M|    absl::container_internal::SanitizerUnpoisonObject(dest);
 1001|  13.2M|    params_type::transfer(alloc, dest, src);
 1002|  13.2M|    absl::container_internal::SanitizerPoisonObject(src);
 1003|  13.2M|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE10transfer_nEmmmPS5_PNSt3__19allocatorImEE:
 1016|  1.55M|                  allocator_type *alloc) {
 1017|  1.55M|    next_generation();
 1018|  1.55M|    for (slot_type *src = src_node->slot(src_i), *end = src + n,
 1019|  1.55M|                   *dest = slot(dest_i);
 1020|  14.5M|         src != end; ++src, ++dest) {
  ------------------
  |  Branch (1020:10): [True: 13.0M, False: 1.55M]
  ------------------
 1021|  13.0M|      transfer(dest, src, alloc);
 1022|  13.0M|    }
 1023|  1.55M|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE10set_finishEh:
  672|  5.16M|  void set_finish(field_type v) { GetField<2>()[2] = v; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm2EEEPNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  653|  7.48M|  inline typename layout_type::template ElementType<N> *GetField() {
  654|       |    // We assert that we don't read from values that aren't there.
  655|       |    assert(N < 4 || is_internal());
  656|  7.48M|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  657|  7.48M|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE22rebalance_after_deleteENS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPS9_EE:
 2583|   981k|auto btree<P>::rebalance_after_delete(iterator iter) -> iterator {
 2584|       |  // Merge/rebalance as we walk back up the tree.
 2585|   981k|  iterator res(iter);
 2586|   981k|  bool first_iteration = true;
 2587|  1.00M|  for (;;) {
 2588|  1.00M|    if (iter.node_ == root()) {
  ------------------
  |  Branch (2588:9): [True: 433k, False: 569k]
  ------------------
 2589|   433k|      try_shrink();
 2590|   433k|      if (empty()) {
  ------------------
  |  Branch (2590:11): [True: 79.7k, False: 353k]
  ------------------
 2591|  79.7k|        return end();
 2592|  79.7k|      }
 2593|   353k|      break;
 2594|   433k|    }
 2595|   569k|    if (iter.node_->count() >= kMinNodeValues) {
  ------------------
  |  Branch (2595:9): [True: 462k, False: 107k]
  ------------------
 2596|   462k|      break;
 2597|   462k|    }
 2598|   107k|    bool merged = try_merge_or_rebalance(&iter);
 2599|       |    // On the first iteration, we should update `res` with `iter` because `res`
 2600|       |    // may have been invalidated.
 2601|   107k|    if (first_iteration) {
  ------------------
  |  Branch (2601:9): [True: 105k, False: 1.40k]
  ------------------
 2602|   105k|      res = iter;
 2603|   105k|      first_iteration = false;
 2604|   105k|    }
 2605|   107k|    if (!merged) {
  ------------------
  |  Branch (2605:9): [True: 86.4k, False: 20.6k]
  ------------------
 2606|  86.4k|      break;
 2607|  86.4k|    }
 2608|  20.6k|    iter.position_ = iter.node_->position();
 2609|  20.6k|    iter.node_ = iter.node_->parent();
 2610|  20.6k|  }
 2611|   902k|  res.update_generation();
 2612|       |
 2613|       |  // Adjust our return value. If we're pointing at the end of a node, advance
 2614|       |  // the iterator.
 2615|   902k|  if (res.position_ == res.node_->finish()) {
  ------------------
  |  Branch (2615:7): [True: 51.1k, False: 850k]
  ------------------
 2616|  51.1k|    res.position_ = res.node_->finish() - 1;
 2617|  51.1k|    ++res;
 2618|  51.1k|  }
 2619|       |
 2620|   902k|  return res;
 2621|   981k|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE10try_shrinkEv:
 2879|   433k|void btree<P>::try_shrink() {
 2880|   433k|  node_type *orig_root = root();
 2881|   433k|  if (orig_root->count() > 0) {
  ------------------
  |  Branch (2881:7): [True: 347k, False: 85.3k]
  ------------------
 2882|   347k|    return;
 2883|   347k|  }
 2884|       |  // Deleted the last item on the root node, shrink the height of the tree.
 2885|  85.3k|  if (orig_root->is_leaf()) {
  ------------------
  |  Branch (2885:7): [True: 79.7k, False: 5.66k]
  ------------------
 2886|  79.7k|    assert(size() == 0);
 2887|  79.7k|    mutable_root() = mutable_rightmost() = EmptyNode();
 2888|  79.7k|  } else {
 2889|  5.66k|    node_type *child = orig_root->start_child();
 2890|  5.66k|    child->make_root();
 2891|  5.66k|    mutable_root() = child;
 2892|  5.66k|  }
 2893|  85.3k|  node_type::clear_and_delete(orig_root, mutable_allocator());
 2894|  85.3k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE9make_rootEv:
  719|  5.66k|  void make_root() {
  720|       |    assert(parent()->is_root());
  721|  5.66k|    set_generation(parent()->generation());
  722|  5.66k|    set_parent(parent()->parent());
  723|  5.66k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE14set_generationEj:
  739|  1.02M|  void set_generation(uint32_t generation) {
  740|  1.02M|    if (BtreeGenerationsEnabled()) GetField<1>()[0] = generation;
  ------------------
  |  Branch (740:9): [Folded, False: 1.02M]
  ------------------
  741|  1.02M|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE10set_parentEPS5_:
  664|   730k|  void set_parent(btree_node *p) { *GetField<0>() = p; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm0EEEPNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  653|   730k|  inline typename layout_type::template ElementType<N> *GetField() {
  654|       |    // We assert that we don't read from values that aren't there.
  655|       |    assert(N < 4 || is_internal());
  656|   730k|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  657|   730k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE22try_merge_or_rebalanceEPNS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPS9_EE:
 2825|   107k|bool btree<P>::try_merge_or_rebalance(iterator *iter) {
 2826|   107k|  node_type *parent = iter->node_->parent();
 2827|   107k|  if (iter->node_->position() > parent->start()) {
  ------------------
  |  Branch (2827:7): [True: 28.2k, False: 78.8k]
  ------------------
 2828|       |    // Try merging with our left sibling.
 2829|  28.2k|    node_type *left = parent->child(iter->node_->position() - 1);
 2830|  28.2k|    assert(left->max_count() == kNodeSlots);
 2831|  28.2k|    if (1U + left->count() + iter->node_->count() <= kNodeSlots) {
  ------------------
  |  Branch (2831:9): [True: 4.02k, False: 24.2k]
  ------------------
 2832|  4.02k|      iter->position_ += 1 + left->count();
 2833|  4.02k|      merge_nodes(left, iter->node_);
 2834|  4.02k|      iter->node_ = left;
 2835|  4.02k|      return true;
 2836|  4.02k|    }
 2837|  28.2k|  }
 2838|   103k|  if (iter->node_->position() < parent->finish()) {
  ------------------
  |  Branch (2838:7): [True: 98.5k, False: 4.55k]
  ------------------
 2839|       |    // Try merging with our right sibling.
 2840|  98.5k|    node_type *right = parent->child(iter->node_->position() + 1);
 2841|  98.5k|    assert(right->max_count() == kNodeSlots);
 2842|  98.5k|    if (1U + iter->node_->count() + right->count() <= kNodeSlots) {
  ------------------
  |  Branch (2842:9): [True: 16.6k, False: 81.8k]
  ------------------
 2843|  16.6k|      merge_nodes(iter->node_, right);
 2844|  16.6k|      return true;
 2845|  16.6k|    }
 2846|       |    // Try rebalancing with our right sibling. We don't perform rebalancing if
 2847|       |    // we deleted the first element from iter->node_ and the node is not
 2848|       |    // empty. This is a small optimization for the common pattern of deleting
 2849|       |    // from the front of the tree.
 2850|  81.8k|    if (right->count() > kMinNodeValues &&
  ------------------
  |  Branch (2850:9): [True: 81.8k, False: 0]
  ------------------
 2851|  81.8k|        (iter->node_->count() == 0 || iter->position_ > iter->node_->start())) {
  ------------------
  |  Branch (2851:10): [True: 1.96k, False: 79.8k]
  |  Branch (2851:39): [True: 44.1k, False: 35.7k]
  ------------------
 2852|  46.0k|      field_type to_move = (right->count() - iter->node_->count()) / 2;
 2853|  46.0k|      to_move =
 2854|  46.0k|          (std::min)(to_move, static_cast<field_type>(right->count() - 1));
 2855|  46.0k|      iter->node_->rebalance_right_to_left(to_move, right, mutable_allocator());
 2856|  46.0k|      return false;
 2857|  46.0k|    }
 2858|  81.8k|  }
 2859|  40.3k|  if (iter->node_->position() > parent->start()) {
  ------------------
  |  Branch (2859:7): [True: 4.90k, False: 35.4k]
  ------------------
 2860|       |    // Try rebalancing with our left sibling. We don't perform rebalancing if
 2861|       |    // we deleted the last element from iter->node_ and the node is not
 2862|       |    // empty. This is a small optimization for the common pattern of deleting
 2863|       |    // from the back of the tree.
 2864|  4.90k|    node_type *left = parent->child(iter->node_->position() - 1);
 2865|  4.90k|    if (left->count() > kMinNodeValues &&
  ------------------
  |  Branch (2865:9): [True: 4.90k, False: 0]
  ------------------
 2866|  4.90k|        (iter->node_->count() == 0 ||
  ------------------
  |  Branch (2866:10): [True: 2, False: 4.89k]
  ------------------
 2867|  4.89k|         iter->position_ < iter->node_->finish())) {
  ------------------
  |  Branch (2867:10): [True: 4.57k, False: 328]
  ------------------
 2868|  4.57k|      field_type to_move = (left->count() - iter->node_->count()) / 2;
 2869|  4.57k|      to_move = (std::min)(to_move, static_cast<field_type>(left->count() - 1));
 2870|  4.57k|      left->rebalance_left_to_right(to_move, iter->node_, mutable_allocator());
 2871|  4.57k|      iter->position_ += to_move;
 2872|  4.57k|      return false;
 2873|  4.57k|    }
 2874|  4.90k|  }
 2875|  35.7k|  return false;
 2876|  40.3k|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE11merge_nodesEPNS1_10btree_nodeIS4_EES8_:
 2819|  20.6k|void btree<P>::merge_nodes(node_type *left, node_type *right) {
 2820|  20.6k|  left->merge(right, mutable_allocator());
 2821|  20.6k|  if (rightmost() == right) mutable_rightmost() = left;
  ------------------
  |  Branch (2821:7): [True: 7.01k, False: 13.6k]
  ------------------
 2822|  20.6k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE5mergeEPS5_PNSt3__19allocatorImEE:
 1998|  20.6k|void btree_node<P>::merge(btree_node *src, allocator_type *alloc) {
 1999|  20.6k|  assert(parent() == src->parent());
 2000|  20.6k|  assert(position() + 1 == src->position());
 2001|       |
 2002|       |  // Move the delimiting value to the left node.
 2003|  20.6k|  value_init(finish(), alloc, parent()->slot(position()));
 2004|       |
 2005|       |  // Move the values from the right to the left node.
 2006|  20.6k|  transfer_n(src->count(), finish() + 1, src->start(), src, alloc);
 2007|       |
 2008|  20.6k|  if (is_internal()) {
  ------------------
  |  Branch (2008:7): [True: 212, False: 20.4k]
  ------------------
 2009|       |    // Move the child pointers from the right to the left node.
 2010|  3.39k|    for (field_type i = src->start(), j = finish() + 1; i <= src->finish();
  ------------------
  |  Branch (2010:57): [True: 3.18k, False: 212]
  ------------------
 2011|  3.18k|         ++i, ++j) {
 2012|  3.18k|      init_child(j, src->child(i));
 2013|  3.18k|      src->clear_child(i);
 2014|  3.18k|    }
 2015|    212|  }
 2016|       |
 2017|       |  // Fixup `finish` on the src and dest nodes.
 2018|  20.6k|  set_finish(start() + 1 + count() + src->count());
 2019|  20.6k|  src->set_finish(src->start());
 2020|       |
 2021|       |  // Remove the value on the parent node and delete the src node.
 2022|  20.6k|  parent()->remove_values(position(), /*to_erase=*/1, alloc);
 2023|  20.6k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE10value_initIJPmEEEvhPNSt3__19allocatorImEEDpOT_:
  980|  70.2k|  void value_init(const field_type i, allocator_type *alloc, Args &&...args) {
  981|  70.2k|    next_generation();
  982|  70.2k|    absl::container_internal::SanitizerUnpoisonObject(slot(i));
  983|  70.2k|    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
  984|  70.2k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE10init_childEhPS5_:
  769|  28.5k|  void init_child(field_type i, btree_node *c) {
  770|  28.5k|    set_child(i, c);
  771|  28.5k|    c->set_parent(this);
  772|  28.5k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE9set_childEhPS5_:
  765|   172k|  void set_child(field_type i, btree_node *c) {
  766|   172k|    set_child_noupdate_position(i, c);
  767|   172k|    c->set_position(i);
  768|   172k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE27set_child_noupdate_positionEhPS5_:
  761|   222k|  void set_child_noupdate_position(field_type i, btree_node *c) {
  762|   222k|    absl::container_internal::SanitizerUnpoisonObject(&mutable_child(i));
  763|   222k|    mutable_child(i) = c;
  764|   222k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE13mutable_childEh:
  757|   617k|  btree_node *&mutable_child(field_type i) { return GetField<4>()[i]; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm4EEEPNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  653|   617k|  inline typename layout_type::template ElementType<N> *GetField() {
  654|       |    // We assert that we don't read from values that aren't there.
  655|       |    assert(N < 4 || is_internal());
  656|   617k|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  657|   617k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE12set_positionEh:
  670|   869k|  void set_position(field_type v) { GetField<2>()[0] = v; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE11clear_childEh:
  758|   160k|  void clear_child(field_type i) {
  759|   160k|    absl::container_internal::SanitizerPoisonObject(&mutable_child(i));
  760|   160k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE13remove_valuesEhhPNSt3__19allocatorImEE:
 1848|  20.6k|                                         allocator_type *alloc) {
 1849|       |  // Transfer values after the removed range into their new places.
 1850|  20.6k|  value_destroy_n(i, to_erase, alloc);
 1851|  20.6k|  const field_type orig_finish = finish();
 1852|  20.6k|  const field_type src_i = i + to_erase;
 1853|  20.6k|  transfer_n(orig_finish - src_i, i, src_i, this, alloc);
 1854|       |
 1855|  20.6k|  if (is_internal()) {
  ------------------
  |  Branch (1855:7): [True: 20.6k, False: 0]
  ------------------
 1856|       |    // Delete all children between begin and end.
 1857|  41.3k|    for (field_type j = 0; j < to_erase; ++j) {
  ------------------
  |  Branch (1857:28): [True: 20.6k, False: 20.6k]
  ------------------
 1858|  20.6k|      clear_and_delete(child(i + j + 1), alloc);
 1859|  20.6k|    }
 1860|       |    // Rotate children after end into new positions.
 1861|   165k|    for (field_type j = i + to_erase + 1; j <= orig_finish; ++j) {
  ------------------
  |  Branch (1861:43): [True: 144k, False: 20.6k]
  ------------------
 1862|   144k|      set_child(j - to_erase, child(j));
 1863|   144k|      clear_child(j);
 1864|   144k|    }
 1865|  20.6k|  }
 1866|  20.6k|  set_finish(orig_finish - to_erase);
 1867|  20.6k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE23rebalance_right_to_leftEhPS5_PNSt3__19allocatorImEE:
 1872|  84.7k|                                            allocator_type *alloc) {
 1873|  84.7k|  assert(parent() == right->parent());
 1874|  84.7k|  assert(position() + 1 == right->position());
 1875|  84.7k|  assert(right->count() >= count());
 1876|  84.7k|  assert(to_move >= 1);
 1877|  84.7k|  assert(to_move <= right->count());
 1878|       |
 1879|       |  // 1) Move the delimiting value in the parent to the left node.
 1880|  84.7k|  transfer(finish(), position(), parent(), alloc);
 1881|       |
 1882|       |  // 2) Move the (to_move - 1) values from the right node to the left node.
 1883|  84.7k|  transfer_n(to_move - 1, finish() + 1, right->start(), right, alloc);
 1884|       |
 1885|       |  // 3) Move the new delimiting value to the parent from the right node.
 1886|  84.7k|  parent()->transfer(position(), right->start() + to_move - 1, right, alloc);
 1887|       |
 1888|       |  // 4) Shift the values in the right node to their correct positions.
 1889|  84.7k|  right->transfer_n(right->count() - to_move, right->start(),
 1890|  84.7k|                    right->start() + to_move, right, alloc);
 1891|       |
 1892|  84.7k|  if (is_internal()) {
  ------------------
  |  Branch (1892:7): [True: 468, False: 84.2k]
  ------------------
 1893|       |    // Move the child pointers from the right to the left node.
 1894|  1.75k|    for (field_type i = 0; i < to_move; ++i) {
  ------------------
  |  Branch (1894:28): [True: 1.28k, False: 468]
  ------------------
 1895|  1.28k|      init_child(finish() + i + 1, right->child(i));
 1896|  1.28k|    }
 1897|  12.3k|    for (field_type i = right->start(); i <= right->finish() - to_move; ++i) {
  ------------------
  |  Branch (1897:41): [True: 11.8k, False: 468]
  ------------------
 1898|  11.8k|      assert(i + to_move <= right->max_count());
 1899|  11.8k|      right->init_child(i, right->child(i + to_move));
 1900|  11.8k|      right->clear_child(i + to_move);
 1901|  11.8k|    }
 1902|    468|  }
 1903|       |
 1904|       |  // Fixup `finish` on the left and right nodes.
 1905|  84.7k|  set_finish(finish() + to_move);
 1906|  84.7k|  right->set_finish(right->finish() - to_move);
 1907|  84.7k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE23rebalance_left_to_rightEhPS5_PNSt3__19allocatorImEE:
 1912|  4.57k|                                            allocator_type *alloc) {
 1913|  4.57k|  assert(parent() == right->parent());
 1914|  4.57k|  assert(position() + 1 == right->position());
 1915|  4.57k|  assert(count() >= right->count());
 1916|  4.57k|  assert(to_move >= 1);
 1917|  4.57k|  assert(to_move <= count());
 1918|       |
 1919|       |  // Values in the right node are shifted to the right to make room for the
 1920|       |  // new to_move values. Then, the delimiting value in the parent and the
 1921|       |  // other (to_move - 1) values in the left node are moved into the right node.
 1922|       |  // Lastly, a new delimiting value is moved from the left node into the
 1923|       |  // parent, and the remaining empty left node entries are destroyed.
 1924|       |
 1925|       |  // 1) Shift existing values in the right node to their correct positions.
 1926|  4.57k|  right->transfer_n_backward(right->count(), right->start() + to_move,
 1927|  4.57k|                             right->start(), right, alloc);
 1928|       |
 1929|       |  // 2) Move the delimiting value in the parent to the right node.
 1930|  4.57k|  right->transfer(right->start() + to_move - 1, position(), parent(), alloc);
 1931|       |
 1932|       |  // 3) Move the (to_move - 1) values from the left node to the right node.
 1933|  4.57k|  right->transfer_n(to_move - 1, right->start(), finish() - (to_move - 1), this,
 1934|  4.57k|                    alloc);
 1935|       |
 1936|       |  // 4) Move the new delimiting value to the parent from the left node.
 1937|  4.57k|  parent()->transfer(position(), finish() - to_move, this, alloc);
 1938|       |
 1939|  4.57k|  if (is_internal()) {
  ------------------
  |  Branch (1939:7): [True: 31, False: 4.54k]
  ------------------
 1940|       |    // Move the child pointers from the left to the right node.
 1941|    470|    for (field_type i = right->finish() + 1; i > right->start(); --i) {
  ------------------
  |  Branch (1941:46): [True: 439, False: 31]
  ------------------
 1942|    439|      right->init_child(i - 1 + to_move, right->child(i - 1));
 1943|    439|      right->clear_child(i - 1);
 1944|    439|    }
 1945|     98|    for (field_type i = 1; i <= to_move; ++i) {
  ------------------
  |  Branch (1945:28): [True: 67, False: 31]
  ------------------
 1946|     67|      right->init_child(i - 1, child(finish() - to_move + i));
 1947|     67|      clear_child(finish() - to_move + i);
 1948|     67|    }
 1949|     31|  }
 1950|       |
 1951|       |  // Fixup the counts on the left and right nodes.
 1952|  4.57k|  set_finish(finish() - to_move);
 1953|  4.57k|  right->set_finish(right->finish() + to_move);
 1954|  4.57k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE19transfer_n_backwardEmmmPS5_PNSt3__19allocatorImEE:
 1029|  4.57k|                           allocator_type *alloc) {
 1030|  4.57k|    next_generation();
 1031|  4.57k|    for (slot_type *src = src_node->slot(src_i + n), *end = src - n,
 1032|  4.57k|                   *dest = slot(dest_i + n);
 1033|  62.9k|         src != end; --src, --dest) {
  ------------------
  |  Branch (1033:10): [True: 58.3k, False: 4.57k]
  ------------------
 1034|       |      // If we modified the loop index calculations above to avoid the -1s here,
 1035|       |      // it would result in UB in the computation of `end` (and possibly `src`
 1036|       |      // as well, if n == 0), since slot() is effectively an array index and it
 1037|       |      // is UB to compute the address of any out-of-bounds array element except
 1038|       |      // for one-past-the-end.
 1039|  58.3k|      transfer(dest - 1, src - 1, alloc);
 1040|  58.3k|    }
 1041|  4.57k|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EppEv:
 1214|  4.50M|  btree_iterator &operator++() {
 1215|  4.50M|    increment();
 1216|  4.50M|    return *this;
 1217|  4.50M|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E9incrementEv:
 1295|  4.50M|  void increment() {
 1296|  4.50M|    assert_valid_generation(node_);
 1297|  4.50M|    if (node_->is_leaf() && ++position_ < node_->finish()) {
  ------------------
  |  Branch (1297:9): [True: 4.42M, False: 84.2k]
  |  Branch (1297:29): [True: 3.84M, False: 580k]
  ------------------
 1298|  3.84M|      return;
 1299|  3.84M|    }
 1300|   664k|    increment_slow();
 1301|   664k|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E14increment_slowEv:
 2153|   664k|void btree_iterator<N, R, P>::increment_slow() {
 2154|   664k|  N* node = node_;
 2155|   664k|  int position = position_;
 2156|   664k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2156:7): [True: 580k, False: 84.2k]
  ------------------
 2157|   580k|    assert(position >= node->finish());
 2158|   697k|    while (position == node->finish() && !node->is_root()) {
  ------------------
  |  Branch (2158:12): [True: 606k, False: 91.2k]
  |  Branch (2158:42): [True: 117k, False: 489k]
  ------------------
 2159|   117k|      assert(node->parent()->child(node->position()) == node);
 2160|   117k|      position = node->position();
 2161|   117k|      node = node->parent();
 2162|   117k|    }
 2163|       |    // TODO(ezb): assert we aren't incrementing end() instead of handling.
 2164|   580k|    if (position == node->finish()) {
  ------------------
  |  Branch (2164:9): [True: 489k, False: 91.2k]
  ------------------
 2165|   489k|      return;
 2166|   489k|    }
 2167|   580k|  } else {
 2168|  84.2k|    assert(position < node->finish());
 2169|  84.2k|    node = node->child(static_cast<field_type>(position + 1));
 2170|  85.0k|    while (node->is_internal()) {
  ------------------
  |  Branch (2170:12): [True: 852, False: 84.2k]
  ------------------
 2171|    852|      node = node->start_child();
 2172|    852|    }
 2173|  84.2k|    position = node->start();
 2174|  84.2k|  }
 2175|   175k|  *this = {node, position};
 2176|   175k|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13insert_uniqueIS8_JRKS8_EEENSt3__14pairINS1_14btree_iteratorINS1_10btree_nodeIS9_EESD_PSC_EEbEERKT_DpOT0_:
 2374|  2.46M|    -> std::pair<iterator, bool> {
 2375|  2.46M|  if (empty()) {
  ------------------
  |  Branch (2375:7): [True: 1.76k, False: 2.46M]
  ------------------
 2376|  1.76k|    mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
 2377|  1.76k|  }
 2378|       |
 2379|  2.46M|  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
 2380|  2.46M|  iterator iter = res.value;
 2381|       |
 2382|  2.46M|  if (res.HasMatch()) {
  ------------------
  |  Branch (2382:7): [Folded, False: 2.46M]
  ------------------
 2383|      0|    if (res.IsEq()) {
  ------------------
  |  Branch (2383:9): [Folded, False: 0]
  ------------------
 2384|       |      // The key already exists in the tree, do nothing.
 2385|      0|      return {iter, false};
 2386|      0|    }
 2387|  2.46M|  } else {
 2388|  2.46M|    iterator last = internal_last(iter);
 2389|  2.46M|    if (last.node_ && !compare_keys(key, last.key())) {
  ------------------
  |  Branch (2389:9): [True: 2.41M, False: 50.2k]
  |  Branch (2389:23): [True: 2.14M, False: 273k]
  ------------------
 2390|       |      // The key already exists in the tree, do nothing.
 2391|  2.14M|      return {last, false};
 2392|  2.14M|    }
 2393|  2.46M|  }
 2394|   323k|  return {internal_emplace(iter, std::forward<Args>(args)...), true};
 2395|  2.46M|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE18new_leaf_root_nodeEh:
 1720|  18.1k|  node_type *new_leaf_root_node(field_type max_count) {
 1721|  18.1k|    node_type *n = allocate(node_type::LeafSize(max_count));
 1722|  18.1k|    n->init_leaf(/*position=*/0, max_count, /*parent=*/n);
 1723|  18.1k|    return n;
 1724|  18.1k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8allocateEm:
 1703|  33.4k|  node_type *allocate(size_type size) {
 1704|  33.4k|    return reinterpret_cast<node_type *>(
 1705|  33.4k|        absl::container_internal::Allocate<node_type::Alignment()>(
 1706|  33.4k|            mutable_allocator(), size));
 1707|  33.4k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE9init_leafEhhPSA_:
  950|  33.4k|                 btree_node *parent) {
  951|  33.4k|    set_generation(0);
  952|  33.4k|    set_parent(parent);
  953|  33.4k|    set_position(position);
  954|  33.4k|    set_start(0);
  955|  33.4k|    set_finish(0);
  956|  33.4k|    set_max_count(max_count);
  957|  33.4k|    absl::container_internal::SanitizerPoisonMemoryRegion(
  958|  33.4k|        start_slot(), max_count * sizeof(slot_type));
  959|  33.4k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE14set_generationEj:
  739|  50.5k|  void set_generation(uint32_t generation) {
  740|  50.5k|    if (BtreeGenerationsEnabled()) GetField<1>()[0] = generation;
  ------------------
  |  Branch (740:9): [Folded, False: 50.5k]
  ------------------
  741|  50.5k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10set_parentEPSA_:
  664|  42.7k|  void set_parent(btree_node *p) { *GetField<0>() = p; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8GetFieldILm0EEEPNSt3__113tuple_elementIXT_ENSC_5tupleIJPSA_jhS8_SF_EEEE4typeEv:
  653|  42.7k|  inline typename layout_type::template ElementType<N> *GetField() {
  654|       |    // We assert that we don't read from values that aren't there.
  655|       |    assert(N < 4 || is_internal());
  656|  42.7k|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  657|  42.7k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE12set_positionEh:
  670|  90.3k|  void set_position(field_type v) { GetField<2>()[0] = v; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8GetFieldILm2EEEPNSt3__113tuple_elementIXT_ENSC_5tupleIJPSA_jhS8_SF_EEEE4typeEv:
  653|   865k|  inline typename layout_type::template ElementType<N> *GetField() {
  654|       |    // We assert that we don't read from values that aren't there.
  655|       |    assert(N < 4 || is_internal());
  656|   865k|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  657|   865k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE9set_startEh:
  671|  33.4k|  void set_start(field_type v) { GetField<2>()[1] = v; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10set_finishEh:
  672|   693k|  void set_finish(field_type v) { GetField<2>()[2] = v; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13set_max_countEh:
  674|  35.7k|  void set_max_count(field_type v) { GetField<2>()[3] = v; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10start_slotEv:
  667|  33.4k|  slot_type *start_slot() { return slot(start()); }
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE15internal_locateIS8_EENS1_12SearchResultINS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSG_EELb0EEERKT_:
 2994|  2.61M|    -> SearchResult<iterator, is_key_compare_to::value> {
 2995|  2.61M|  iterator iter(const_cast<node_type *>(root()));
 2996|  4.56M|  for (;;) {
 2997|  4.56M|    SearchResult<size_type, is_key_compare_to::value> res =
 2998|  4.56M|        iter.node_->lower_bound(key, key_comp());
 2999|  4.56M|    iter.position_ = static_cast<int>(res.value);
 3000|  4.56M|    if (res.IsEq()) {
  ------------------
  |  Branch (3000:9): [Folded, False: 4.56M]
  ------------------
 3001|      0|      return {iter, MatchKind::kEq};
 3002|      0|    }
 3003|       |    // Note: in the non-key-compare-to case, we don't need to walk all the way
 3004|       |    // down the tree if the keys are equal, but determining equality would
 3005|       |    // require doing an extra comparison on each node on the way down, and we
 3006|       |    // will need to go all the way to the leaf node in the expected case.
 3007|  4.56M|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (3007:9): [True: 2.61M, False: 1.94M]
  ------------------
 3008|  2.61M|      break;
 3009|  2.61M|    }
 3010|  1.94M|    iter.node_ = iter.node_->child(static_cast<field_type>(iter.position_));
 3011|  1.94M|  }
 3012|       |  // Note: in the non-key-compare-to case, the key may actually be equivalent
 3013|       |  // here (and the MatchKind::kNe is ignored).
 3014|  2.61M|  return {iter, MatchKind::kNe};
 3015|  2.61M|}
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE4rootEv:
 1678|  2.61M|  const node_type *root() const { return root_; }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_EC2EPSB_:
 1138|  2.77M|  explicit btree_iterator(Node *n) : btree_iterator(n, n->start()) {}
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_EC2EPSB_i:
 1140|  3.69M|      : btree_iterator_generation_info(n != nullptr ? n->generation()
  ------------------
  |  Branch (1140:40): [True: 3.69M, False: 0]
  ------------------
 1141|  3.69M|                                                    : ~uint32_t{}),
 1142|  3.69M|        node_(n),
 1143|  3.69M|        position_(p) {}
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10generationEv:
  734|  3.76M|  uint32_t generation() const {
  735|  3.76M|    return BtreeGenerationsEnabled() ? *get_root_generation() : 0;
  ------------------
  |  Branch (735:12): [Folded, False: 3.76M]
  ------------------
  736|  3.76M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE11lower_boundIS8_EENS1_12SearchResultImLb0EEERKT_RKNS1_19key_compare_adapterINSt3__14lessIS8_EES8_E15checked_compareE:
  777|  4.56M|      const K &k, const key_compare &comp) const {
  778|  4.56M|    return use_linear_search::value ? linear_search(k, comp)
  ------------------
  |  Branch (778:12): [Folded, False: 4.56M]
  ------------------
  779|  4.56M|                                    : binary_search(k, comp);
  780|  4.56M|  }
_ZNK4absl12lts_2026010718container_internal19key_compare_adapterINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEES9_E15checked_compareclIS9_S9_TnNS3_9enable_ifIXsr3std7is_sameIbNS0_20type_traits_internal9result_ofIFKSA_RKT_RKT0_EE4typeEEE5valueEiE4typeELi0EEEbSK_SN_:
  237|  19.0M|    bool operator()(const T &lhs, const U &rhs) const {
  238|       |      // NOTE: if any of these assertions fail, then the comparator does not
  239|       |      // establish a strict-weak-ordering (see
  240|       |      // https://en.cppreference.com/w/cpp/named_req/Compare).
  241|  19.0M|      assert(is_self_equivalent(lhs));
  242|  19.0M|      assert(is_self_equivalent(rhs));
  243|  19.0M|      const bool lhs_comp_rhs = comp()(lhs, rhs);
  244|       |      assert(!lhs_comp_rhs || !comp()(rhs, lhs));
  245|  19.0M|      return lhs_comp_rhs;
  246|  19.0M|    }
_ZNK4absl12lts_2026010718container_internal20checked_compare_baseINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEELb1EE4compEv:
  176|  19.0M|  const Compare &comp() const { return *this; }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE3keyEm:
  748|  19.0M|  const key_type &key(size_type i) const { return params_type::key(slot(i)); }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE4slotEm:
  669|  19.0M|  const slot_type *slot(size_type i) const { return &GetField<3>()[i]; }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8GetFieldILm3EEEPKNSt3__113tuple_elementIXT_ENSC_5tupleIJPSA_jhS8_SF_EEEE4typeEv:
  659|  19.0M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  660|       |    assert(N < 4 || is_internal());
  661|  19.0M|    return InternalLayout().template Pointer<N>(
  662|  19.0M|        reinterpret_cast<const char *>(this));
  663|  19.0M|  }
_ZN4absl12lts_2026010718container_internal12SearchResultImLb0EEC2Em:
  480|  8.73M|  explicit SearchResult(V v) : value(v) {}
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13binary_searchIS8_NS1_19key_compare_adapterINSt3__14lessIS8_EES8_E15checked_compareEEENS1_12SearchResultImXsr23btree_is_key_compare_toIT0_S8_EE5valueEEERKT_RKSJ_:
  798|  4.56M|  binary_search(const K &k, const Compare &comp) const {
  799|  4.56M|    return binary_search_impl(k, start(), finish(), comp,
  800|  4.56M|                              btree_is_key_compare_to<Compare, key_type>());
  801|  4.56M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE18binary_search_implIS8_NS1_19key_compare_adapterINSt3__14lessIS8_EES8_E15checked_compareEEENS1_12SearchResultImLb0EEERKT_mmRKT0_NSD_17integral_constantIbLb0EEE:
  841|  4.56M|      std::false_type /* IsCompareTo */) const {
  842|  20.9M|    while (s != e) {
  ------------------
  |  Branch (842:12): [True: 16.3M, False: 4.56M]
  ------------------
  843|  16.3M|      const size_type mid = (s + e) >> 1;
  844|  16.3M|      if (comp(key(mid), k)) {
  ------------------
  |  Branch (844:11): [True: 7.77M, False: 8.62M]
  ------------------
  845|  7.77M|        s = mid + 1;
  846|  8.62M|      } else {
  847|  8.62M|        e = mid;
  848|  8.62M|      }
  849|  16.3M|    }
  850|  4.56M|    return SearchResult<size_type, false>{s};
  851|  4.56M|  }
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8key_compEv:
 1583|  7.23M|  const key_compare &key_comp() const noexcept {
 1584|  7.23M|    return rightmost_.template get<0>();
 1585|  7.23M|  }
_ZN4absl12lts_2026010718container_internal12SearchResultINS1_14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKSA_PSD_EELb0EEC2ESG_NS1_9MatchKindE:
  481|  2.61M|  SearchResult(V v, MatchKind /*match*/) : value(v) {}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13internal_lastINS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSF_EEEET_SJ_:
 2898|  2.61M|inline IterType btree<P>::internal_last(IterType iter) {
 2899|  2.61M|  assert(iter.node_ != nullptr);
 2900|  2.71M|  while (iter.position_ == iter.node_->finish()) {
  ------------------
  |  Branch (2900:10): [True: 144k, False: 2.56M]
  ------------------
 2901|   144k|    iter.position_ = iter.node_->position();
 2902|   144k|    iter.node_ = iter.node_->parent();
 2903|   144k|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (2903:9): [True: 52.0k, False: 92.6k]
  ------------------
 2904|  52.0k|      iter.node_ = nullptr;
 2905|  52.0k|      break;
 2906|  52.0k|    }
 2907|   144k|  }
 2908|  2.61M|  iter.update_generation();
 2909|  2.61M|  return iter;
 2910|  2.61M|}
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_E17update_generationEv:
 1322|  3.10M|  void update_generation() {
 1323|  3.10M|    btree_iterator_generation_info::update_generation(node_);
 1324|  3.10M|  }
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE12compare_keysIS8_S8_EEbRKT_RKT0_:
 1587|  2.66M|  bool compare_keys(const K1 &a, const K2 &b) const {
 1588|  2.66M|    return compare_internal::compare_result_as_less_than(key_comp()(a, b));
 1589|  2.66M|  }
_ZNK4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_E3keyEv:
 1315|  2.66M|  const key_type &key() const {
 1316|  2.66M|    return node_->key(static_cast<size_type>(position_));
 1317|  2.66M|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE16internal_emplaceIJRKS8_EEENS1_14btree_iteratorINS1_10btree_nodeIS9_EESD_PSC_EESI_DpOT_:
 2915|   323k|    -> iterator {
 2916|   323k|  if (iter.node_->is_internal()) {
  ------------------
  |  Branch (2916:7): [True: 0, False: 323k]
  ------------------
 2917|       |    // We can't insert on an internal node. Instead, we'll insert after the
 2918|       |    // previous value which is guaranteed to be on a leaf node.
 2919|      0|    --iter;
 2920|      0|    ++iter.position_;
 2921|      0|  }
 2922|   323k|  const field_type max_count = iter.node_->max_count();
 2923|   323k|  allocator_type *alloc = mutable_allocator();
 2924|       |
 2925|   323k|  const auto transfer_and_delete = [&](node_type *old_node,
 2926|   323k|                                       node_type *new_node) {
 2927|   323k|    new_node->transfer_n(old_node->count(), new_node->start(),
 2928|   323k|                         old_node->start(), old_node, alloc);
 2929|   323k|    new_node->set_finish(old_node->finish());
 2930|   323k|    old_node->set_finish(old_node->start());
 2931|   323k|    new_node->set_generation(old_node->generation());
 2932|   323k|    node_type::clear_and_delete(old_node, alloc);
 2933|   323k|  };
 2934|   323k|  const auto replace_leaf_root_node = [&](field_type new_node_size) {
 2935|   323k|    assert(iter.node_ == root());
 2936|   323k|    node_type *old_root = iter.node_;
 2937|   323k|    node_type *new_root = iter.node_ = new_leaf_root_node(new_node_size);
 2938|   323k|    transfer_and_delete(old_root, new_root);
 2939|   323k|    mutable_root() = mutable_rightmost() = new_root;
 2940|   323k|  };
 2941|       |
 2942|   323k|  bool replaced_node = false;
 2943|   323k|  if (iter.node_->count() == max_count) {
  ------------------
  |  Branch (2943:7): [True: 57.7k, False: 265k]
  ------------------
 2944|       |    // Make room in the leaf for the new item.
 2945|  57.7k|    if (max_count < kNodeSlots) {
  ------------------
  |  Branch (2945:9): [True: 7.74k, False: 50.0k]
  ------------------
 2946|       |      // Insertion into the root where the root is smaller than the full node
 2947|       |      // size. Simply grow the size of the root node.
 2948|  7.74k|      replace_leaf_root_node(static_cast<field_type>(
 2949|  7.74k|          (std::min)(static_cast<int>(kNodeSlots), 2 * max_count)));
 2950|  7.74k|      replaced_node = true;
 2951|  50.0k|    } else {
 2952|  50.0k|      rebalance_or_split(&iter);
 2953|  50.0k|    }
 2954|  57.7k|  }
 2955|   323k|  (void)replaced_node;
 2956|       |#if defined(ABSL_HAVE_ADDRESS_SANITIZER) || \
 2957|       |    defined(ABSL_HAVE_HWADDRESS_SANITIZER)
 2958|       |  if (!replaced_node) {
 2959|       |    assert(iter.node_->is_leaf());
 2960|       |    if (iter.node_->is_root()) {
 2961|       |      replace_leaf_root_node(max_count);
 2962|       |    } else {
 2963|       |      node_type *old_node = iter.node_;
 2964|       |      const bool was_rightmost = rightmost() == old_node;
 2965|       |      const bool was_leftmost = leftmost() == old_node;
 2966|       |      node_type *parent = old_node->parent();
 2967|       |      const field_type position = old_node->position();
 2968|       |      node_type *new_node = iter.node_ = new_leaf_node(position, parent);
 2969|       |      parent->set_child_noupdate_position(position, new_node);
 2970|       |      transfer_and_delete(old_node, new_node);
 2971|       |      if (was_rightmost) mutable_rightmost() = new_node;
 2972|       |      // The leftmost node is stored as the parent of the root node.
 2973|       |      if (was_leftmost) root()->set_parent(new_node);
 2974|       |    }
 2975|       |  }
 2976|       |#endif
 2977|   323k|  iter.node_->emplace_value(static_cast<field_type>(iter.position_), alloc,
 2978|   323k|                            std::forward<Args>(args)...);
 2979|       |  assert(
 2980|   323k|      iter.node_->is_ordered_correctly(static_cast<field_type>(iter.position_),
 2981|   323k|                                       original_key_compare(key_comp())) &&
 2982|   323k|      "If this assert fails, then either (1) the comparator may violate "
 2983|   323k|      "transitivity, i.e. comp(a,b) && comp(b,c) -> comp(a,c) (see "
 2984|   323k|      "https://en.cppreference.com/w/cpp/named_req/Compare), or (2) a "
 2985|   323k|      "key may have been mutated after it was inserted into the tree.");
 2986|   323k|  ++size_;
 2987|   323k|  iter.update_generation();
 2988|   323k|  return iter;
 2989|   323k|}
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_EmmEv:
 1218|   100k|  btree_iterator &operator--() {
 1219|   100k|    decrement();
 1220|   100k|    return *this;
 1221|   100k|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_E9decrementEv:
 1305|   100k|  void decrement() {
 1306|   100k|    assert_valid_generation(node_);
 1307|   100k|    if (node_->is_leaf() && --position_ >= node_->start()) {
  ------------------
  |  Branch (1307:9): [True: 99.4k, False: 1.24k]
  |  Branch (1307:29): [True: 99.4k, False: 0]
  ------------------
 1308|  99.4k|      return;
 1309|  99.4k|    }
 1310|  1.24k|    decrement_slow();
 1311|  1.24k|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_E14decrement_slowEv:
 2179|  1.24k|void btree_iterator<N, R, P>::decrement_slow() {
 2180|  1.24k|  N* node = node_;
 2181|  1.24k|  int position = position_;
 2182|  1.24k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2182:7): [True: 0, False: 1.24k]
  ------------------
 2183|      0|    assert(position <= -1);
 2184|      0|    while (position < node->start() && !node->is_root()) {
  ------------------
  |  Branch (2184:12): [True: 0, False: 0]
  |  Branch (2184:40): [True: 0, False: 0]
  ------------------
 2185|      0|      assert(node->parent()->child(node->position()) == node);
 2186|      0|      position = node->position() - 1;
 2187|      0|      node = node->parent();
 2188|      0|    }
 2189|       |    // TODO(ezb): assert we aren't decrementing begin() instead of handling.
 2190|      0|    if (position < node->start()) {
  ------------------
  |  Branch (2190:9): [True: 0, False: 0]
  ------------------
 2191|      0|      return;
 2192|      0|    }
 2193|  1.24k|  } else {
 2194|  1.24k|    assert(position >= node->start());
 2195|  1.24k|    node = node->child(static_cast<field_type>(position));
 2196|  1.24k|    while (node->is_internal()) {
  ------------------
  |  Branch (2196:12): [True: 1, False: 1.24k]
  ------------------
 2197|      1|      node = node->child(node->finish());
 2198|      1|    }
 2199|  1.24k|    position = node->finish() - 1;
 2200|  1.24k|  }
 2201|  1.24k|  *this = {node, position};
 2202|  1.24k|}
_ZZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE16internal_emplaceIJRKS8_EEENS1_14btree_iteratorINS1_10btree_nodeIS9_EESD_PSC_EESI_DpOT_ENKUlhE_clEh:
 2934|  7.74k|  const auto replace_leaf_root_node = [&](field_type new_node_size) {
 2935|       |    assert(iter.node_ == root());
 2936|  7.74k|    node_type *old_root = iter.node_;
 2937|  7.74k|    node_type *new_root = iter.node_ = new_leaf_root_node(new_node_size);
 2938|  7.74k|    transfer_and_delete(old_root, new_root);
 2939|  7.74k|    mutable_root() = mutable_rightmost() = new_root;
 2940|  7.74k|  };
_ZZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE16internal_emplaceIJRKS8_EEENS1_14btree_iteratorINS1_10btree_nodeIS9_EESD_PSC_EESI_DpOT_ENKUlPSG_SM_E_clESM_SM_:
 2926|  7.74k|                                       node_type *new_node) {
 2927|  7.74k|    new_node->transfer_n(old_node->count(), new_node->start(),
 2928|  7.74k|                         old_node->start(), old_node, alloc);
 2929|  7.74k|    new_node->set_finish(old_node->finish());
 2930|  7.74k|    old_node->set_finish(old_node->start());
 2931|  7.74k|    new_node->set_generation(old_node->generation());
 2932|  7.74k|    node_type::clear_and_delete(old_node, alloc);
 2933|  7.74k|  };
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10transfer_nEmmmPSA_PNSt3__19allocatorIS8_EE:
 1016|   177k|                  allocator_type *alloc) {
 1017|   177k|    next_generation();
 1018|   177k|    for (slot_type *src = src_node->slot(src_i), *end = src + n,
 1019|   177k|                   *dest = slot(dest_i);
 1020|  2.16M|         src != end; ++src, ++dest) {
  ------------------
  |  Branch (1020:10): [True: 1.99M, False: 177k]
  ------------------
 1021|  1.99M|      transfer(dest, src, alloc);
 1022|  1.99M|    }
 1023|   177k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8transferEPS8_SB_PNSt3__19allocatorIS8_EE:
  999|  5.98M|  static void transfer(slot_type *dest, slot_type *src, allocator_type *alloc) {
 1000|  5.98M|    absl::container_internal::SanitizerUnpoisonObject(dest);
 1001|  5.98M|    params_type::transfer(alloc, dest, src);
 1002|  5.98M|    absl::container_internal::SanitizerPoisonObject(src);
 1003|  5.98M|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE18rebalance_or_splitEPNS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSE_EE:
 2711|  64.7k|void btree<P>::rebalance_or_split(iterator *iter) {
 2712|  64.7k|  node_type *&node = iter->node_;
 2713|  64.7k|  int &insert_position = iter->position_;
 2714|  64.7k|  assert(node->count() == node->max_count());
 2715|  64.7k|  assert(kNodeSlots == node->max_count());
 2716|       |
 2717|       |  // First try to make room on the node by rebalancing.
 2718|  64.7k|  node_type *parent = node->parent();
 2719|  64.7k|  if (node != root()) {
  ------------------
  |  Branch (2719:7): [True: 62.6k, False: 2.13k]
  ------------------
 2720|  62.6k|    if (node->position() > parent->start()) {
  ------------------
  |  Branch (2720:9): [True: 57.8k, False: 4.79k]
  ------------------
 2721|       |      // Try rebalancing with our left sibling.
 2722|  57.8k|      node_type *left = parent->child(node->position() - 1);
 2723|  57.8k|      assert(left->max_count() == kNodeSlots);
 2724|  57.8k|      if (left->count() < kNodeSlots) {
  ------------------
  |  Branch (2724:11): [True: 37.3k, False: 20.5k]
  ------------------
 2725|       |        // We bias rebalancing based on the position being inserted. If we're
 2726|       |        // inserting at the end of the right node then we bias rebalancing to
 2727|       |        // fill up the left node.
 2728|  37.3k|        field_type to_move =
 2729|  37.3k|            (kNodeSlots - left->count()) /
 2730|  37.3k|            (1 + (static_cast<field_type>(insert_position) < kNodeSlots));
 2731|  37.3k|        to_move = (std::max)(field_type{1}, to_move);
 2732|       |
 2733|  37.3k|        if (static_cast<field_type>(insert_position) - to_move >=
  ------------------
  |  Branch (2733:13): [True: 35.8k, False: 1.53k]
  ------------------
 2734|  37.3k|                node->start() ||
 2735|  37.2k|            left->count() + to_move < kNodeSlots) {
  ------------------
  |  Branch (2735:13): [True: 1.44k, False: 93]
  ------------------
 2736|  37.2k|          left->rebalance_right_to_left(to_move, node, mutable_allocator());
 2737|       |
 2738|  37.2k|          assert(node->max_count() - node->count() == to_move);
 2739|  37.2k|          insert_position = static_cast<int>(
 2740|  37.2k|              static_cast<field_type>(insert_position) - to_move);
 2741|  37.2k|          if (insert_position < node->start()) {
  ------------------
  |  Branch (2741:15): [True: 1.44k, False: 35.8k]
  ------------------
 2742|  1.44k|            insert_position = insert_position + left->count() + 1;
 2743|  1.44k|            node = left;
 2744|  1.44k|          }
 2745|       |
 2746|  37.2k|          assert(node->count() < node->max_count());
 2747|  37.2k|          return;
 2748|  37.2k|        }
 2749|  37.3k|      }
 2750|  57.8k|    }
 2751|       |
 2752|  25.4k|    if (node->position() < parent->finish()) {
  ------------------
  |  Branch (2752:9): [True: 21.7k, False: 3.64k]
  ------------------
 2753|       |      // Try rebalancing with our right sibling.
 2754|  21.7k|      node_type *right = parent->child(node->position() + 1);
 2755|  21.7k|      assert(right->max_count() == kNodeSlots);
 2756|  21.7k|      if (right->count() < kNodeSlots) {
  ------------------
  |  Branch (2756:11): [True: 14.5k, False: 7.22k]
  ------------------
 2757|       |        // We bias rebalancing based on the position being inserted. If we're
 2758|       |        // inserting at the beginning of the left node then we bias rebalancing
 2759|       |        // to fill up the right node.
 2760|  14.5k|        field_type to_move = (kNodeSlots - right->count()) /
 2761|  14.5k|                             (1 + (insert_position > node->start()));
 2762|  14.5k|        to_move = (std::max)(field_type{1}, to_move);
 2763|       |
 2764|  14.5k|        if (static_cast<field_type>(insert_position) <=
  ------------------
  |  Branch (2764:13): [True: 11.7k, False: 2.78k]
  ------------------
 2765|  14.5k|                node->finish() - to_move ||
 2766|  14.3k|            right->count() + to_move < kNodeSlots) {
  ------------------
  |  Branch (2766:13): [True: 2.59k, False: 196]
  ------------------
 2767|  14.3k|          node->rebalance_left_to_right(to_move, right, mutable_allocator());
 2768|       |
 2769|  14.3k|          if (insert_position > node->finish()) {
  ------------------
  |  Branch (2769:15): [True: 2.59k, False: 11.7k]
  ------------------
 2770|  2.59k|            insert_position = insert_position - node->count() - 1;
 2771|  2.59k|            node = right;
 2772|  2.59k|          }
 2773|       |
 2774|  14.3k|          assert(node->count() < node->max_count());
 2775|  14.3k|          return;
 2776|  14.3k|        }
 2777|  14.5k|      }
 2778|  21.7k|    }
 2779|       |
 2780|       |    // Rebalancing failed, make sure there is room on the parent node for a new
 2781|       |    // value.
 2782|  25.4k|    assert(parent->max_count() == kNodeSlots);
 2783|  11.0k|    if (parent->count() == kNodeSlots) {
  ------------------
  |  Branch (2783:9): [True: 298, False: 10.7k]
  ------------------
 2784|    298|      iterator parent_iter(parent, node->position());
 2785|    298|      rebalance_or_split(&parent_iter);
 2786|    298|      parent = node->parent();
 2787|    298|    }
 2788|  11.0k|  } else {
 2789|       |    // Rebalancing not possible because this is the root node.
 2790|       |    // Create a new root node and set the current root node as the child of the
 2791|       |    // new root.
 2792|  2.13k|    parent = new_internal_node(/*position=*/0, parent);
 2793|  2.13k|    parent->set_generation(root()->generation());
 2794|  2.13k|    parent->init_child(parent->start(), node);
 2795|  2.13k|    mutable_root() = parent;
 2796|       |    // If the former root was a leaf node, then it's now the rightmost node.
 2797|  2.13k|    assert(parent->start_child()->is_internal() ||
 2798|  2.13k|           parent->start_child() == rightmost());
 2799|  2.13k|  }
 2800|       |
 2801|       |  // Split the node.
 2802|  13.1k|  node_type *split_node;
 2803|  13.1k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2803:7): [True: 13.0k, False: 123]
  ------------------
 2804|  13.0k|    split_node = new_leaf_node(node->position() + 1, parent);
 2805|  13.0k|    node->split(insert_position, split_node, mutable_allocator());
 2806|  13.0k|    if (rightmost() == node) mutable_rightmost() = split_node;
  ------------------
  |  Branch (2806:9): [True: 5.59k, False: 7.47k]
  ------------------
 2807|  13.0k|  } else {
 2808|    123|    split_node = new_internal_node(node->position() + 1, parent);
 2809|    123|    node->split(insert_position, split_node, mutable_allocator());
 2810|    123|  }
 2811|       |
 2812|  13.1k|  if (insert_position > node->finish()) {
  ------------------
  |  Branch (2812:7): [True: 8.12k, False: 5.07k]
  ------------------
 2813|  8.12k|    insert_position = insert_position - node->count() - 1;
 2814|  8.12k|    node = split_node;
 2815|  8.12k|  }
 2816|  13.1k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE23rebalance_right_to_leftEhPSA_PNSt3__19allocatorIS8_EE:
 1872|  39.0k|                                            allocator_type *alloc) {
 1873|  39.0k|  assert(parent() == right->parent());
 1874|  39.0k|  assert(position() + 1 == right->position());
 1875|  39.0k|  assert(right->count() >= count());
 1876|  39.0k|  assert(to_move >= 1);
 1877|  39.0k|  assert(to_move <= right->count());
 1878|       |
 1879|       |  // 1) Move the delimiting value in the parent to the left node.
 1880|  39.0k|  transfer(finish(), position(), parent(), alloc);
 1881|       |
 1882|       |  // 2) Move the (to_move - 1) values from the right node to the left node.
 1883|  39.0k|  transfer_n(to_move - 1, finish() + 1, right->start(), right, alloc);
 1884|       |
 1885|       |  // 3) Move the new delimiting value to the parent from the right node.
 1886|  39.0k|  parent()->transfer(position(), right->start() + to_move - 1, right, alloc);
 1887|       |
 1888|       |  // 4) Shift the values in the right node to their correct positions.
 1889|  39.0k|  right->transfer_n(right->count() - to_move, right->start(),
 1890|  39.0k|                    right->start() + to_move, right, alloc);
 1891|       |
 1892|  39.0k|  if (is_internal()) {
  ------------------
  |  Branch (1892:7): [True: 132, False: 38.9k]
  ------------------
 1893|       |    // Move the child pointers from the right to the left node.
 1894|    616|    for (field_type i = 0; i < to_move; ++i) {
  ------------------
  |  Branch (1894:28): [True: 484, False: 132]
  ------------------
 1895|    484|      init_child(finish() + i + 1, right->child(i));
 1896|    484|    }
 1897|  3.71k|    for (field_type i = right->start(); i <= right->finish() - to_move; ++i) {
  ------------------
  |  Branch (1897:41): [True: 3.57k, False: 132]
  ------------------
 1898|  3.57k|      assert(i + to_move <= right->max_count());
 1899|  3.57k|      right->init_child(i, right->child(i + to_move));
 1900|  3.57k|      right->clear_child(i + to_move);
 1901|  3.57k|    }
 1902|    132|  }
 1903|       |
 1904|       |  // Fixup `finish` on the left and right nodes.
 1905|  39.0k|  set_finish(finish() + to_move);
 1906|  39.0k|  right->set_finish(right->finish() - to_move);
 1907|  39.0k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8transferEmmPSA_PNSt3__19allocatorIS8_EE:
 1007|   109k|                btree_node *src_node, allocator_type *alloc) {
 1008|   109k|    next_generation();
 1009|   109k|    transfer(slot(dest_i), src_node->slot(src_i), alloc);
 1010|   109k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE11clear_childEh:
  758|  15.4k|  void clear_child(field_type i) {
  759|  15.4k|    absl::container_internal::SanitizerPoisonObject(&mutable_child(i));
  760|  15.4k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13mutable_childEh:
  757|   157k|  btree_node *&mutable_child(field_type i) { return GetField<4>()[i]; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8GetFieldILm4EEEPNSt3__113tuple_elementIXT_ENSC_5tupleIJPSA_jhS8_SF_EEEE4typeEv:
  653|   157k|  inline typename layout_type::template ElementType<N> *GetField() {
  654|       |    // We assert that we don't read from values that aren't there.
  655|       |    assert(N < 4 || is_internal());
  656|   157k|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  657|   157k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE23rebalance_left_to_rightEhPSA_PNSt3__19allocatorIS8_EE:
 1912|  14.9k|                                            allocator_type *alloc) {
 1913|  14.9k|  assert(parent() == right->parent());
 1914|  14.9k|  assert(position() + 1 == right->position());
 1915|  14.9k|  assert(count() >= right->count());
 1916|  14.9k|  assert(to_move >= 1);
 1917|  14.9k|  assert(to_move <= count());
 1918|       |
 1919|       |  // Values in the right node are shifted to the right to make room for the
 1920|       |  // new to_move values. Then, the delimiting value in the parent and the
 1921|       |  // other (to_move - 1) values in the left node are moved into the right node.
 1922|       |  // Lastly, a new delimiting value is moved from the left node into the
 1923|       |  // parent, and the remaining empty left node entries are destroyed.
 1924|       |
 1925|       |  // 1) Shift existing values in the right node to their correct positions.
 1926|  14.9k|  right->transfer_n_backward(right->count(), right->start() + to_move,
 1927|  14.9k|                             right->start(), right, alloc);
 1928|       |
 1929|       |  // 2) Move the delimiting value in the parent to the right node.
 1930|  14.9k|  right->transfer(right->start() + to_move - 1, position(), parent(), alloc);
 1931|       |
 1932|       |  // 3) Move the (to_move - 1) values from the left node to the right node.
 1933|  14.9k|  right->transfer_n(to_move - 1, right->start(), finish() - (to_move - 1), this,
 1934|  14.9k|                    alloc);
 1935|       |
 1936|       |  // 4) Move the new delimiting value to the parent from the left node.
 1937|  14.9k|  parent()->transfer(position(), finish() - to_move, this, alloc);
 1938|       |
 1939|  14.9k|  if (is_internal()) {
  ------------------
  |  Branch (1939:7): [True: 47, False: 14.8k]
  ------------------
 1940|       |    // Move the child pointers from the left to the right node.
 1941|    643|    for (field_type i = right->finish() + 1; i > right->start(); --i) {
  ------------------
  |  Branch (1941:46): [True: 596, False: 47]
  ------------------
 1942|    596|      right->init_child(i - 1 + to_move, right->child(i - 1));
 1943|    596|      right->clear_child(i - 1);
 1944|    596|    }
 1945|    466|    for (field_type i = 1; i <= to_move; ++i) {
  ------------------
  |  Branch (1945:28): [True: 419, False: 47]
  ------------------
 1946|    419|      right->init_child(i - 1, child(finish() - to_move + i));
 1947|    419|      clear_child(finish() - to_move + i);
 1948|    419|    }
 1949|     47|  }
 1950|       |
 1951|       |  // Fixup the counts on the left and right nodes.
 1952|  14.9k|  set_finish(finish() - to_move);
 1953|  14.9k|  right->set_finish(right->finish() + to_move);
 1954|  14.9k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE19transfer_n_backwardEmmmPSA_PNSt3__19allocatorIS8_EE:
 1029|   373k|                           allocator_type *alloc) {
 1030|   373k|    next_generation();
 1031|   373k|    for (slot_type *src = src_node->slot(src_i + n), *end = src - n,
 1032|   373k|                   *dest = slot(dest_i + n);
 1033|  4.25M|         src != end; --src, --dest) {
  ------------------
  |  Branch (1033:10): [True: 3.87M, False: 373k]
  ------------------
 1034|       |      // If we modified the loop index calculations above to avoid the -1s here,
 1035|       |      // it would result in UB in the computation of `end` (and possibly `src`
 1036|       |      // as well, if n == 0), since slot() is effectively an array index and it
 1037|       |      // is UB to compute the address of any out-of-bounds array element except
 1038|       |      // for one-past-the-end.
 1039|  3.87M|      transfer(dest - 1, src - 1, alloc);
 1040|  3.87M|    }
 1041|   373k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE17new_internal_nodeEhPNS1_10btree_nodeIS9_EE:
 1710|  2.25k|  node_type *new_internal_node(field_type position, node_type *parent) {
 1711|  2.25k|    node_type *n = allocate(node_type::InternalSize());
 1712|  2.25k|    n->init_internal(position, parent);
 1713|  2.25k|    return n;
 1714|  2.25k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13init_internalEhPSA_:
  960|  2.25k|  void init_internal(field_type position, btree_node *parent) {
  961|  2.25k|    init_leaf(position, kNodeSlots, parent);
  962|       |    // Set `max_count` to a sentinel value to indicate that this node is
  963|       |    // internal.
  964|  2.25k|    set_max_count(kInternalNodeMaxCount);
  965|  2.25k|    absl::container_internal::SanitizerPoisonMemoryRegion(
  966|  2.25k|        &mutable_child(start()), (kNodeSlots + 1) * sizeof(btree_node *));
  967|  2.25k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10init_childEhPSA_:
  769|  8.84k|  void init_child(field_type i, btree_node *c) {
  770|  8.84k|    set_child(i, c);
  771|  8.84k|    c->set_parent(this);
  772|  8.84k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE9set_childEhPSA_:
  765|  56.8k|  void set_child(field_type i, btree_node *c) {
  766|  56.8k|    set_child_noupdate_position(i, c);
  767|  56.8k|    c->set_position(i);
  768|  56.8k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE27set_child_noupdate_positionEhPSA_:
  761|  70.0k|  void set_child_noupdate_position(field_type i, btree_node *c) {
  762|  70.0k|    absl::container_internal::SanitizerUnpoisonObject(&mutable_child(i));
  763|  70.0k|    mutable_child(i) = c;
  764|  70.0k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13new_leaf_nodeEhPNS1_10btree_nodeIS9_EE:
 1715|  13.0k|  node_type *new_leaf_node(field_type position, node_type *parent) {
 1716|  13.0k|    node_type *n = allocate(node_type::LeafSize());
 1717|  13.0k|    n->init_leaf(position, kNodeSlots, parent);
 1718|  13.0k|    return n;
 1719|  13.0k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE5splitEiPSA_PNSt3__19allocatorIS8_EE:
 1958|  13.1k|                          allocator_type *alloc) {
 1959|  13.1k|  assert(dest->count() == 0);
 1960|  13.1k|  assert(max_count() == kNodeSlots);
 1961|  13.1k|  assert(position() + 1 == dest->position());
 1962|  13.1k|  assert(parent() == dest->parent());
 1963|       |
 1964|       |  // We bias the split based on the position being inserted. If we're
 1965|       |  // inserting at the beginning of the left node then bias the split to put
 1966|       |  // more values on the right node. If we're inserting at the end of the
 1967|       |  // right node then bias the split to put more values on the left node.
 1968|  13.1k|  if (insert_position == start()) {
  ------------------
  |  Branch (1968:7): [True: 177, False: 13.0k]
  ------------------
 1969|    177|    dest->set_finish(dest->start() + finish() - 1);
 1970|  13.0k|  } else if (insert_position == kNodeSlots) {
  ------------------
  |  Branch (1970:14): [True: 1.82k, False: 11.1k]
  ------------------
 1971|  1.82k|    dest->set_finish(dest->start());
 1972|  11.1k|  } else {
 1973|  11.1k|    dest->set_finish(dest->start() + count() / 2);
 1974|  11.1k|  }
 1975|  13.1k|  set_finish(finish() - dest->count());
 1976|  13.1k|  assert(count() >= 1);
 1977|       |
 1978|       |  // Move values from the left sibling to the right sibling.
 1979|  13.1k|  dest->transfer_n(dest->count(), dest->start(), finish(), this, alloc);
 1980|       |
 1981|       |  // The split key is the largest value in the left sibling.
 1982|  13.1k|  --mutable_finish();
 1983|  13.1k|  parent()->emplace_value(position(), alloc, finish_slot());
 1984|  13.1k|  value_destroy(finish(), alloc);
 1985|  13.1k|  parent()->set_child_noupdate_position(position() + 1, dest);
 1986|       |
 1987|  13.1k|  if (is_internal()) {
  ------------------
  |  Branch (1987:7): [True: 123, False: 13.0k]
  ------------------
 1988|  1.74k|    for (field_type i = dest->start(), j = finish() + 1; i <= dest->finish();
  ------------------
  |  Branch (1988:58): [True: 1.62k, False: 123]
  ------------------
 1989|  1.62k|         ++i, ++j) {
 1990|       |      assert(child(j) != nullptr);
 1991|  1.62k|      dest->init_child(i, child(j));
 1992|  1.62k|      clear_child(j);
 1993|  1.62k|    }
 1994|    123|  }
 1995|  13.1k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE14mutable_finishEv:
  665|  13.1k|  field_type &mutable_finish() { return GetField<2>()[2]; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13emplace_valueIJPS8_EEEvhPNSt3__19allocatorIS8_EEDpOT_:
 1825|  13.1k|                                         Args &&...args) {
 1826|  13.1k|  assert(i >= start());
 1827|  13.1k|  assert(i <= finish());
 1828|       |  // Shift old values to create space for new value and then construct it in
 1829|       |  // place.
 1830|  13.1k|  if (i < finish()) {
  ------------------
  |  Branch (1830:7): [True: 7.41k, False: 5.78k]
  ------------------
 1831|  7.41k|    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
 1832|  7.41k|                        alloc);
 1833|  7.41k|  }
 1834|  13.1k|  value_init(static_cast<field_type>(i), alloc, std::forward<Args>(args)...);
 1835|  13.1k|  set_finish(finish() + 1);
 1836|       |
 1837|  13.1k|  if (is_internal() && finish() > i + 1) {
  ------------------
  |  Branch (1837:7): [True: 13.1k, False: 0]
  |  Branch (1837:24): [True: 7.41k, False: 5.78k]
  ------------------
 1838|  53.6k|    for (field_type j = finish(); j > i + 1; --j) {
  ------------------
  |  Branch (1838:35): [True: 46.2k, False: 7.41k]
  ------------------
 1839|  46.2k|      set_child(j, child(j - 1));
 1840|  46.2k|    }
 1841|  7.41k|    clear_child(i + 1);
 1842|  7.41k|  }
 1843|  13.1k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10value_initIJPS8_EEEvhPNSt3__19allocatorIS8_EEDpOT_:
  980|  13.9k|  void value_init(const field_type i, allocator_type *alloc, Args &&...args) {
  981|  13.9k|    next_generation();
  982|  13.9k|    absl::container_internal::SanitizerUnpoisonObject(slot(i));
  983|  13.9k|    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
  984|  13.9k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE11finish_slotEv:
  668|  13.1k|  slot_type *finish_slot() { return slot(finish()); }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13value_destroyEhPNSt3__19allocatorIS8_EE:
  985|  14.4k|  void value_destroy(const field_type i, allocator_type *alloc) {
  986|  14.4k|    next_generation();
  987|  14.4k|    params_type::destroy(alloc, slot(i));
  988|  14.4k|    absl::container_internal::SanitizerPoisonObject(slot(i));
  989|  14.4k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE9rightmostEv:
 1680|   531k|  node_type *rightmost() { return rightmost_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13emplace_valueIJRKS8_EEEvhPNSt3__19allocatorIS8_EEDpOT_:
 1825|   323k|                                         Args &&...args) {
 1826|   323k|  assert(i >= start());
 1827|   323k|  assert(i <= finish());
 1828|       |  // Shift old values to create space for new value and then construct it in
 1829|       |  // place.
 1830|   323k|  if (i < finish()) {
  ------------------
  |  Branch (1830:7): [True: 258k, False: 64.5k]
  ------------------
 1831|   258k|    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
 1832|   258k|                        alloc);
 1833|   258k|  }
 1834|   323k|  value_init(static_cast<field_type>(i), alloc, std::forward<Args>(args)...);
 1835|   323k|  set_finish(finish() + 1);
 1836|       |
 1837|   323k|  if (is_internal() && finish() > i + 1) {
  ------------------
  |  Branch (1837:7): [True: 0, False: 323k]
  |  Branch (1837:24): [True: 0, False: 0]
  ------------------
 1838|      0|    for (field_type j = finish(); j > i + 1; --j) {
  ------------------
  |  Branch (1838:35): [True: 0, False: 0]
  ------------------
 1839|      0|      set_child(j, child(j - 1));
 1840|      0|    }
 1841|      0|    clear_child(i + 1);
 1842|      0|  }
 1843|   323k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10value_initIJRKS8_EEEvhPNSt3__19allocatorIS8_EEDpOT_:
  980|   323k|  void value_init(const field_type i, allocator_type *alloc, Args &&...args) {
  981|   323k|    next_generation();
  982|   323k|    absl::container_internal::SanitizerUnpoisonObject(slot(i));
  983|   323k|    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
  984|   323k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE13insert_uniqueImJmEEENSt3__14pairINS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSC_EEbEERKT_DpOT0_:
 2374|  2.46M|    -> std::pair<iterator, bool> {
 2375|  2.46M|  if (empty()) {
  ------------------
  |  Branch (2375:7): [True: 323k, False: 2.14M]
  ------------------
 2376|   323k|    mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
 2377|   323k|  }
 2378|       |
 2379|  2.46M|  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
 2380|  2.46M|  iterator iter = res.value;
 2381|       |
 2382|  2.46M|  if (res.HasMatch()) {
  ------------------
  |  Branch (2382:7): [Folded, False: 2.46M]
  ------------------
 2383|      0|    if (res.IsEq()) {
  ------------------
  |  Branch (2383:9): [Folded, False: 0]
  ------------------
 2384|       |      // The key already exists in the tree, do nothing.
 2385|      0|      return {iter, false};
 2386|      0|    }
 2387|  2.46M|  } else {
 2388|  2.46M|    iterator last = internal_last(iter);
 2389|  2.46M|    if (last.node_ && !compare_keys(key, last.key())) {
  ------------------
  |  Branch (2389:9): [True: 0, False: 2.46M]
  |  Branch (2389:23): [True: 0, False: 0]
  ------------------
 2390|       |      // The key already exists in the tree, do nothing.
 2391|      0|      return {last, false};
 2392|      0|    }
 2393|  2.46M|  }
 2394|  2.46M|  return {internal_emplace(iter, std::forward<Args>(args)...), true};
 2395|  2.46M|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE18new_leaf_root_nodeEh:
 1720|   636k|  node_type *new_leaf_root_node(field_type max_count) {
 1721|   636k|    node_type *n = allocate(node_type::LeafSize(max_count));
 1722|   636k|    n->init_leaf(/*position=*/0, max_count, /*parent=*/n);
 1723|   636k|    return n;
 1724|   636k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE8allocateEm:
 1703|   696k|  node_type *allocate(size_type size) {
 1704|   696k|    return reinterpret_cast<node_type *>(
 1705|   696k|        absl::container_internal::Allocate<node_type::Alignment()>(
 1706|   696k|            mutable_allocator(), size));
 1707|   696k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE9init_leafEhhPS5_:
  950|   696k|                 btree_node *parent) {
  951|   696k|    set_generation(0);
  952|   696k|    set_parent(parent);
  953|   696k|    set_position(position);
  954|   696k|    set_start(0);
  955|   696k|    set_finish(0);
  956|   696k|    set_max_count(max_count);
  957|   696k|    absl::container_internal::SanitizerPoisonMemoryRegion(
  958|   696k|        start_slot(), max_count * sizeof(slot_type));
  959|   696k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE9set_startEh:
  671|   696k|  void set_start(field_type v) { GetField<2>()[1] = v; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE13set_max_countEh:
  674|   708k|  void set_max_count(field_type v) { GetField<2>()[3] = v; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE10start_slotEv:
  667|   696k|  slot_type *start_slot() { return slot(start()); }
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE15internal_locateImEENS1_12SearchResultINS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSB_EELb0EEERKT_:
 2994|  2.46M|    -> SearchResult<iterator, is_key_compare_to::value> {
 2995|  2.46M|  iterator iter(const_cast<node_type *>(root()));
 2996|  4.16M|  for (;;) {
 2997|  4.16M|    SearchResult<size_type, is_key_compare_to::value> res =
 2998|  4.16M|        iter.node_->lower_bound(key, key_comp());
 2999|  4.16M|    iter.position_ = static_cast<int>(res.value);
 3000|  4.16M|    if (res.IsEq()) {
  ------------------
  |  Branch (3000:9): [Folded, False: 4.16M]
  ------------------
 3001|      0|      return {iter, MatchKind::kEq};
 3002|      0|    }
 3003|       |    // Note: in the non-key-compare-to case, we don't need to walk all the way
 3004|       |    // down the tree if the keys are equal, but determining equality would
 3005|       |    // require doing an extra comparison on each node on the way down, and we
 3006|       |    // will need to go all the way to the leaf node in the expected case.
 3007|  4.16M|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (3007:9): [True: 2.46M, False: 1.70M]
  ------------------
 3008|  2.46M|      break;
 3009|  2.46M|    }
 3010|  1.70M|    iter.node_ = iter.node_->child(static_cast<field_type>(iter.position_));
 3011|  1.70M|  }
 3012|       |  // Note: in the non-key-compare-to case, the key may actually be equivalent
 3013|       |  // here (and the MatchKind::kNe is ignored).
 3014|  2.46M|  return {iter, MatchKind::kNe};
 3015|  2.46M|}
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE4rootEv:
 1678|  2.46M|  const node_type *root() const { return root_; }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE11lower_boundImEENS1_12SearchResultImLb0EEERKT_RKNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareE:
  777|  4.16M|      const K &k, const key_compare &comp) const {
  778|  4.16M|    return use_linear_search::value ? linear_search(k, comp)
  ------------------
  |  Branch (778:12): [True: 4.16M, Folded]
  ------------------
  779|  4.16M|                                    : binary_search(k, comp);
  780|  4.16M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE13linear_searchImNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareEEENS1_12SearchResultImXsr23btree_is_key_compare_toIT0_mEE5valueEEERKT_RKSE_:
  791|  4.16M|  linear_search(const K &k, const Compare &comp) const {
  792|  4.16M|    return linear_search_impl(k, start(), finish(), comp,
  793|  4.16M|                              btree_is_key_compare_to<Compare, key_type>());
  794|  4.16M|  }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE18linear_search_implImNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareEEENS1_12SearchResultImLb0EEERKT_mmRKT0_NS8_17integral_constantIbLb0EEE:
  808|  4.16M|      std::false_type /* IsCompareTo */) const {
  809|  46.1M|    while (s < e) {
  ------------------
  |  Branch (809:12): [True: 41.9M, False: 4.16M]
  ------------------
  810|  41.9M|      if (!comp(key(s), k)) {
  ------------------
  |  Branch (810:11): [True: 0, False: 41.9M]
  ------------------
  811|      0|        break;
  812|      0|      }
  813|  41.9M|      ++s;
  814|  41.9M|    }
  815|  4.16M|    return SearchResult<size_type, false>{s};
  816|  4.16M|  }
_ZNK4absl12lts_2026010718container_internal19key_compare_adapterINSt3__14lessImEEmE15checked_compareclImmTnNS3_9enable_ifIXsr3std7is_sameIbNS0_20type_traits_internal9result_ofIFKS5_RKT_RKT0_EE4typeEEE5valueEiE4typeELi0EEEbSF_SI_:
  237|  41.9M|    bool operator()(const T &lhs, const U &rhs) const {
  238|       |      // NOTE: if any of these assertions fail, then the comparator does not
  239|       |      // establish a strict-weak-ordering (see
  240|       |      // https://en.cppreference.com/w/cpp/named_req/Compare).
  241|  41.9M|      assert(is_self_equivalent(lhs));
  242|  41.9M|      assert(is_self_equivalent(rhs));
  243|  41.9M|      const bool lhs_comp_rhs = comp()(lhs, rhs);
  244|       |      assert(!lhs_comp_rhs || !comp()(rhs, lhs));
  245|  41.9M|      return lhs_comp_rhs;
  246|  41.9M|    }
_ZNK4absl12lts_2026010718container_internal20checked_compare_baseINSt3__14lessImEELb1EE4compEv:
  176|  41.9M|  const Compare &comp() const { return *this; }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE3keyEm:
  748|  41.9M|  const key_type &key(size_type i) const { return params_type::key(slot(i)); }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE4slotEm:
  669|  41.9M|  const slot_type *slot(size_type i) const { return &GetField<3>()[i]; }
_ZNK4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm3EEEPKNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  659|  41.9M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  660|       |    assert(N < 4 || is_internal());
  661|  41.9M|    return InternalLayout().template Pointer<N>(
  662|  41.9M|        reinterpret_cast<const char *>(this));
  663|  41.9M|  }
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE8key_compEv:
 1583|  4.16M|  const key_compare &key_comp() const noexcept {
 1584|  4.16M|    return rightmost_.template get<0>();
 1585|  4.16M|  }
_ZN4absl12lts_2026010718container_internal12SearchResultINS1_14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS8_EELb0EEC2ESB_NS1_9MatchKindE:
  481|  2.46M|  SearchResult(V v, MatchKind /*match*/) : value(v) {}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE13internal_lastINS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSA_EEEET_SE_:
 2898|  2.46M|inline IterType btree<P>::internal_last(IterType iter) {
 2899|  2.46M|  assert(iter.node_ != nullptr);
 2900|  4.16M|  while (iter.position_ == iter.node_->finish()) {
  ------------------
  |  Branch (2900:10): [True: 4.16M, False: 0]
  ------------------
 2901|  4.16M|    iter.position_ = iter.node_->position();
 2902|  4.16M|    iter.node_ = iter.node_->parent();
 2903|  4.16M|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (2903:9): [True: 2.46M, False: 1.70M]
  ------------------
 2904|  2.46M|      iter.node_ = nullptr;
 2905|  2.46M|      break;
 2906|  2.46M|    }
 2907|  4.16M|  }
 2908|  2.46M|  iter.update_generation();
 2909|  2.46M|  return iter;
 2910|  2.46M|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE16internal_emplaceIJmEEENS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSA_EESD_DpOT_:
 2915|  2.46M|    -> iterator {
 2916|  2.46M|  if (iter.node_->is_internal()) {
  ------------------
  |  Branch (2916:7): [True: 0, False: 2.46M]
  ------------------
 2917|       |    // We can't insert on an internal node. Instead, we'll insert after the
 2918|       |    // previous value which is guaranteed to be on a leaf node.
 2919|      0|    --iter;
 2920|      0|    ++iter.position_;
 2921|      0|  }
 2922|  2.46M|  const field_type max_count = iter.node_->max_count();
 2923|  2.46M|  allocator_type *alloc = mutable_allocator();
 2924|       |
 2925|  2.46M|  const auto transfer_and_delete = [&](node_type *old_node,
 2926|  2.46M|                                       node_type *new_node) {
 2927|  2.46M|    new_node->transfer_n(old_node->count(), new_node->start(),
 2928|  2.46M|                         old_node->start(), old_node, alloc);
 2929|  2.46M|    new_node->set_finish(old_node->finish());
 2930|  2.46M|    old_node->set_finish(old_node->start());
 2931|  2.46M|    new_node->set_generation(old_node->generation());
 2932|  2.46M|    node_type::clear_and_delete(old_node, alloc);
 2933|  2.46M|  };
 2934|  2.46M|  const auto replace_leaf_root_node = [&](field_type new_node_size) {
 2935|  2.46M|    assert(iter.node_ == root());
 2936|  2.46M|    node_type *old_root = iter.node_;
 2937|  2.46M|    node_type *new_root = iter.node_ = new_leaf_root_node(new_node_size);
 2938|  2.46M|    transfer_and_delete(old_root, new_root);
 2939|  2.46M|    mutable_root() = mutable_rightmost() = new_root;
 2940|  2.46M|  };
 2941|       |
 2942|  2.46M|  bool replaced_node = false;
 2943|  2.46M|  if (iter.node_->count() == max_count) {
  ------------------
  |  Branch (2943:7): [True: 400k, False: 2.06M]
  ------------------
 2944|       |    // Make room in the leaf for the new item.
 2945|   400k|    if (max_count < kNodeSlots) {
  ------------------
  |  Branch (2945:9): [True: 312k, False: 87.3k]
  ------------------
 2946|       |      // Insertion into the root where the root is smaller than the full node
 2947|       |      // size. Simply grow the size of the root node.
 2948|   312k|      replace_leaf_root_node(static_cast<field_type>(
 2949|   312k|          (std::min)(static_cast<int>(kNodeSlots), 2 * max_count)));
 2950|   312k|      replaced_node = true;
 2951|   312k|    } else {
 2952|  87.3k|      rebalance_or_split(&iter);
 2953|  87.3k|    }
 2954|   400k|  }
 2955|  2.46M|  (void)replaced_node;
 2956|       |#if defined(ABSL_HAVE_ADDRESS_SANITIZER) || \
 2957|       |    defined(ABSL_HAVE_HWADDRESS_SANITIZER)
 2958|       |  if (!replaced_node) {
 2959|       |    assert(iter.node_->is_leaf());
 2960|       |    if (iter.node_->is_root()) {
 2961|       |      replace_leaf_root_node(max_count);
 2962|       |    } else {
 2963|       |      node_type *old_node = iter.node_;
 2964|       |      const bool was_rightmost = rightmost() == old_node;
 2965|       |      const bool was_leftmost = leftmost() == old_node;
 2966|       |      node_type *parent = old_node->parent();
 2967|       |      const field_type position = old_node->position();
 2968|       |      node_type *new_node = iter.node_ = new_leaf_node(position, parent);
 2969|       |      parent->set_child_noupdate_position(position, new_node);
 2970|       |      transfer_and_delete(old_node, new_node);
 2971|       |      if (was_rightmost) mutable_rightmost() = new_node;
 2972|       |      // The leftmost node is stored as the parent of the root node.
 2973|       |      if (was_leftmost) root()->set_parent(new_node);
 2974|       |    }
 2975|       |  }
 2976|       |#endif
 2977|  2.46M|  iter.node_->emplace_value(static_cast<field_type>(iter.position_), alloc,
 2978|  2.46M|                            std::forward<Args>(args)...);
 2979|       |  assert(
 2980|  2.46M|      iter.node_->is_ordered_correctly(static_cast<field_type>(iter.position_),
 2981|  2.46M|                                       original_key_compare(key_comp())) &&
 2982|  2.46M|      "If this assert fails, then either (1) the comparator may violate "
 2983|  2.46M|      "transitivity, i.e. comp(a,b) && comp(b,c) -> comp(a,c) (see "
 2984|  2.46M|      "https://en.cppreference.com/w/cpp/named_req/Compare), or (2) a "
 2985|  2.46M|      "key may have been mutated after it was inserted into the tree.");
 2986|  2.46M|  ++size_;
 2987|  2.46M|  iter.update_generation();
 2988|  2.46M|  return iter;
 2989|  2.46M|}
_ZZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE16internal_emplaceIJmEEENS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSA_EESD_DpOT_ENKUlhE_clEh:
 2934|   312k|  const auto replace_leaf_root_node = [&](field_type new_node_size) {
 2935|       |    assert(iter.node_ == root());
 2936|   312k|    node_type *old_root = iter.node_;
 2937|   312k|    node_type *new_root = iter.node_ = new_leaf_root_node(new_node_size);
 2938|   312k|    transfer_and_delete(old_root, new_root);
 2939|   312k|    mutable_root() = mutable_rightmost() = new_root;
 2940|   312k|  };
_ZZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE16internal_emplaceIJmEEENS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSA_EESD_DpOT_ENKUlPS9_SH_E_clESH_SH_:
 2926|   312k|                                       node_type *new_node) {
 2927|   312k|    new_node->transfer_n(old_node->count(), new_node->start(),
 2928|   312k|                         old_node->start(), old_node, alloc);
 2929|   312k|    new_node->set_finish(old_node->finish());
 2930|   312k|    old_node->set_finish(old_node->start());
 2931|   312k|    new_node->set_generation(old_node->generation());
 2932|   312k|    node_type::clear_and_delete(old_node, alloc);
 2933|   312k|  };
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE18rebalance_or_splitEPNS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPS9_EE:
 2711|  88.2k|void btree<P>::rebalance_or_split(iterator *iter) {
 2712|  88.2k|  node_type *&node = iter->node_;
 2713|  88.2k|  int &insert_position = iter->position_;
 2714|  88.2k|  assert(node->count() == node->max_count());
 2715|  88.2k|  assert(kNodeSlots == node->max_count());
 2716|       |
 2717|       |  // First try to make room on the node by rebalancing.
 2718|  88.2k|  node_type *parent = node->parent();
 2719|  88.2k|  if (node != root()) {
  ------------------
  |  Branch (2719:7): [True: 77.1k, False: 11.1k]
  ------------------
 2720|  77.1k|    if (node->position() > parent->start()) {
  ------------------
  |  Branch (2720:9): [True: 77.1k, False: 0]
  ------------------
 2721|       |      // Try rebalancing with our left sibling.
 2722|  77.1k|      node_type *left = parent->child(node->position() - 1);
 2723|  77.1k|      assert(left->max_count() == kNodeSlots);
 2724|  77.1k|      if (left->count() < kNodeSlots) {
  ------------------
  |  Branch (2724:11): [True: 38.6k, False: 38.4k]
  ------------------
 2725|       |        // We bias rebalancing based on the position being inserted. If we're
 2726|       |        // inserting at the end of the right node then we bias rebalancing to
 2727|       |        // fill up the left node.
 2728|  38.6k|        field_type to_move =
 2729|  38.6k|            (kNodeSlots - left->count()) /
 2730|  38.6k|            (1 + (static_cast<field_type>(insert_position) < kNodeSlots));
 2731|  38.6k|        to_move = (std::max)(field_type{1}, to_move);
 2732|       |
 2733|  38.6k|        if (static_cast<field_type>(insert_position) - to_move >=
  ------------------
  |  Branch (2733:13): [True: 38.6k, False: 0]
  ------------------
 2734|  38.6k|                node->start() ||
 2735|  38.6k|            left->count() + to_move < kNodeSlots) {
  ------------------
  |  Branch (2735:13): [True: 0, False: 0]
  ------------------
 2736|  38.6k|          left->rebalance_right_to_left(to_move, node, mutable_allocator());
 2737|       |
 2738|  38.6k|          assert(node->max_count() - node->count() == to_move);
 2739|  38.6k|          insert_position = static_cast<int>(
 2740|  38.6k|              static_cast<field_type>(insert_position) - to_move);
 2741|  38.6k|          if (insert_position < node->start()) {
  ------------------
  |  Branch (2741:15): [True: 0, False: 38.6k]
  ------------------
 2742|      0|            insert_position = insert_position + left->count() + 1;
 2743|      0|            node = left;
 2744|      0|          }
 2745|       |
 2746|  38.6k|          assert(node->count() < node->max_count());
 2747|  38.6k|          return;
 2748|  38.6k|        }
 2749|  38.6k|      }
 2750|  77.1k|    }
 2751|       |
 2752|  38.4k|    if (node->position() < parent->finish()) {
  ------------------
  |  Branch (2752:9): [True: 0, False: 38.4k]
  ------------------
 2753|       |      // Try rebalancing with our right sibling.
 2754|      0|      node_type *right = parent->child(node->position() + 1);
 2755|      0|      assert(right->max_count() == kNodeSlots);
 2756|      0|      if (right->count() < kNodeSlots) {
  ------------------
  |  Branch (2756:11): [True: 0, False: 0]
  ------------------
 2757|       |        // We bias rebalancing based on the position being inserted. If we're
 2758|       |        // inserting at the beginning of the left node then we bias rebalancing
 2759|       |        // to fill up the right node.
 2760|      0|        field_type to_move = (kNodeSlots - right->count()) /
 2761|      0|                             (1 + (insert_position > node->start()));
 2762|      0|        to_move = (std::max)(field_type{1}, to_move);
 2763|       |
 2764|      0|        if (static_cast<field_type>(insert_position) <=
  ------------------
  |  Branch (2764:13): [True: 0, False: 0]
  ------------------
 2765|      0|                node->finish() - to_move ||
 2766|      0|            right->count() + to_move < kNodeSlots) {
  ------------------
  |  Branch (2766:13): [True: 0, False: 0]
  ------------------
 2767|      0|          node->rebalance_left_to_right(to_move, right, mutable_allocator());
 2768|       |
 2769|      0|          if (insert_position > node->finish()) {
  ------------------
  |  Branch (2769:15): [True: 0, False: 0]
  ------------------
 2770|      0|            insert_position = insert_position - node->count() - 1;
 2771|      0|            node = right;
 2772|      0|          }
 2773|       |
 2774|      0|          assert(node->count() < node->max_count());
 2775|      0|          return;
 2776|      0|        }
 2777|      0|      }
 2778|      0|    }
 2779|       |
 2780|       |    // Rebalancing failed, make sure there is room on the parent node for a new
 2781|       |    // value.
 2782|  38.4k|    assert(parent->max_count() == kNodeSlots);
 2783|  38.4k|    if (parent->count() == kNodeSlots) {
  ------------------
  |  Branch (2783:9): [True: 884, False: 37.5k]
  ------------------
 2784|    884|      iterator parent_iter(parent, node->position());
 2785|    884|      rebalance_or_split(&parent_iter);
 2786|    884|      parent = node->parent();
 2787|    884|    }
 2788|  38.4k|  } else {
 2789|       |    // Rebalancing not possible because this is the root node.
 2790|       |    // Create a new root node and set the current root node as the child of the
 2791|       |    // new root.
 2792|  11.1k|    parent = new_internal_node(/*position=*/0, parent);
 2793|  11.1k|    parent->set_generation(root()->generation());
 2794|  11.1k|    parent->init_child(parent->start(), node);
 2795|  11.1k|    mutable_root() = parent;
 2796|       |    // If the former root was a leaf node, then it's now the rightmost node.
 2797|  11.1k|    assert(parent->start_child()->is_internal() ||
 2798|  11.1k|           parent->start_child() == rightmost());
 2799|  11.1k|  }
 2800|       |
 2801|       |  // Split the node.
 2802|  49.5k|  node_type *split_node;
 2803|  49.5k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2803:7): [True: 48.9k, False: 595]
  ------------------
 2804|  48.9k|    split_node = new_leaf_node(node->position() + 1, parent);
 2805|  48.9k|    node->split(insert_position, split_node, mutable_allocator());
 2806|  48.9k|    if (rightmost() == node) mutable_rightmost() = split_node;
  ------------------
  |  Branch (2806:9): [True: 48.9k, False: 0]
  ------------------
 2807|  48.9k|  } else {
 2808|    595|    split_node = new_internal_node(node->position() + 1, parent);
 2809|    595|    node->split(insert_position, split_node, mutable_allocator());
 2810|    595|  }
 2811|       |
 2812|  49.5k|  if (insert_position > node->finish()) {
  ------------------
  |  Branch (2812:7): [True: 49.5k, False: 0]
  ------------------
 2813|  49.5k|    insert_position = insert_position - node->count() - 1;
 2814|  49.5k|    node = split_node;
 2815|  49.5k|  }
 2816|  49.5k|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE17new_internal_nodeEhPNS1_10btree_nodeIS4_EE:
 1710|  11.7k|  node_type *new_internal_node(field_type position, node_type *parent) {
 1711|  11.7k|    node_type *n = allocate(node_type::InternalSize());
 1712|  11.7k|    n->init_internal(position, parent);
 1713|  11.7k|    return n;
 1714|  11.7k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE13init_internalEhPS5_:
  960|  11.7k|  void init_internal(field_type position, btree_node *parent) {
  961|  11.7k|    init_leaf(position, kNodeSlots, parent);
  962|       |    // Set `max_count` to a sentinel value to indicate that this node is
  963|       |    // internal.
  964|  11.7k|    set_max_count(kInternalNodeMaxCount);
  965|  11.7k|    absl::container_internal::SanitizerPoisonMemoryRegion(
  966|  11.7k|        &mutable_child(start()), (kNodeSlots + 1) * sizeof(btree_node *));
  967|  11.7k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEE13new_leaf_nodeEhPNS1_10btree_nodeIS4_EE:
 1715|  48.9k|  node_type *new_leaf_node(field_type position, node_type *parent) {
 1716|  48.9k|    node_type *n = allocate(node_type::LeafSize());
 1717|  48.9k|    n->init_leaf(position, kNodeSlots, parent);
 1718|  48.9k|    return n;
 1719|  48.9k|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE5splitEiPS5_PNSt3__19allocatorImEE:
 1958|  49.5k|                          allocator_type *alloc) {
 1959|  49.5k|  assert(dest->count() == 0);
 1960|  49.5k|  assert(max_count() == kNodeSlots);
 1961|  49.5k|  assert(position() + 1 == dest->position());
 1962|  49.5k|  assert(parent() == dest->parent());
 1963|       |
 1964|       |  // We bias the split based on the position being inserted. If we're
 1965|       |  // inserting at the beginning of the left node then bias the split to put
 1966|       |  // more values on the right node. If we're inserting at the end of the
 1967|       |  // right node then bias the split to put more values on the left node.
 1968|  49.5k|  if (insert_position == start()) {
  ------------------
  |  Branch (1968:7): [True: 0, False: 49.5k]
  ------------------
 1969|      0|    dest->set_finish(dest->start() + finish() - 1);
 1970|  49.5k|  } else if (insert_position == kNodeSlots) {
  ------------------
  |  Branch (1970:14): [True: 49.5k, False: 0]
  ------------------
 1971|  49.5k|    dest->set_finish(dest->start());
 1972|  49.5k|  } else {
 1973|      0|    dest->set_finish(dest->start() + count() / 2);
 1974|      0|  }
 1975|  49.5k|  set_finish(finish() - dest->count());
 1976|  49.5k|  assert(count() >= 1);
 1977|       |
 1978|       |  // Move values from the left sibling to the right sibling.
 1979|  49.5k|  dest->transfer_n(dest->count(), dest->start(), finish(), this, alloc);
 1980|       |
 1981|       |  // The split key is the largest value in the left sibling.
 1982|  49.5k|  --mutable_finish();
 1983|  49.5k|  parent()->emplace_value(position(), alloc, finish_slot());
 1984|  49.5k|  value_destroy(finish(), alloc);
 1985|  49.5k|  parent()->set_child_noupdate_position(position() + 1, dest);
 1986|       |
 1987|  49.5k|  if (is_internal()) {
  ------------------
  |  Branch (1987:7): [True: 595, False: 48.9k]
  ------------------
 1988|  1.19k|    for (field_type i = dest->start(), j = finish() + 1; i <= dest->finish();
  ------------------
  |  Branch (1988:58): [True: 595, False: 595]
  ------------------
 1989|    595|         ++i, ++j) {
 1990|       |      assert(child(j) != nullptr);
 1991|    595|      dest->init_child(i, child(j));
 1992|    595|      clear_child(j);
 1993|    595|    }
 1994|    595|  }
 1995|  49.5k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE14mutable_finishEv:
  665|  49.5k|  field_type &mutable_finish() { return GetField<2>()[2]; }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE13emplace_valueIJPmEEEvhPNSt3__19allocatorImEEDpOT_:
 1825|  49.5k|                                         Args &&...args) {
 1826|  49.5k|  assert(i >= start());
 1827|  49.5k|  assert(i <= finish());
 1828|       |  // Shift old values to create space for new value and then construct it in
 1829|       |  // place.
 1830|  49.5k|  if (i < finish()) {
  ------------------
  |  Branch (1830:7): [True: 0, False: 49.5k]
  ------------------
 1831|      0|    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
 1832|      0|                        alloc);
 1833|      0|  }
 1834|  49.5k|  value_init(static_cast<field_type>(i), alloc, std::forward<Args>(args)...);
 1835|  49.5k|  set_finish(finish() + 1);
 1836|       |
 1837|  49.5k|  if (is_internal() && finish() > i + 1) {
  ------------------
  |  Branch (1837:7): [True: 49.5k, False: 0]
  |  Branch (1837:24): [True: 0, False: 49.5k]
  ------------------
 1838|      0|    for (field_type j = finish(); j > i + 1; --j) {
  ------------------
  |  Branch (1838:35): [True: 0, False: 0]
  ------------------
 1839|      0|      set_child(j, child(j - 1));
 1840|      0|    }
 1841|      0|    clear_child(i + 1);
 1842|      0|  }
 1843|  49.5k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE11finish_slotEv:
  668|  49.5k|  slot_type *finish_slot() { return slot(finish()); }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE13emplace_valueIJmEEEvhPNSt3__19allocatorImEEDpOT_:
 1825|  2.46M|                                         Args &&...args) {
 1826|  2.46M|  assert(i >= start());
 1827|  2.46M|  assert(i <= finish());
 1828|       |  // Shift old values to create space for new value and then construct it in
 1829|       |  // place.
 1830|  2.46M|  if (i < finish()) {
  ------------------
  |  Branch (1830:7): [True: 0, False: 2.46M]
  ------------------
 1831|      0|    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
 1832|      0|                        alloc);
 1833|      0|  }
 1834|  2.46M|  value_init(static_cast<field_type>(i), alloc, std::forward<Args>(args)...);
 1835|  2.46M|  set_finish(finish() + 1);
 1836|       |
 1837|  2.46M|  if (is_internal() && finish() > i + 1) {
  ------------------
  |  Branch (1837:7): [True: 0, False: 2.46M]
  |  Branch (1837:24): [True: 0, False: 0]
  ------------------
 1838|      0|    for (field_type j = finish(); j > i + 1; --j) {
  ------------------
  |  Branch (1838:35): [True: 0, False: 0]
  ------------------
 1839|      0|      set_child(j, child(j - 1));
 1840|      0|    }
 1841|      0|    clear_child(i + 1);
 1842|      0|  }
 1843|  2.46M|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implImJEEEE10value_initIJmEEEvhPNSt3__19allocatorImEEDpOT_:
  980|  2.46M|  void value_init(const field_type i, allocator_type *alloc, Args &&...args) {
  981|  2.46M|    next_generation();
  982|  2.46M|    absl::container_internal::SanitizerUnpoisonObject(slot(i));
  983|  2.46M|    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
  984|  2.46M|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE11equal_rangeIS8_EENSt3__14pairINS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSH_EESK_EERKT_:
 2344|  56.8k|auto btree<P>::equal_range(const K &key) -> std::pair<iterator, iterator> {
 2345|  56.8k|  const std::pair<iterator, bool> lower_and_equal = lower_bound_equal(key);
 2346|  56.8k|  const iterator lower = lower_and_equal.first;
 2347|  56.8k|  if (!lower_and_equal.second) {
  ------------------
  |  Branch (2347:7): [True: 0, False: 56.8k]
  ------------------
 2348|      0|    return {lower, lower};
 2349|      0|  }
 2350|       |
 2351|  56.8k|  const iterator next = std::next(lower);
 2352|  56.8k|  if (!params_type::template can_have_multiple_equivalent_keys<K>()) {
  ------------------
  |  Branch (2352:7): [True: 56.8k, Folded]
  ------------------
 2353|       |    // The next iterator after lower must point to a key greater than `key`.
 2354|       |    // Note: if this assert fails, then it may indicate that the comparator does
 2355|       |    // not meet the equivalence requirements for Compare
 2356|       |    // (see https://en.cppreference.com/w/cpp/named_req/Compare).
 2357|  56.8k|    assert(next == end() || compare_keys(key, next.key()));
 2358|  56.8k|    return {lower, next};
 2359|  56.8k|  }
 2360|       |  // Try once more to avoid the call to upper_bound() if there's only one
 2361|       |  // equivalent key. This should prevent all calls to upper_bound() in cases of
 2362|       |  // unique-containers with heterogeneous comparators in which all comparison
 2363|       |  // operators have the same equivalence classes.
 2364|      0|  if (next == end() || compare_keys(key, next.key())) return {lower, next};
  ------------------
  |  Branch (2364:7): [True: 0, False: 0]
  |  Branch (2364:7): [True: 0, False: 0]
  |  Branch (2364:24): [True: 0, False: 0]
  ------------------
 2365|       |
 2366|       |  // In this case, we need to call upper_bound() to avoid worst case O(N)
 2367|       |  // behavior if we were to iterate over equal keys.
 2368|      0|  return {lower, upper_bound(key)};
 2369|      0|}
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE17lower_bound_equalIS8_EENSt3__14pairINS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSH_EEbEERKT_:
 2332|  56.8k|    -> std::pair<iterator, bool> {
 2333|  56.8k|  const SearchResult<iterator, is_key_compare_to::value> res =
 2334|  56.8k|      internal_lower_bound(key);
 2335|  56.8k|  const iterator lower = iterator(internal_end(res.value));
 2336|  56.8k|  const bool equal = res.HasMatch()
  ------------------
  |  Branch (2336:22): [Folded, False: 56.8k]
  ------------------
 2337|  56.8k|                         ? res.IsEq()
 2338|  56.8k|                         : lower != end() && !compare_keys(key, lower.key());
  ------------------
  |  Branch (2338:28): [True: 56.8k, False: 0]
  |  Branch (2338:46): [True: 56.8k, False: 0]
  ------------------
 2339|  56.8k|  return {lower, equal};
 2340|  56.8k|}
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE20internal_lower_boundIS8_EENS1_12SearchResultINS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSG_EELb0EEERKT_:
 3020|  56.8k|    -> SearchResult<iterator, is_key_compare_to::value> {
 3021|  56.8k|  if (!params_type::template can_have_multiple_equivalent_keys<K>()) {
  ------------------
  |  Branch (3021:7): [True: 56.8k, Folded]
  ------------------
 3022|  56.8k|    SearchResult<iterator, is_key_compare_to::value> ret = internal_locate(key);
 3023|  56.8k|    ret.value = internal_last(ret.value);
 3024|  56.8k|    return ret;
 3025|  56.8k|  }
 3026|      0|  iterator iter(const_cast<node_type *>(root()));
 3027|      0|  SearchResult<size_type, is_key_compare_to::value> res;
 3028|      0|  bool seen_eq = false;
 3029|      0|  for (;;) {
 3030|      0|    res = iter.node_->lower_bound(key, key_comp());
 3031|      0|    iter.position_ = static_cast<int>(res.value);
 3032|      0|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (3032:9): [True: 0, False: 0]
  ------------------
 3033|      0|      break;
 3034|      0|    }
 3035|      0|    seen_eq = seen_eq || res.IsEq();
  ------------------
  |  Branch (3035:15): [True: 0, False: 0]
  |  Branch (3035:26): [Folded, False: 0]
  ------------------
 3036|      0|    iter.node_ = iter.node_->child(static_cast<field_type>(iter.position_));
 3037|      0|  }
 3038|      0|  if (res.IsEq()) return {iter, MatchKind::kEq};
  ------------------
  |  Branch (3038:7): [Folded, False: 0]
  ------------------
 3039|      0|  return {internal_last(iter), seen_eq ? MatchKind::kEq : MatchKind::kNe};
  ------------------
  |  Branch (3039:32): [True: 0, False: 0]
  ------------------
 3040|      0|}
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE12internal_endENS1_14btree_iteratorIKNS1_10btree_nodeIS9_EERKS8_PSF_EE:
 1748|  56.8k|  const_iterator internal_end(const_iterator iter) const {
 1749|  56.8k|    return iter.node_ != nullptr ? iter : end();
  ------------------
  |  Branch (1749:12): [True: 56.8k, False: 0]
  ------------------
 1750|  56.8k|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorIKNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSD_EC2ISB_SE_SF_TnNSt3__19enable_ifIXaasr3std7is_sameINS2_IT_T0_T1_EENS2_ISB_SE_SF_EEEE5valueL_ZNSI_17integral_constantIbLb1EE5valueEEEiE4typeELi0EEESN_:
 1154|  10.0M|      : btree_iterator_generation_info(other),
 1155|  10.0M|        node_(other.node_),
 1156|  10.0M|        position_(other.position_) {}
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_EC2IKSB_SD_SE_TnNSt3__19enable_ifIXaasr3std7is_sameINS2_IT_T0_T1_EENS2_ISH_SD_SE_EEEE5valueL_ZNSI_17integral_constantIbLb1EE5valueEEEiE4typeELi0EEESN_:
 1260|  56.8k|      : btree_iterator_generation_info(other.generation()),
 1261|  56.8k|        node_(const_cast<node_type *>(other.node_)),
 1262|  56.8k|        position_(other.position_) {}
_ZNK4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_EneERKNS2_IKSB_SD_SE_EE:
 1167|  56.8k|  bool operator!=(const const_iterator &other) const {
 1168|  56.8k|    return !Equals(other);
 1169|  56.8k|  }
_ZNK4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_E6EqualsENS2_IKSB_SD_SE_EE:
 1264|  9.97M|  bool Equals(const const_iterator other) const {
 1265|  9.97M|    ABSL_HARDENING_ASSERT(((node_ == nullptr && other.node_ == nullptr) ||
  ------------------
  |  |  140|  9.97M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  9.97M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 9.97M]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1266|  9.97M|                           (node_ != nullptr && other.node_ != nullptr)) &&
 1267|  9.97M|                          "Comparing default-constructed iterator with "
 1268|  9.97M|                          "non-default-constructed iterator.");
 1269|       |    // Note: we use assert instead of ABSL_HARDENING_ASSERT here because this
 1270|       |    // changes the complexity of Equals from O(1) to O(log(N) + log(M)) where
 1271|       |    // N/M are sizes of the containers containing node_/other.node_.
 1272|  9.97M|    assert(AreNodesFromSameContainer(node_, other.node_) &&
 1273|  9.97M|           "Comparing iterators from different containers.");
 1274|  9.97M|    assert_valid_generation(node_);
 1275|  9.97M|    other.assert_valid_generation(other.node_);
 1276|  9.97M|    return node_ == other.node_ && position_ == other.position_;
  ------------------
  |  Branch (1276:12): [True: 1.29M, False: 8.68M]
  |  Branch (1276:36): [True: 156k, False: 1.13M]
  ------------------
 1277|  9.97M|  }
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE3endEv:
 1457|  56.8k|  const_iterator end() const {
 1458|  56.8k|    return const_iterator(rightmost(), rightmost()->finish());
 1459|  56.8k|  }
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE9rightmostEv:
 1681|   113k|  const node_type *rightmost() const { return rightmost_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal14btree_iteratorIKNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSD_EC2EPSC_i:
 1140|  56.8k|      : btree_iterator_generation_info(n != nullptr ? n->generation()
  ------------------
  |  Branch (1140:40): [True: 56.8k, False: 0]
  ------------------
 1141|  56.8k|                                                    : ~uint32_t{}),
 1142|  56.8k|        node_(n),
 1143|  56.8k|        position_(p) {}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE11erase_rangeENS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSE_EESH_:
 2629|  56.8k|    -> std::pair<size_type, iterator> {
 2630|  56.8k|  size_type count = static_cast<size_type>(end - begin);
 2631|  56.8k|  assert(count >= 0);
 2632|       |
 2633|  56.8k|  if (count == 0) {
  ------------------
  |  Branch (2633:7): [True: 0, False: 56.8k]
  ------------------
 2634|      0|    return {0, begin};
 2635|      0|  }
 2636|       |
 2637|  56.8k|  if (static_cast<size_type>(count) == size_) {
  ------------------
  |  Branch (2637:7): [True: 670, False: 56.1k]
  ------------------
 2638|    670|    clear();
 2639|    670|    return {count, this->end()};
 2640|    670|  }
 2641|       |
 2642|  56.1k|  if (begin.node_ == end.node_) {
  ------------------
  |  Branch (2642:7): [True: 53.6k, False: 2.49k]
  ------------------
 2643|  53.6k|    assert(end.position_ > begin.position_);
 2644|  53.6k|    begin.node_->remove_values(
 2645|  53.6k|        static_cast<field_type>(begin.position_),
 2646|  53.6k|        static_cast<field_type>(end.position_ - begin.position_),
 2647|  53.6k|        mutable_allocator());
 2648|  53.6k|    size_ -= count;
 2649|  53.6k|    return {count, rebalance_after_delete(begin)};
 2650|  53.6k|  }
 2651|       |
 2652|  2.49k|  const size_type target_size = size_ - count;
 2653|  4.98k|  while (size_ > target_size) {
  ------------------
  |  Branch (2653:10): [True: 2.49k, False: 2.49k]
  ------------------
 2654|  2.49k|    if (begin.node_->is_leaf()) {
  ------------------
  |  Branch (2654:9): [True: 1.25k, False: 1.24k]
  ------------------
 2655|  1.25k|      const size_type remaining_to_erase = size_ - target_size;
 2656|  1.25k|      const size_type remaining_in_node =
 2657|  1.25k|          static_cast<size_type>(begin.node_->finish() - begin.position_);
 2658|  1.25k|      const field_type to_erase = static_cast<field_type>(
 2659|  1.25k|          (std::min)(remaining_to_erase, remaining_in_node));
 2660|  1.25k|      begin.node_->remove_values(static_cast<field_type>(begin.position_),
 2661|  1.25k|                                 to_erase, mutable_allocator());
 2662|  1.25k|      size_ -= to_erase;
 2663|  1.25k|      begin = rebalance_after_delete(begin);
 2664|  1.25k|    } else {
 2665|  1.24k|      begin = erase(begin);
 2666|  1.24k|    }
 2667|  2.49k|  }
 2668|  2.49k|  begin.update_generation();
 2669|  2.49k|  return {count, begin};
 2670|  56.1k|}
_ZNK4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_EmiENS2_IKSB_SD_SE_EE:
 1173|  56.8k|  difference_type operator-(const_iterator other) const {
 1174|  56.8k|    if (node_ == other.node_) {
  ------------------
  |  Branch (1174:9): [True: 54.3k, False: 2.49k]
  ------------------
 1175|  54.3k|      if (node_->is_leaf()) return position_ - other.position_;
  ------------------
  |  Branch (1175:11): [True: 54.3k, False: 0]
  ------------------
 1176|      0|      if (position_ == other.position_) return 0;
  ------------------
  |  Branch (1176:11): [True: 0, False: 0]
  ------------------
 1177|      0|    }
 1178|  2.49k|    return distance_slow(other);
 1179|  56.8k|  }
_ZNK4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_E13distance_slowENS2_IKSB_SD_SE_EE:
 2098|  2.49k|    -> difference_type {
 2099|  2.49k|  const_iterator begin = other;
 2100|  2.49k|  const_iterator end = *this;
 2101|  2.49k|  assert(begin.node_ != end.node_ || !begin.node_->is_leaf() ||
 2102|  2.49k|         begin.position_ != end.position_);
 2103|       |
 2104|  2.49k|  const node_type *node = begin.node_;
 2105|       |  // We need to compensate for double counting if begin.node_ is a leaf node.
 2106|  2.49k|  difference_type count = node->is_leaf() ? -begin.position_ : 0;
  ------------------
  |  Branch (2106:27): [True: 1.25k, False: 1.24k]
  ------------------
 2107|       |
 2108|       |  // First navigate to the leftmost leaf node past begin.
 2109|  2.49k|  if (node->is_internal()) {
  ------------------
  |  Branch (2109:7): [True: 1.24k, False: 1.25k]
  ------------------
 2110|  1.24k|    ++count;
 2111|  1.24k|    node = node->child(begin.position_ + 1);
 2112|  1.24k|  }
 2113|  2.49k|  while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (2113:10): [True: 1, False: 2.49k]
  ------------------
 2114|       |
 2115|       |  // Use `size_type` because `pos` needs to be able to hold `kNodeSlots+1`,
 2116|       |  // which isn't guaranteed to be a valid `field_type`.
 2117|  2.49k|  size_type pos = node->position();
 2118|  2.49k|  const node_type *parent = node->parent();
 2119|  2.49k|  for (;;) {
 2120|       |    // In each iteration of the next loop, we count one leaf node and go right.
 2121|  2.49k|    assert(pos <= parent->finish());
 2122|  2.49k|    do {
 2123|  2.49k|      node = parent->child(static_cast<field_type>(pos));
 2124|  2.49k|      if (node->is_internal()) {
  ------------------
  |  Branch (2124:11): [True: 0, False: 2.49k]
  ------------------
 2125|       |        // Navigate to the leftmost leaf under node.
 2126|      0|        while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (2126:16): [True: 0, False: 0]
  ------------------
 2127|      0|        pos = node->position();
 2128|      0|        parent = node->parent();
 2129|      0|      }
 2130|  2.49k|      if (node == end.node_) return count + end.position_;
  ------------------
  |  Branch (2130:11): [True: 1.24k, False: 1.25k]
  ------------------
 2131|  1.25k|      if (parent == end.node_ && pos == static_cast<size_type>(end.position_))
  ------------------
  |  Branch (2131:11): [True: 1.25k, False: 1]
  |  Branch (2131:34): [True: 1.25k, False: 0]
  ------------------
 2132|  1.25k|        return count + node->count();
 2133|       |      // +1 is for the next internal node value.
 2134|      1|      count += node->count() + 1;
 2135|      1|      ++pos;
 2136|      1|    } while (pos <= parent->finish());
  ------------------
  |  Branch (2136:14): [True: 0, False: 1]
  ------------------
 2137|       |
 2138|       |    // Once we've counted all children of parent, go up/right.
 2139|  2.49k|    assert(pos > parent->finish());
 2140|      1|    do {
 2141|      1|      node = parent;
 2142|      1|      pos = node->position();
 2143|      1|      parent = node->parent();
 2144|       |      // -1 because we counted the value at end and shouldn't.
 2145|      1|      if (parent == end.node_ && pos == static_cast<size_type>(end.position_))
  ------------------
  |  Branch (2145:11): [True: 1, False: 0]
  |  Branch (2145:34): [True: 1, False: 0]
  ------------------
 2146|      1|        return count - 1;
 2147|      0|      ++pos;
 2148|      0|    } while (pos > parent->finish());
  ------------------
  |  Branch (2148:14): [True: 0, False: 0]
  ------------------
 2149|      1|  }
 2150|  2.49k|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE3endEv:
 1456|   258k|  iterator end() { return iterator(rightmost(), rightmost()->finish()); }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13remove_valuesEhhPNSt3__19allocatorIS8_EE:
 1848|  55.6k|                                         allocator_type *alloc) {
 1849|       |  // Transfer values after the removed range into their new places.
 1850|  55.6k|  value_destroy_n(i, to_erase, alloc);
 1851|  55.6k|  const field_type orig_finish = finish();
 1852|  55.6k|  const field_type src_i = i + to_erase;
 1853|  55.6k|  transfer_n(orig_finish - src_i, i, src_i, this, alloc);
 1854|       |
 1855|  55.6k|  if (is_internal()) {
  ------------------
  |  Branch (1855:7): [True: 752, False: 54.9k]
  ------------------
 1856|       |    // Delete all children between begin and end.
 1857|  1.50k|    for (field_type j = 0; j < to_erase; ++j) {
  ------------------
  |  Branch (1857:28): [True: 752, False: 752]
  ------------------
 1858|    752|      clear_and_delete(child(i + j + 1), alloc);
 1859|    752|    }
 1860|       |    // Rotate children after end into new positions.
 1861|  2.52k|    for (field_type j = i + to_erase + 1; j <= orig_finish; ++j) {
  ------------------
  |  Branch (1861:43): [True: 1.77k, False: 752]
  ------------------
 1862|  1.77k|      set_child(j - to_erase, child(j));
 1863|  1.77k|      clear_child(j);
 1864|  1.77k|    }
 1865|    752|  }
 1866|  55.6k|  set_finish(orig_finish - to_erase);
 1867|  55.6k|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE22rebalance_after_deleteENS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSE_EE:
 2583|  56.1k|auto btree<P>::rebalance_after_delete(iterator iter) -> iterator {
 2584|       |  // Merge/rebalance as we walk back up the tree.
 2585|  56.1k|  iterator res(iter);
 2586|  56.1k|  bool first_iteration = true;
 2587|  56.9k|  for (;;) {
 2588|  56.9k|    if (iter.node_ == root()) {
  ------------------
  |  Branch (2588:9): [True: 16.1k, False: 40.7k]
  ------------------
 2589|  16.1k|      try_shrink();
 2590|  16.1k|      if (empty()) {
  ------------------
  |  Branch (2590:11): [True: 0, False: 16.1k]
  ------------------
 2591|      0|        return end();
 2592|      0|      }
 2593|  16.1k|      break;
 2594|  16.1k|    }
 2595|  40.7k|    if (iter.node_->count() >= kMinNodeValues) {
  ------------------
  |  Branch (2595:9): [True: 37.4k, False: 3.36k]
  ------------------
 2596|  37.4k|      break;
 2597|  37.4k|    }
 2598|  3.36k|    bool merged = try_merge_or_rebalance(&iter);
 2599|       |    // On the first iteration, we should update `res` with `iter` because `res`
 2600|       |    // may have been invalidated.
 2601|  3.36k|    if (first_iteration) {
  ------------------
  |  Branch (2601:9): [True: 3.35k, False: 8]
  ------------------
 2602|  3.35k|      res = iter;
 2603|  3.35k|      first_iteration = false;
 2604|  3.35k|    }
 2605|  3.36k|    if (!merged) {
  ------------------
  |  Branch (2605:9): [True: 2.61k, False: 752]
  ------------------
 2606|  2.61k|      break;
 2607|  2.61k|    }
 2608|    752|    iter.position_ = iter.node_->position();
 2609|    752|    iter.node_ = iter.node_->parent();
 2610|    752|  }
 2611|  56.1k|  res.update_generation();
 2612|       |
 2613|       |  // Adjust our return value. If we're pointing at the end of a node, advance
 2614|       |  // the iterator.
 2615|  56.1k|  if (res.position_ == res.node_->finish()) {
  ------------------
  |  Branch (2615:7): [True: 4.28k, False: 51.8k]
  ------------------
 2616|  4.28k|    res.position_ = res.node_->finish() - 1;
 2617|  4.28k|    ++res;
 2618|  4.28k|  }
 2619|       |
 2620|  56.1k|  return res;
 2621|  56.1k|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10try_shrinkEv:
 2879|  16.1k|void btree<P>::try_shrink() {
 2880|  16.1k|  node_type *orig_root = root();
 2881|  16.1k|  if (orig_root->count() > 0) {
  ------------------
  |  Branch (2881:7): [True: 15.7k, False: 406]
  ------------------
 2882|  15.7k|    return;
 2883|  15.7k|  }
 2884|       |  // Deleted the last item on the root node, shrink the height of the tree.
 2885|    406|  if (orig_root->is_leaf()) {
  ------------------
  |  Branch (2885:7): [True: 0, False: 406]
  ------------------
 2886|      0|    assert(size() == 0);
 2887|      0|    mutable_root() = mutable_rightmost() = EmptyNode();
 2888|    406|  } else {
 2889|    406|    node_type *child = orig_root->start_child();
 2890|    406|    child->make_root();
 2891|    406|    mutable_root() = child;
 2892|    406|  }
 2893|    406|  node_type::clear_and_delete(orig_root, mutable_allocator());
 2894|    406|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE9make_rootEv:
  719|    406|  void make_root() {
  720|       |    assert(parent()->is_root());
  721|    406|    set_generation(parent()->generation());
  722|    406|    set_parent(parent()->parent());
  723|    406|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE22try_merge_or_rebalanceEPNS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSE_EE:
 2825|  3.36k|bool btree<P>::try_merge_or_rebalance(iterator *iter) {
 2826|  3.36k|  node_type *parent = iter->node_->parent();
 2827|  3.36k|  if (iter->node_->position() > parent->start()) {
  ------------------
  |  Branch (2827:7): [True: 1.55k, False: 1.80k]
  ------------------
 2828|       |    // Try merging with our left sibling.
 2829|  1.55k|    node_type *left = parent->child(iter->node_->position() - 1);
 2830|  1.55k|    assert(left->max_count() == kNodeSlots);
 2831|  1.55k|    if (1U + left->count() + iter->node_->count() <= kNodeSlots) {
  ------------------
  |  Branch (2831:9): [True: 288, False: 1.27k]
  ------------------
 2832|    288|      iter->position_ += 1 + left->count();
 2833|    288|      merge_nodes(left, iter->node_);
 2834|    288|      iter->node_ = left;
 2835|    288|      return true;
 2836|    288|    }
 2837|  1.55k|  }
 2838|  3.07k|  if (iter->node_->position() < parent->finish()) {
  ------------------
  |  Branch (2838:7): [True: 2.48k, False: 596]
  ------------------
 2839|       |    // Try merging with our right sibling.
 2840|  2.48k|    node_type *right = parent->child(iter->node_->position() + 1);
 2841|  2.48k|    assert(right->max_count() == kNodeSlots);
 2842|  2.48k|    if (1U + iter->node_->count() + right->count() <= kNodeSlots) {
  ------------------
  |  Branch (2842:9): [True: 464, False: 2.01k]
  ------------------
 2843|    464|      merge_nodes(iter->node_, right);
 2844|    464|      return true;
 2845|    464|    }
 2846|       |    // Try rebalancing with our right sibling. We don't perform rebalancing if
 2847|       |    // we deleted the first element from iter->node_ and the node is not
 2848|       |    // empty. This is a small optimization for the common pattern of deleting
 2849|       |    // from the front of the tree.
 2850|  2.01k|    if (right->count() > kMinNodeValues &&
  ------------------
  |  Branch (2850:9): [True: 2.01k, False: 0]
  ------------------
 2851|  2.01k|        (iter->node_->count() == 0 || iter->position_ > iter->node_->start())) {
  ------------------
  |  Branch (2851:10): [True: 0, False: 2.01k]
  |  Branch (2851:39): [True: 1.83k, False: 185]
  ------------------
 2852|  1.83k|      field_type to_move = (right->count() - iter->node_->count()) / 2;
 2853|  1.83k|      to_move =
 2854|  1.83k|          (std::min)(to_move, static_cast<field_type>(right->count() - 1));
 2855|  1.83k|      iter->node_->rebalance_right_to_left(to_move, right, mutable_allocator());
 2856|  1.83k|      return false;
 2857|  1.83k|    }
 2858|  2.01k|  }
 2859|    781|  if (iter->node_->position() > parent->start()) {
  ------------------
  |  Branch (2859:7): [True: 642, False: 139]
  ------------------
 2860|       |    // Try rebalancing with our left sibling. We don't perform rebalancing if
 2861|       |    // we deleted the last element from iter->node_ and the node is not
 2862|       |    // empty. This is a small optimization for the common pattern of deleting
 2863|       |    // from the back of the tree.
 2864|    642|    node_type *left = parent->child(iter->node_->position() - 1);
 2865|    642|    if (left->count() > kMinNodeValues &&
  ------------------
  |  Branch (2865:9): [True: 642, False: 0]
  ------------------
 2866|    642|        (iter->node_->count() == 0 ||
  ------------------
  |  Branch (2866:10): [True: 0, False: 642]
  ------------------
 2867|    642|         iter->position_ < iter->node_->finish())) {
  ------------------
  |  Branch (2867:10): [True: 588, False: 54]
  ------------------
 2868|    588|      field_type to_move = (left->count() - iter->node_->count()) / 2;
 2869|    588|      to_move = (std::min)(to_move, static_cast<field_type>(left->count() - 1));
 2870|    588|      left->rebalance_left_to_right(to_move, iter->node_, mutable_allocator());
 2871|    588|      iter->position_ += to_move;
 2872|    588|      return false;
 2873|    588|    }
 2874|    642|  }
 2875|    193|  return false;
 2876|    781|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE11merge_nodesEPNS1_10btree_nodeIS9_EESD_:
 2819|    752|void btree<P>::merge_nodes(node_type *left, node_type *right) {
 2820|    752|  left->merge(right, mutable_allocator());
 2821|    752|  if (rightmost() == right) mutable_rightmost() = left;
  ------------------
  |  Branch (2821:7): [True: 513, False: 239]
  ------------------
 2822|    752|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE5mergeEPSA_PNSt3__19allocatorIS8_EE:
 1998|    752|void btree_node<P>::merge(btree_node *src, allocator_type *alloc) {
 1999|    752|  assert(parent() == src->parent());
 2000|    752|  assert(position() + 1 == src->position());
 2001|       |
 2002|       |  // Move the delimiting value to the left node.
 2003|    752|  value_init(finish(), alloc, parent()->slot(position()));
 2004|       |
 2005|       |  // Move the values from the right to the left node.
 2006|    752|  transfer_n(src->count(), finish() + 1, src->start(), src, alloc);
 2007|       |
 2008|    752|  if (is_internal()) {
  ------------------
  |  Branch (2008:7): [True: 1, False: 751]
  ------------------
 2009|       |    // Move the child pointers from the right to the left node.
 2010|     16|    for (field_type i = src->start(), j = finish() + 1; i <= src->finish();
  ------------------
  |  Branch (2010:57): [True: 15, False: 1]
  ------------------
 2011|     15|         ++i, ++j) {
 2012|     15|      init_child(j, src->child(i));
 2013|     15|      src->clear_child(i);
 2014|     15|    }
 2015|      1|  }
 2016|       |
 2017|       |  // Fixup `finish` on the src and dest nodes.
 2018|    752|  set_finish(start() + 1 + count() + src->count());
 2019|    752|  src->set_finish(src->start());
 2020|       |
 2021|       |  // Remove the value on the parent node and delete the src node.
 2022|    752|  parent()->remove_values(position(), /*to_erase=*/1, alloc);
 2023|    752|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE5eraseENS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSE_EE:
 2535|  1.24k|auto btree<P>::erase(iterator iter) -> iterator {
 2536|  1.24k|  iter.node_->value_destroy(static_cast<field_type>(iter.position_),
 2537|  1.24k|                            mutable_allocator());
 2538|  1.24k|  iter.update_generation();
 2539|       |
 2540|  1.24k|  const bool internal_delete = iter.node_->is_internal();
 2541|  1.24k|  if (internal_delete) {
  ------------------
  |  Branch (2541:7): [True: 1.24k, False: 0]
  ------------------
 2542|       |    // Deletion of a value on an internal node. First, transfer the largest
 2543|       |    // value from our left child here, then erase/rebalance from that position.
 2544|       |    // We can get to the largest value from our left child by decrementing iter.
 2545|  1.24k|    iterator internal_iter(iter);
 2546|  1.24k|    --iter;
 2547|  1.24k|    assert(iter.node_->is_leaf());
 2548|  1.24k|    internal_iter.node_->transfer(
 2549|  1.24k|        static_cast<size_type>(internal_iter.position_),
 2550|  1.24k|        static_cast<size_type>(iter.position_), iter.node_,
 2551|  1.24k|        mutable_allocator());
 2552|  1.24k|  } else {
 2553|       |    // Shift values after erased position in leaf. In the internal case, we
 2554|       |    // don't need to do this because the leaf position is the end of the node.
 2555|      0|    const field_type transfer_from =
 2556|      0|        static_cast<field_type>(iter.position_ + 1);
 2557|      0|    const field_type num_to_transfer = iter.node_->finish() - transfer_from;
 2558|      0|    iter.node_->transfer_n(num_to_transfer,
 2559|      0|                           static_cast<size_type>(iter.position_),
 2560|      0|                           transfer_from, iter.node_, mutable_allocator());
 2561|      0|  }
 2562|       |  // Update node finish and container size.
 2563|  1.24k|  iter.node_->set_finish(iter.node_->finish() - 1);
 2564|  1.24k|  --size_;
 2565|       |
 2566|       |  // We want to return the next value after the one we just erased. If we
 2567|       |  // erased from an internal node (internal_delete == true), then the next
 2568|       |  // value is ++(++iter). If we erased from a leaf node (internal_delete ==
 2569|       |  // false) then the next value is ++iter. Note that ++iter may point to an
 2570|       |  // internal node and the value in the internal node may move to a leaf node
 2571|       |  // (iter.node_) when rebalancing is performed at the leaf level.
 2572|       |
 2573|  1.24k|  iterator res = rebalance_after_delete(iter);
 2574|       |
 2575|       |  // If we erased from an internal node, advance the iterator.
 2576|  1.24k|  if (internal_delete) {
  ------------------
  |  Branch (2576:7): [True: 1.24k, False: 0]
  ------------------
 2577|  1.24k|    ++res;
 2578|  1.24k|  }
 2579|  1.24k|  return res;
 2580|  1.24k|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE22insert_iterator_uniqueINSt3__111__wrap_iterIPS8_EEbEEvT_SG_i:
 2424|  1.78k|void btree<P>::insert_iterator_unique(InputIterator b, InputIterator e, int) {
 2425|   102k|  for (; b != e; ++b) {
  ------------------
  |  Branch (2425:10): [True: 101k, False: 1.78k]
  ------------------
 2426|   101k|    insert_hint_unique(end(), params_type::key(*b), *b);
 2427|   101k|  }
 2428|  1.78k|}
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE18insert_hint_uniqueIS8_JRS8_EEENSt3__14pairINS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSI_EEbEESL_RKT_DpOT0_:
 2401|   101k|    -> std::pair<iterator, bool> {
 2402|   101k|  if (!empty()) {
  ------------------
  |  Branch (2402:7): [True: 99.4k, False: 1.75k]
  ------------------
 2403|  99.4k|    if (position == end() || compare_keys(key, position.key())) {
  ------------------
  |  Branch (2403:9): [True: 99.4k, False: 0]
  |  Branch (2403:9): [True: 99.4k, False: 0]
  |  Branch (2403:30): [True: 0, False: 0]
  ------------------
 2404|  99.4k|      if (position == begin() || compare_keys(std::prev(position).key(), key)) {
  ------------------
  |  Branch (2404:11): [True: 0, False: 99.4k]
  |  Branch (2404:11): [True: 5.04k, False: 94.4k]
  |  Branch (2404:34): [True: 5.04k, False: 94.4k]
  ------------------
 2405|       |        // prev.key() < key < position.key()
 2406|  5.04k|        return {internal_emplace(position, std::forward<Args>(args)...), true};
 2407|  5.04k|      }
 2408|  99.4k|    } else if (compare_keys(position.key(), key)) {
  ------------------
  |  Branch (2408:16): [True: 0, False: 0]
  ------------------
 2409|      0|      ++position;
 2410|      0|      if (position == end() || compare_keys(key, position.key())) {
  ------------------
  |  Branch (2410:11): [True: 0, False: 0]
  |  Branch (2410:11): [True: 0, False: 0]
  |  Branch (2410:32): [True: 0, False: 0]
  ------------------
 2411|       |        // {original `position`}.key() < key < {current `position`}.key()
 2412|      0|        return {internal_emplace(position, std::forward<Args>(args)...), true};
 2413|      0|      }
 2414|      0|    } else {
 2415|       |      // position.key() == key
 2416|      0|      return {position, false};
 2417|      0|    }
 2418|  99.4k|  }
 2419|  96.1k|  return insert_unique(key, std::forward<Args>(args)...);
 2420|   101k|}
_ZNK4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_EeqERKSF_:
 1158|   198k|  bool operator==(const iterator &other) const {
 1159|   198k|    return Equals(other);
 1160|   198k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE5beginEv:
 1454|   156k|  iterator begin() { return iterator(leftmost()); }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE8leftmostEv:
 1690|   156k|  node_type *leftmost() { return root()->parent(); }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE16internal_emplaceIJRS8_EEENS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSG_EESJ_DpOT_:
 2915|   101k|    -> iterator {
 2916|   101k|  if (iter.node_->is_internal()) {
  ------------------
  |  Branch (2916:7): [True: 0, False: 101k]
  ------------------
 2917|       |    // We can't insert on an internal node. Instead, we'll insert after the
 2918|       |    // previous value which is guaranteed to be on a leaf node.
 2919|      0|    --iter;
 2920|      0|    ++iter.position_;
 2921|      0|  }
 2922|   101k|  const field_type max_count = iter.node_->max_count();
 2923|   101k|  allocator_type *alloc = mutable_allocator();
 2924|       |
 2925|   101k|  const auto transfer_and_delete = [&](node_type *old_node,
 2926|   101k|                                       node_type *new_node) {
 2927|   101k|    new_node->transfer_n(old_node->count(), new_node->start(),
 2928|   101k|                         old_node->start(), old_node, alloc);
 2929|   101k|    new_node->set_finish(old_node->finish());
 2930|   101k|    old_node->set_finish(old_node->start());
 2931|   101k|    new_node->set_generation(old_node->generation());
 2932|   101k|    node_type::clear_and_delete(old_node, alloc);
 2933|   101k|  };
 2934|   101k|  const auto replace_leaf_root_node = [&](field_type new_node_size) {
 2935|   101k|    assert(iter.node_ == root());
 2936|   101k|    node_type *old_root = iter.node_;
 2937|   101k|    node_type *new_root = iter.node_ = new_leaf_root_node(new_node_size);
 2938|   101k|    transfer_and_delete(old_root, new_root);
 2939|   101k|    mutable_root() = mutable_rightmost() = new_root;
 2940|   101k|  };
 2941|       |
 2942|   101k|  bool replaced_node = false;
 2943|   101k|  if (iter.node_->count() == max_count) {
  ------------------
  |  Branch (2943:7): [True: 21.3k, False: 79.9k]
  ------------------
 2944|       |    // Make room in the leaf for the new item.
 2945|  21.3k|    if (max_count < kNodeSlots) {
  ------------------
  |  Branch (2945:9): [True: 6.85k, False: 14.4k]
  ------------------
 2946|       |      // Insertion into the root where the root is smaller than the full node
 2947|       |      // size. Simply grow the size of the root node.
 2948|  6.85k|      replace_leaf_root_node(static_cast<field_type>(
 2949|  6.85k|          (std::min)(static_cast<int>(kNodeSlots), 2 * max_count)));
 2950|  6.85k|      replaced_node = true;
 2951|  14.4k|    } else {
 2952|  14.4k|      rebalance_or_split(&iter);
 2953|  14.4k|    }
 2954|  21.3k|  }
 2955|   101k|  (void)replaced_node;
 2956|       |#if defined(ABSL_HAVE_ADDRESS_SANITIZER) || \
 2957|       |    defined(ABSL_HAVE_HWADDRESS_SANITIZER)
 2958|       |  if (!replaced_node) {
 2959|       |    assert(iter.node_->is_leaf());
 2960|       |    if (iter.node_->is_root()) {
 2961|       |      replace_leaf_root_node(max_count);
 2962|       |    } else {
 2963|       |      node_type *old_node = iter.node_;
 2964|       |      const bool was_rightmost = rightmost() == old_node;
 2965|       |      const bool was_leftmost = leftmost() == old_node;
 2966|       |      node_type *parent = old_node->parent();
 2967|       |      const field_type position = old_node->position();
 2968|       |      node_type *new_node = iter.node_ = new_leaf_node(position, parent);
 2969|       |      parent->set_child_noupdate_position(position, new_node);
 2970|       |      transfer_and_delete(old_node, new_node);
 2971|       |      if (was_rightmost) mutable_rightmost() = new_node;
 2972|       |      // The leftmost node is stored as the parent of the root node.
 2973|       |      if (was_leftmost) root()->set_parent(new_node);
 2974|       |    }
 2975|       |  }
 2976|       |#endif
 2977|   101k|  iter.node_->emplace_value(static_cast<field_type>(iter.position_), alloc,
 2978|   101k|                            std::forward<Args>(args)...);
 2979|       |  assert(
 2980|   101k|      iter.node_->is_ordered_correctly(static_cast<field_type>(iter.position_),
 2981|   101k|                                       original_key_compare(key_comp())) &&
 2982|   101k|      "If this assert fails, then either (1) the comparator may violate "
 2983|   101k|      "transitivity, i.e. comp(a,b) && comp(b,c) -> comp(a,c) (see "
 2984|   101k|      "https://en.cppreference.com/w/cpp/named_req/Compare), or (2) a "
 2985|   101k|      "key may have been mutated after it was inserted into the tree.");
 2986|   101k|  ++size_;
 2987|   101k|  iter.update_generation();
 2988|   101k|  return iter;
 2989|   101k|}
_ZZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE16internal_emplaceIJRS8_EEENS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSG_EESJ_DpOT_ENKUlhE_clEh:
 2934|  6.85k|  const auto replace_leaf_root_node = [&](field_type new_node_size) {
 2935|       |    assert(iter.node_ == root());
 2936|  6.85k|    node_type *old_root = iter.node_;
 2937|  6.85k|    node_type *new_root = iter.node_ = new_leaf_root_node(new_node_size);
 2938|  6.85k|    transfer_and_delete(old_root, new_root);
 2939|  6.85k|    mutable_root() = mutable_rightmost() = new_root;
 2940|  6.85k|  };
_ZZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE16internal_emplaceIJRS8_EEENS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSG_EESJ_DpOT_ENKUlPSF_SN_E_clESN_SN_:
 2926|  6.85k|                                       node_type *new_node) {
 2927|  6.85k|    new_node->transfer_n(old_node->count(), new_node->start(),
 2928|  6.85k|                         old_node->start(), old_node, alloc);
 2929|  6.85k|    new_node->set_finish(old_node->finish());
 2930|  6.85k|    old_node->set_finish(old_node->start());
 2931|  6.85k|    new_node->set_generation(old_node->generation());
 2932|  6.85k|    node_type::clear_and_delete(old_node, alloc);
 2933|  6.85k|  };
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13emplace_valueIJRS8_EEEvhPNSt3__19allocatorIS8_EEDpOT_:
 1825|   101k|                                         Args &&...args) {
 1826|   101k|  assert(i >= start());
 1827|   101k|  assert(i <= finish());
 1828|       |  // Shift old values to create space for new value and then construct it in
 1829|       |  // place.
 1830|   101k|  if (i < finish()) {
  ------------------
  |  Branch (1830:7): [True: 92.0k, False: 9.20k]
  ------------------
 1831|  92.0k|    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
 1832|  92.0k|                        alloc);
 1833|  92.0k|  }
 1834|   101k|  value_init(static_cast<field_type>(i), alloc, std::forward<Args>(args)...);
 1835|   101k|  set_finish(finish() + 1);
 1836|       |
 1837|   101k|  if (is_internal() && finish() > i + 1) {
  ------------------
  |  Branch (1837:7): [True: 0, False: 101k]
  |  Branch (1837:24): [True: 0, False: 0]
  ------------------
 1838|      0|    for (field_type j = finish(); j > i + 1; --j) {
  ------------------
  |  Branch (1838:35): [True: 0, False: 0]
  ------------------
 1839|      0|      set_child(j, child(j - 1));
 1840|      0|    }
 1841|      0|    clear_child(i + 1);
 1842|      0|  }
 1843|   101k|}
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE10value_initIJRS8_EEEvhPNSt3__19allocatorIS8_EEDpOT_:
  980|   101k|  void value_init(const field_type i, allocator_type *alloc, Args &&...args) {
  981|   101k|    next_generation();
  982|   101k|    absl::container_internal::SanitizerUnpoisonObject(slot(i));
  983|   101k|    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
  984|   101k|  }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE13insert_uniqueIS8_JRS8_EEENSt3__14pairINS1_14btree_iteratorINS1_10btree_nodeIS9_EERKS8_PSI_EEbEERKT_DpOT0_:
 2374|  96.1k|    -> std::pair<iterator, bool> {
 2375|  96.1k|  if (empty()) {
  ------------------
  |  Branch (2375:7): [True: 1.75k, False: 94.4k]
  ------------------
 2376|  1.75k|    mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
 2377|  1.75k|  }
 2378|       |
 2379|  96.1k|  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
 2380|  96.1k|  iterator iter = res.value;
 2381|       |
 2382|  96.1k|  if (res.HasMatch()) {
  ------------------
  |  Branch (2382:7): [Folded, False: 96.1k]
  ------------------
 2383|      0|    if (res.IsEq()) {
  ------------------
  |  Branch (2383:9): [Folded, False: 0]
  ------------------
 2384|       |      // The key already exists in the tree, do nothing.
 2385|      0|      return {iter, false};
 2386|      0|    }
 2387|  96.1k|  } else {
 2388|  96.1k|    iterator last = internal_last(iter);
 2389|  96.1k|    if (last.node_ && !compare_keys(key, last.key())) {
  ------------------
  |  Branch (2389:9): [True: 94.4k, False: 1.75k]
  |  Branch (2389:23): [True: 0, False: 94.4k]
  ------------------
 2390|       |      // The key already exists in the tree, do nothing.
 2391|      0|      return {last, false};
 2392|      0|    }
 2393|  96.1k|  }
 2394|  96.1k|  return {internal_emplace(iter, std::forward<Args>(args)...), true};
 2395|  96.1k|}
_ZNK4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_EneERKSF_:
 1164|  9.71M|  bool operator!=(const iterator &other) const {
 1165|  9.71M|    return !Equals(other);
 1166|  9.71M|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_EppEv:
 1214|  9.72M|  btree_iterator &operator++() {
 1215|  9.72M|    increment();
 1216|  9.72M|    return *this;
 1217|  9.72M|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_E9incrementEv:
 1295|  9.72M|  void increment() {
 1296|  9.72M|    assert_valid_generation(node_);
 1297|  9.72M|    if (node_->is_leaf() && ++position_ < node_->finish()) {
  ------------------
  |  Branch (1297:9): [True: 9.39M, False: 328k]
  |  Branch (1297:29): [True: 9.00M, False: 391k]
  ------------------
 1298|  9.00M|      return;
 1299|  9.00M|    }
 1300|   719k|    increment_slow();
 1301|   719k|  }
_ZN4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_E14increment_slowEv:
 2153|   719k|void btree_iterator<N, R, P>::increment_slow() {
 2154|   719k|  N* node = node_;
 2155|   719k|  int position = position_;
 2156|   719k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2156:7): [True: 391k, False: 328k]
  ------------------
 2157|   391k|    assert(position >= node->finish());
 2158|   768k|    while (position == node->finish() && !node->is_root()) {
  ------------------
  |  Branch (2158:12): [True: 439k, False: 329k]
  |  Branch (2158:42): [True: 377k, False: 61.6k]
  ------------------
 2159|   377k|      assert(node->parent()->child(node->position()) == node);
 2160|   377k|      position = node->position();
 2161|   377k|      node = node->parent();
 2162|   377k|    }
 2163|       |    // TODO(ezb): assert we aren't incrementing end() instead of handling.
 2164|   391k|    if (position == node->finish()) {
  ------------------
  |  Branch (2164:9): [True: 61.6k, False: 329k]
  ------------------
 2165|  61.6k|      return;
 2166|  61.6k|    }
 2167|   391k|  } else {
 2168|   328k|    assert(position < node->finish());
 2169|   328k|    node = node->child(static_cast<field_type>(position + 1));
 2170|   331k|    while (node->is_internal()) {
  ------------------
  |  Branch (2170:12): [True: 3.50k, False: 328k]
  ------------------
 2171|  3.50k|      node = node->start_child();
 2172|  3.50k|    }
 2173|   328k|    position = node->start();
 2174|   328k|  }
 2175|   658k|  *this = {node, position};
 2176|   658k|}
_ZNK4absl12lts_2026010718container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEERKS9_PSC_EdeEv:
 1202|  9.66M|  reference operator*() const {
 1203|  9.66M|    ABSL_HARDENING_ASSERT(node_ != nullptr);
  ------------------
  |  |  140|  9.66M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  9.66M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 9.66M]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1204|  9.66M|    assert_valid_generation(node_);
 1205|  9.66M|    ABSL_HARDENING_ASSERT(position_ >= node_->start());
  ------------------
  |  |  140|  9.66M|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|  9.66M|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 9.66M]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1206|  9.66M|    if (position_ >= node_->finish()) {
  ------------------
  |  Branch (1206:9): [True: 0, False: 9.66M]
  ------------------
 1207|      0|      ABSL_HARDENING_ASSERT(!IsEndIterator() && "Dereferencing end() iterator");
  ------------------
  |  |  140|      0|#define ABSL_HARDENING_ASSERT(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]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1208|      0|      ABSL_HARDENING_ASSERT(position_ < node_->finish());
  ------------------
  |  |  140|      0|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|      0|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 0]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1209|      0|    }
 1210|  9.66M|    return node_->value(static_cast<field_type>(position_));
 1211|  9.66M|  }
_ZN4absl12lts_2026010718container_internal10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE5valueEm:
  749|  9.66M|  reference value(size_type i) { return params_type::element(slot(i)); }
_ZNK4absl12lts_2026010718container_internal5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEE4sizeEv:
 1599|  2.10k|  size_type size() const { return size_; }
_ZN4absl12lts_2026010718container_internal5btreeINS1_15set_params_implImJEEEED2Ev:
 1443|   359k|  ~btree() {
 1444|       |    // Put static_asserts in destructor to avoid triggering them before the type
 1445|       |    // is complete.
 1446|   359k|    static_assert(static_assert_validation(), "This call must be elided.");
 1447|   359k|    clear();
 1448|   359k|  }

_ZN4absl12lts_2026010718container_internal19btree_set_containerINS1_5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEEC2Ev:
  306|  1.81k|  btree_set_container() {}
_ZN4absl12lts_2026010718container_internal15btree_containerINS1_5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEEC2Ev:
   76|  1.81k|  btree_container() : tree_(key_compare(), allocator_type()) {}
_ZN4absl12lts_2026010718container_internal19btree_set_containerINS1_5btreeINS1_15set_params_implImJEEEEEEC2Ev:
  306|   359k|  btree_set_container() {}
_ZN4absl12lts_2026010718container_internal15btree_containerINS1_5btreeINS1_15set_params_implImJEEEEEEC2Ev:
   76|   359k|  btree_container() : tree_(key_compare(), allocator_type()) {}
_ZN4absl12lts_2026010718container_internal15btree_containerINS1_5btreeINS1_15set_params_implImJEEEEEE5beginEv:
  100|  2.69M|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND { return tree_.begin(); }
_ZN4absl12lts_2026010718container_internal15btree_containerINS1_5btreeINS1_15set_params_implImJEEEEEE3endEv:
  107|  7.08M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND { return tree_.end(); }
_ZN4absl12lts_2026010718container_internal15btree_containerINS1_5btreeINS1_15set_params_implImJEEEEEE5eraseENS1_14btree_iteratorINS1_10btree_nodeIS5_EERKmPSB_EE:
  188|   981k|  iterator erase(iterator iter) ABSL_ATTRIBUTE_LIFETIME_BOUND {
  189|   981k|    return tree_.erase(iter);
  190|   981k|  }
_ZN4absl12lts_2026010718container_internal19btree_set_containerINS1_5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEE6insertERKS9_:
  332|  2.46M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  333|  2.46M|    return this->tree_.insert_unique(params_type::key(v), v);
  334|  2.46M|  }
_ZN4absl12lts_2026010718container_internal19btree_set_containerINS1_5btreeINS1_15set_params_implImJEEEEEE6insertEOm:
  336|  2.46M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  337|  2.46M|    return this->tree_.insert_unique(params_type::key(v), std::move(v));
  338|  2.46M|  }
_ZN4absl12lts_2026010718container_internal15btree_containerINS1_5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEE5eraseIS9_EEmRKS9_:
  196|  56.8k|  size_type erase(const key_arg<K> &key) {
  197|  56.8k|    auto equal_range = this->equal_range(key);
  198|  56.8k|    return tree_.erase_range(equal_range.first, equal_range.second).first;
  199|  56.8k|  }
_ZN4absl12lts_2026010718container_internal15btree_containerINS1_5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEE11equal_rangeIS9_EENSt3__14pairINS1_14btree_iteratorINS1_10btree_nodeISA_EERKS9_PSJ_EESM_EERSJ_:
  170|  56.8k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  171|  56.8k|    return tree_.equal_range(key);
  172|  56.8k|  }
_ZN4absl12lts_2026010718container_internal15btree_containerINS1_5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEE5clearEv:
  224|  3.59k|  ABSL_ATTRIBUTE_REINITIALIZES void clear() { tree_.clear(); }
_ZN4absl12lts_2026010718container_internal19btree_set_containerINS1_5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEE6insertINSt3__111__wrap_iterIPS9_EEEEvT_SI_:
  372|  1.78k|  void insert(InputIterator b, InputIterator e) {
  373|  1.78k|    this->tree_.insert_iterator_unique(b, e, 0);
  374|  1.78k|  }
_ZN4absl12lts_2026010718container_internal15btree_containerINS1_5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEE5beginEv:
  100|  57.5k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND { return tree_.begin(); }
_ZN4absl12lts_2026010718container_internal15btree_containerINS1_5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEE3endEv:
  107|  57.5k|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND { return tree_.end(); }
_ZNK4absl12lts_2026010718container_internal15btree_containerINS1_5btreeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEE4sizeEv:
  229|  2.10k|  size_type size() const { return tree_.size(); }

_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE7destroyINSt3__19allocatorINSC_4pairIKmS8_EEEEEEDaPT_PNS1_13map_slot_typeImS8_EE:
   59|  56.8k|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|  56.8k|    return Policy::destroy(alloc, slot);
   61|  56.8k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEEEvE7destroyINSt3__19allocatorIS8_EEEEDaPT_PS8_:
   59|   438k|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|   438k|    return Policy::destroy(alloc, slot);
   61|   438k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE7destroyINSt3__19allocatorImEEEEDaPT_Pm:
   59|  2.53M|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|  2.53M|    return Policy::destroy(alloc, slot);
   61|  2.53M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjlEEvE7destroyINSt3__19allocatorINS7_4pairIKjlEEEEEEDaPT_PNS1_13map_slot_typeIjlEE:
   59|     83|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|     83|    return Policy::destroy(alloc, slot);
   61|     83|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEvE7destroyINS4_9allocatorINS5_IKjS6_EEEEEEDaPT_PNS1_13map_slot_typeIjS6_EE:
   59|     49|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|     49|    return Policy::destroy(alloc, slot);
   61|     49|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE7destroyINS8_INS4_4pairIKSA_lEEEEEEDaPT_PNS1_13map_slot_typeISA_lEE:
   59|  2.13M|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|  2.13M|    return Policy::destroy(alloc, slot);
   61|  2.13M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEvE7elementIS7_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIjS6_EE:
   85|  18.9M|      -> decltype(P::element(slot)) {
   86|  18.9M|    return P::element(slot);
   87|  18.9M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEvE8transferINS4_9allocatorINS5_IKjS6_EEEEEEvPT_PNS1_13map_slot_typeIjS6_EESI_:
   75|   439k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   439k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   439k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEvE13transfer_implINS4_9allocatorINS5_IKjS6_EEEES7_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeIjS6_EESK_NS8_5Rank2E:
  119|   439k|                                                           old_slot)) {
  120|   439k|    return P::transfer(alloc, new_slot, old_slot);
  121|   439k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEvE9constructINS4_9allocatorINS5_IKjS6_EEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRSB_EEENSH_IJEEEEEEvPT_PNS1_13map_slot_typeIjS6_EEDpOT0_:
   51|   330k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   330k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   330k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjlEEvE7elementIS4_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIjlEE:
   85|  12.6M|      -> decltype(P::element(slot)) {
   86|  12.6M|    return P::element(slot);
   87|  12.6M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjlEEvE8transferINSt3__19allocatorINS7_4pairIKjlEEEEEEvPT_PNS1_13map_slot_typeIjlEESH_:
   75|   300k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   300k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   300k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjlEEvE13transfer_implINSt3__19allocatorINS7_4pairIKjlEEEES4_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeIjlEESJ_NS5_5Rank2E:
  119|   300k|                                                           old_slot)) {
  120|   300k|    return P::transfer(alloc, new_slot, old_slot);
  121|   300k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjlEEvE9constructINSt3__19allocatorINS7_4pairIKjlEEEEJRKNS7_21piecewise_construct_tENS7_5tupleIJRSA_EEENSG_IJRKlEEEEEEvPT_PNS1_13map_slot_typeIjlEEDpOT0_:
   51|   298k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   298k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   298k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeISA_lEE:
   85|  29.4M|      -> decltype(P::element(slot)) {
   86|  29.4M|    return P::element(slot);
   87|  29.4M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE8transferINS8_INS4_4pairIKSA_lEEEEEEvPT_PNS1_13map_slot_typeISA_lEESM_:
   75|  3.02M|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|  3.02M|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|  3.02M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE13transfer_implINS8_INS4_4pairIKSA_lEEEESB_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeISA_lEESO_NSC_5Rank2E:
  119|  3.02M|                                                           old_slot)) {
  120|  3.02M|    return P::transfer(alloc, new_slot, old_slot);
  121|  3.02M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE9constructINS8_INS4_4pairIKSA_lEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSL_IJEEEEEEvPT_PNS1_13map_slot_typeISA_lEEDpOT0_:
   51|   189k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   189k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   189k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE8transferINS8_INS4_4pairIKSA_fEEEEEEvPT_PNS1_13map_slot_typeISA_fEESM_:
   75|   315k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   315k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   315k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE13transfer_implINS8_INS4_4pairIKSA_fEEEESB_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeISA_fEESO_NSC_5Rank2E:
  119|   315k|                                                           old_slot)) {
  120|   315k|    return P::transfer(alloc, new_slot, old_slot);
  121|   315k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeISA_fEE:
   85|  1.33M|      -> decltype(P::element(slot)) {
   86|  1.33M|    return P::element(slot);
   87|  1.33M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE9constructINS8_INS4_4pairIKSA_fEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRSF_EEENSL_IJRKfEEEEEEvPT_PNS1_13map_slot_typeISA_fEEDpOT0_:
   51|   258k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   258k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   258k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE7destroyINS8_INS4_4pairIKSA_fEEEEEEDaPT_PNS1_13map_slot_typeISA_fEE:
   59|   505k|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|   505k|    return Policy::destroy(alloc, slot);
   61|   505k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE9constructINS8_INS4_4pairIKSA_lEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSL_IJEEEEEEvPT_PNS1_13map_slot_typeISA_lEEDpOT0_:
   51|   187k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   187k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   187k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE9constructINS8_INS4_4pairIKSA_lEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRSF_EEENSL_IJEEEEEEvPT_PNS1_13map_slot_typeISA_lEEDpOT0_:
   51|  1.76M|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|  1.76M|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|  1.76M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE9constructINS8_INS4_4pairIKSA_fEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRSF_EEENSL_IJEEEEEEvPT_PNS1_13map_slot_typeISA_fEEDpOT0_:
   51|   247k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   247k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   247k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEvE7destroyINS8_INS4_4pairIKSA_mEEEEEEDaPT_PNS1_13map_slot_typeISA_mEE:
   59|   103k|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|   103k|    return Policy::destroy(alloc, slot);
   61|   103k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeISA_mEE:
   85|   582k|      -> decltype(P::element(slot)) {
   86|   582k|    return P::element(slot);
   87|   582k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEvE8transferINS8_INS4_4pairIKSA_mEEEEEEvPT_PNS1_13map_slot_typeISA_mEESM_:
   75|   150k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   150k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   150k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEvE13transfer_implINS8_INS4_4pairIKSA_mEEEESB_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeISA_mEESO_NSC_5Rank2E:
  119|   150k|                                                           old_slot)) {
  120|   150k|    return P::transfer(alloc, new_slot, old_slot);
  121|   150k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEvE9constructINS8_INS4_4pairIKSA_mEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSL_IJEEEEEEvPT_PNS1_13map_slot_typeISA_mEEDpOT0_:
   51|   103k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   103k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   103k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE7destroyINS8_ISA_EEEEDaPT_PSA_:
   59|   134k|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|   134k|    return Policy::destroy(alloc, slot);
   61|   134k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE7elementIS9_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeImS8_EE:
   85|  10.4M|      -> decltype(P::element(slot)) {
   86|  10.4M|    return P::element(slot);
   87|  10.4M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE8transferINSt3__19allocatorINSC_4pairIKmS8_EEEEEEvPT_PNS1_13map_slot_typeImS8_EESM_:
   75|   465k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   465k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   465k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE13transfer_implINSt3__19allocatorINSC_4pairIKmS8_EEEES9_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeImS8_EESO_NSA_5Rank2E:
  119|   465k|                                                           old_slot)) {
  120|   465k|    return P::transfer(alloc, new_slot, old_slot);
  121|   465k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE9constructINSt3__19allocatorINSC_4pairIKmS8_EEEEJRKNSC_21piecewise_construct_tENSC_5tupleIJRSF_EEENSL_IJRKS8_EEEEEEvPT_PNS1_13map_slot_typeImS8_EEDpOT0_:
   51|   359k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   359k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   359k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE7elementIS4_EEDTclsrT_7elementfp_EEPm:
   85|  32.0M|      -> decltype(P::element(slot)) {
   86|  32.0M|    return P::element(slot);
   87|  32.0M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE8transferINSt3__19allocatorImEEEEvPT_PmSC_:
   75|  13.2M|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|  13.2M|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|  13.2M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE13transfer_implINSt3__19allocatorImEEvEENS7_17integral_constantIbLb1EEEPT_PmSE_NS5_5Rank1E:
  129|  13.2M|                                      slot_type* old_slot, Rank1) {
  130|       |    // TODO(b/247130232): remove casts after fixing warnings.
  131|       |    // TODO(b/251814870): remove casts after fixing warnings.
  132|  13.2M|    std::memcpy(
  133|  13.2M|        static_cast<void*>(std::launder(
  134|  13.2M|            const_cast<std::remove_const_t<value_type>*>(&element(new_slot)))),
  135|  13.2M|        static_cast<const void*>(&element(old_slot)), sizeof(value_type));
  136|  13.2M|    return {};
  137|  13.2M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE9constructINSt3__19allocatorImEEJPmEEEvPT_SA_DpOT0_:
   51|  70.2k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|  70.2k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|  70.2k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEEEvE8transferINSt3__19allocatorIS8_EEEEvPT_PS8_SH_:
   75|  5.98M|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|  5.98M|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|  5.98M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEEEvE13transfer_implINSt3__19allocatorIS8_EEvEENSC_17integral_constantIbLb1EEEPT_PS8_SJ_NSA_5Rank1E:
  129|  5.98M|                                      slot_type* old_slot, Rank1) {
  130|       |    // TODO(b/247130232): remove casts after fixing warnings.
  131|       |    // TODO(b/251814870): remove casts after fixing warnings.
  132|  5.98M|    std::memcpy(
  133|  5.98M|        static_cast<void*>(std::launder(
  134|  5.98M|            const_cast<std::remove_const_t<value_type>*>(&element(new_slot)))),
  135|  5.98M|        static_cast<const void*>(&element(old_slot)), sizeof(value_type));
  136|  5.98M|    return {};
  137|  5.98M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEEEvE7elementIS9_EEDTclsrT_7elementfp_EEPS8_:
   85|  21.6M|      -> decltype(P::element(slot)) {
   86|  21.6M|    return P::element(slot);
   87|  21.6M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEEEvE9constructINSt3__19allocatorIS8_EEJPS8_EEEvPT_SF_DpOT0_:
   51|  13.9k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|  13.9k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|  13.9k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEEEvE9constructINSt3__19allocatorIS8_EEJRKS8_EEEvPT_PS8_DpOT0_:
   51|   323k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   323k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   323k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE9constructINSt3__19allocatorImEEJmEEEvPT_PmDpOT0_:
   51|  2.46M|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|  2.46M|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|  2.46M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_15set_slot_policyIPN13sentencepiece3bpe7Trainer6SymbolEEEvE9constructINSt3__19allocatorIS8_EEJRS8_EEEvPT_PS8_DpOT0_:
   51|   101k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   101k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   101k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE7elementISB_EEDTclsrT_7elementfp_EEPSA_:
   85|   143k|      -> decltype(P::element(slot)) {
   86|   143k|    return P::element(slot);
   87|   143k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE8transferINS8_ISA_EEEEvPT_PSA_SH_:
   75|  77.2k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|  77.2k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|  77.2k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE13transfer_implINS8_ISA_EEEEvPT_PSA_SH_NSC_5Rank0E:
  141|  77.2k|                            slot_type* old_slot, Rank0) {
  142|  77.2k|    construct(alloc, new_slot, std::move(element(old_slot)));
  143|  77.2k|    destroy(alloc, old_slot);
  144|  77.2k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE9constructINS8_ISA_EEJSA_EEEvPT_PSA_DpOT0_:
   51|   134k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   134k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   134k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEvE7elementIS7_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIjS6_EE:
   85|  62.9M|      -> decltype(P::element(slot)) {
   86|  62.9M|    return P::element(slot);
   87|  62.9M|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEvE8transferINSt3__19allocatorINSA_4pairIKjS6_EEEEEEvPT_PNS1_13map_slot_typeIjS6_EESK_:
   75|   229k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   229k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   229k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEvE13transfer_implINSt3__19allocatorINSA_4pairIKjS6_EEEES7_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeIjS6_EESM_NS8_5Rank2E:
  119|   229k|                                                           old_slot)) {
  120|   229k|    return P::transfer(alloc, new_slot, old_slot);
  121|   229k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEvE9constructINSt3__19allocatorINSA_4pairIKjS6_EEEEJRKNSA_21piecewise_construct_tENSA_5tupleIJRSD_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIjS6_EEDpOT0_:
   51|   127k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   127k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   127k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEvE9constructINSt3__19allocatorINSA_4pairIKjS6_EEEEJRKNSA_21piecewise_construct_tENSA_5tupleIJOjEEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIjS6_EEDpOT0_:
   51|    697|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|    697|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|    697|  }

_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIjEEmEEELb0EE3getEv:
   91|  8.77k|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNSt3__19allocatorIjEEmEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS6_XT_EE4typeEv:
  249|  8.77k|  constexpr const ElemT<I>& get() const& {
  250|  8.77k|    return StorageT<I>::get();
  251|  8.77k|  }
_ZN4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEEC2IS3_JS6_S9_SB_ETnNS7_9enable_ifIXsr4absl11conjunctionINS7_8negationINS7_7is_sameIFvSC_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleISC_JSI_DpT0_EEEEE5valueEbE4typeELb1EEEOSI_DpOSP_:
  239|  1.81k|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|  1.81k|                                             std::forward<First>(first),
  241|  1.81k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS9_9allocatorIcEEEEENS9_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S8_SB_SD_EEENS9_10in_place_tEDpOT_:
  126|  7.26k|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|  7.26k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashImEENSt3__18equal_toImEENS9_9allocatorIcEEEEELb0EEC2IS4_EENS9_10in_place_tEOT_:
   90|  1.81k|      : value(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashImEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toImEENS9_9allocatorIcEEEEELb1EEC2IS6_EENS9_10in_place_tEOT_:
  102|  1.81k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__18equal_toImEELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashImEES6_NS4_9allocatorIcEEEEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  1.81k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENS4_8equal_toImEES6_EEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  1.81k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEESA_E15checked_compareENS4_9allocatorISA_EEPNS1_10btree_nodeINS1_15set_params_implISA_JEEEEEEEC2IRKSD_JRKSF_SK_ETnNS4_9enable_ifIXsr4absl11conjunctionINS4_8negationINS4_7is_sameIFvSL_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleISL_JSV_DpT0_EEEEE5valueEbE4typeELb1EEEOSV_DpOS12_:
  239|  1.81k|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|  1.81k|                                             std::forward<First>(first),
  241|  1.81k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEESC_E15checked_compareENS6_9allocatorISC_EEPNS1_10btree_nodeINS1_15set_params_implISC_JEEEEEEEENS6_16integer_sequenceImJLm0ELm1ELm2EEEELb1EEC2IJRKSF_RKSH_SM_EEENS6_10in_place_tEDpOT_:
  126|  5.44k|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|  5.44k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_19key_compare_adapterINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEESB_E15checked_compareELm0ENS2_10StorageTagIJSE_NS5_9allocatorISB_EEPNS1_10btree_nodeINS1_15set_params_implISB_JEEEEEEEELb1EEC2IRKSE_EENS5_10in_place_tEOT_:
  102|  1.81k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIPN13sentencepiece3bpe7Trainer6SymbolEEELm1ENS2_10StorageTagIJNS1_19key_compare_adapterINS4_4lessISA_EESA_E15checked_compareESB_PNS1_10btree_nodeINS1_15set_params_implISA_JEEEEEEEELb1EEC2IRKSB_EENS4_10in_place_tEOT_:
  102|  1.81k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEELm2ENS2_10StorageTagIJNS1_19key_compare_adapterINSt3__14lessISA_EESA_E15checked_compareENSG_9allocatorISA_EESD_EEELb0EEC2ISD_EENSG_10in_place_tEOT_:
   90|  1.81k|      : value(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|  45.2M|  constexpr const ElemT<I>& get() const& {
  250|  45.2M|    return StorageT<I>::get();
  251|  45.2M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashImEENSt3__18equal_toImEENS9_9allocatorIcEEEEELb0EE3getEv:
   91|  45.2M|  constexpr const T& get() const& { return value; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|  18.3M|  constexpr ElemT<I>& get() & {
  245|  18.3M|    return StorageT<I>::get();
  246|  18.3M|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashImEENSt3__18equal_toImEENS9_9allocatorIcEEEEELb0EE3getEv:
   92|  18.3M|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|   883k|  constexpr ElemT<I>& get() & {
  245|   883k|    return StorageT<I>::get();
  246|   883k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENS4_8equal_toImEES6_EEELb1EE3getEv:
  105|   883k|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIPN13sentencepiece3bpe7Trainer6SymbolEEELm1ENS2_10StorageTagIJNS1_19key_compare_adapterINS4_4lessISA_EESA_E15checked_compareESB_PNS1_10btree_nodeINS1_15set_params_implISA_JEEEEEEEELb1EE3getEv:
  105|   587k|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEESA_E15checked_compareENS4_9allocatorISA_EEPNS1_10btree_nodeINS1_15set_params_implISA_JEEEEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISL_XT_EE4typeEv:
  244|   587k|  constexpr ElemT<I>& get() & {
  245|   587k|    return StorageT<I>::get();
  246|   587k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEELm2ENS2_10StorageTagIJNS1_19key_compare_adapterINSt3__14lessISA_EESA_E15checked_compareENSG_9allocatorISA_EESD_EEELb0EE3getEv:
   92|   561k|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEESA_E15checked_compareENS4_9allocatorISA_EEPNS1_10btree_nodeINS1_15set_params_implISA_JEEEEEEE3getILi2EEERNS1_25internal_compressed_tuple4ElemISL_XT_EE4typeEv:
  244|   561k|  constexpr ElemT<I>& get() & {
  245|   561k|    return StorageT<I>::get();
  246|   561k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorImEELm1ENS2_10StorageTagIJNS1_19key_compare_adapterINS4_4lessImEEmE15checked_compareES6_PNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEELb1EE3getEv:
  105|  5.61M|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENS4_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISG_XT_EE4typeEv:
  244|  5.61M|  constexpr ElemT<I>& get() & {
  245|  5.61M|    return StorageT<I>::get();
  246|  5.61M|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_15set_params_implImJEEEEELm2ENS2_10StorageTagIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENSB_9allocatorImEES8_EEELb0EE3getEv:
   92|  15.5M|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENS4_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEE3getILi2EEERNS1_25internal_compressed_tuple4ElemISG_XT_EE4typeEv:
  244|  15.5M|  constexpr ElemT<I>& get() & {
  245|  15.5M|    return StorageT<I>::get();
  246|  15.5M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   91|   130M|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|   130M|  constexpr const ElemT<I>& get() const& {
  250|   130M|    return StorageT<I>::get();
  251|   130M|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   92|  57.4M|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|  57.4M|  constexpr ElemT<I>& get() & {
  245|  57.4M|    return StorageT<I>::get();
  246|  57.4M|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EE3getEv:
  105|  9.21M|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|  9.21M|  constexpr ElemT<I>& get() & {
  245|  9.21M|    return StorageT<I>::get();
  246|  9.21M|  }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS7_9allocatorIcEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|   421M|  constexpr const ElemT<I>& get() const& {
  250|   421M|    return StorageT<I>::get();
  251|   421M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS9_9allocatorIcEEEEELb0EE3getEv:
   91|   421M|  constexpr const T& get() const& { return value; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS7_9allocatorIcEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|   161M|  constexpr ElemT<I>& get() & {
  245|   161M|    return StorageT<I>::get();
  246|   161M|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS9_9allocatorIcEEEEELb0EE3getEv:
   92|   161M|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS7_9allocatorIcEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|  1.74M|  constexpr ElemT<I>& get() & {
  245|  1.74M|    return StorageT<I>::get();
  246|  1.74M|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEENS4_8equal_toIjEES6_EEELb1EE3getEv:
  105|  1.74M|  constexpr T& get() & { return *this; }
_ZN4absl12lts_2026010718container_internal15CompressedTupleIJNSt3__19allocatorIjEEmEEC2IS5_JjETnNS3_9enable_ifIXsr4absl11conjunctionINS3_8negationINS3_7is_sameIFvS6_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS6_JSC_DpT0_EEEEE5valueEbE4typeELb1EEEOSC_DpOSJ_:
  239|  1.46k|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|  1.46k|                                             std::forward<First>(first),
  241|  1.46k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNSt3__19allocatorIjEEmEEENS5_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJS7_jEEENS5_10in_place_tEDpOT_:
  126|  2.92k|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|  2.92k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIjEELm0ENS2_10StorageTagIJS6_mEEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  1.46k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIjEEmEEELb0EEC2IjEENS5_10in_place_tEOT_:
   90|  1.46k|      : value(std::forward<V>(v)) {}
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNSt3__19allocatorIjEEmEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS6_XT_EE4typeEv:
  244|  1.46k|  constexpr ElemT<I>& get() & {
  245|  1.46k|    return StorageT<I>::get();
  246|  1.46k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIjEELm0ENS2_10StorageTagIJS6_mEEELb1EE3getEv:
  105|  1.46k|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNSt3__19allocatorIjEEmEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS6_XT_EE4typeEv:
  244|  2.92k|  constexpr ElemT<I>& get() & {
  245|  2.92k|    return StorageT<I>::get();
  246|  2.92k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIjEEmEEELb0EE3getEv:
   92|  2.92k|  constexpr T& get() & { return value; }
_ZN4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS7_9allocatorIcEEEEC2IS3_JS6_S9_SB_ETnNS7_9enable_ifIXsr4absl11conjunctionINS7_8negationINS7_7is_sameIFvSC_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleISC_JSI_DpT0_EEEEE5valueEbE4typeELb1EEEOSI_DpOSP_:
  239|  20.2k|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|  20.2k|                                             std::forward<First>(first),
  241|  20.2k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS9_9allocatorIcEEEEENS9_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S8_SB_SD_EEENS9_10in_place_tEDpOT_:
  126|  80.9k|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|  80.9k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS9_9allocatorIcEEEEELb0EEC2IS4_EENS9_10in_place_tEOT_:
   90|  20.2k|      : value(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashIjEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toIjEENS9_9allocatorIcEEEEELb1EEC2IS6_EENS9_10in_place_tEOT_:
  102|  20.2k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__18equal_toIjEELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEES6_NS4_9allocatorIcEEEEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  20.2k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEENS4_8equal_toIjEES6_EEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  20.2k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS7_9allocatorIcEEEE3getILi2EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|  51.1M|  constexpr const ElemT<I>& get() const& {
  250|  51.1M|    return StorageT<I>::get();
  251|  51.1M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__18equal_toIjEELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEES6_NS4_9allocatorIcEEEEELb1EE3getEv:
  104|  51.1M|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS7_9allocatorIcEEEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|  54.1M|  constexpr const ElemT<I>& get() const& {
  250|  54.1M|    return StorageT<I>::get();
  251|  54.1M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashIjEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toIjEENS9_9allocatorIcEEEEELb1EE3getEv:
  104|  54.1M|  constexpr const T& get() const& { return *this; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIjEENSt3__18equal_toIjEENS7_9allocatorIcEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|  30.1k|  constexpr ElemT<I>& get() & {
  245|  30.1k|    return StorageT<I>::get();
  246|  30.1k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashIjEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toIjEENS9_9allocatorIcEEEEELb1EE3getEv:
  105|  30.1k|  constexpr T& get() & { return *this; }
_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|  44.8k|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|  44.8k|                                             std::forward<First>(first),
  241|  44.8k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S6_S7_SA_EEENS8_10in_place_tEDpOT_:
  126|   179k|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|   179k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EEC2IS4_EENS8_10in_place_tEOT_:
   90|  51.6k|      : value(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EEC2IS4_EENS8_10in_place_tEOT_:
  102|  44.8k|  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|  44.8k|  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|  44.8k|  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|  11.9M|  constexpr const ElemT<I>& get() const& {
  250|  11.9M|    return StorageT<I>::get();
  251|  11.9M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EE3getEv:
  104|  11.9M|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|  19.2M|  constexpr const ElemT<I>& get() const& {
  250|  19.2M|    return StorageT<I>::get();
  251|  19.2M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  104|  19.2M|  constexpr const T& get() const& { return *this; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|  58.1k|  constexpr ElemT<I>& get() & {
  245|  58.1k|    return StorageT<I>::get();
  246|  58.1k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  105|  58.1k|  constexpr T& get() & { return *this; }
_ZN4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEC2IS3_JRKS4_RKS5_RKNS7_INS6_4pairIKNS6_12basic_stringIcNS6_11char_traitsIcEES8_EEfEEEEETnNS6_9enable_ifIXsr4absl11conjunctionINS6_8negationINS6_7is_sameIFvS9_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS9_JST_DpT0_EEEEE5valueEbE4typeELb1EEEOST_DpOS10_:
  239|  6.79k|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|  6.79k|                                             std::forward<First>(first),
  241|  6.79k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_RKS6_RKS7_RKNS9_INS8_4pairIKNS8_12basic_stringIcNS8_11char_traitsIcEESA_EEfEEEEEEENS8_10in_place_tEDpOT_:
  126|  27.1k|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|  27.1k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EEC2IRKS4_EENS8_10in_place_tEOT_:
  102|  6.79k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EEC2IRKS4_EENS8_10in_place_tEOT_:
  102|  6.79k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EEC2IRKNS5_INS4_4pairIKNS4_12basic_stringIcNS4_11char_traitsIcEES6_EEfEEEEEENS4_10in_place_tEOT_:
  102|  6.79k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENS4_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEC2IRKS8_JRKSA_SF_ETnNS4_9enable_ifIXsr4absl11conjunctionINS4_8negationINS4_7is_sameIFvSG_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleISG_JSQ_DpT0_EEEEE5valueEbE4typeELb1EEEOSQ_DpOSX_:
  239|   359k|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|   359k|                                             std::forward<First>(first),
  241|   359k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENS6_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEENS6_16integer_sequenceImJLm0ELm1ELm2EEEELb1EEC2IJRKSA_RKSC_SH_EEENS6_10in_place_tEDpOT_:
  126|  1.07M|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|  1.07M|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareELm0ENS2_10StorageTagIJS9_NS5_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEELb1EEC2IRKS9_EENS5_10in_place_tEOT_:
  102|   359k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorImEELm1ENS2_10StorageTagIJNS1_19key_compare_adapterINS4_4lessImEEmE15checked_compareES6_PNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEELb1EEC2IRKS6_EENS4_10in_place_tEOT_:
  102|   359k|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_15set_params_implImJEEEEELm2ENS2_10StorageTagIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENSB_9allocatorImEES8_EEELb0EEC2IS8_EENSB_10in_place_tEOT_:
   90|   359k|      : value(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi2EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|  5.03M|  constexpr const ElemT<I>& get() const& {
  250|  5.03M|    return StorageT<I>::get();
  251|  5.03M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__18equal_toImEELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashImEES6_NS4_9allocatorIcEEEEELb1EE3getEv:
  104|  5.03M|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|  6.27M|  constexpr const ElemT<I>& get() const& {
  250|  6.27M|    return StorageT<I>::get();
  251|  6.27M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashImEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toImEENS9_9allocatorIcEEEEELb1EE3getEv:
  104|  6.27M|  constexpr const T& get() const& { return *this; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|  1.79k|  constexpr ElemT<I>& get() & {
  245|  1.79k|    return StorageT<I>::get();
  246|  1.79k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashImEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toImEENS9_9allocatorIcEEEEELb1EE3getEv:
  105|  1.79k|  constexpr T& get() & { return *this; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEESA_E15checked_compareENS4_9allocatorISA_EEPNS1_10btree_nodeINS1_15set_params_implISA_JEEEEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISL_XT_EE4typeEv:
  249|  7.23M|  constexpr const ElemT<I>& get() const& {
  250|  7.23M|    return StorageT<I>::get();
  251|  7.23M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_19key_compare_adapterINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEESB_E15checked_compareELm0ENS2_10StorageTagIJSE_NS5_9allocatorISB_EEPNS1_10btree_nodeINS1_15set_params_implISB_JEEEEEEEELb1EE3getEv:
  104|  7.23M|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENS4_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISG_XT_EE4typeEv:
  249|  4.16M|  constexpr const ElemT<I>& get() const& {
  250|  4.16M|    return StorageT<I>::get();
  251|  4.16M|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareELm0ENS2_10StorageTagIJS9_NS5_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEELb1EE3getEv:
  104|  4.16M|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessIPN13sentencepiece3bpe7Trainer6SymbolEEESA_E15checked_compareENS4_9allocatorISA_EEPNS1_10btree_nodeINS1_15set_params_implISA_JEEEEEEE3getILi2EEERKNS1_25internal_compressed_tuple4ElemISL_XT_EE4typeEv:
  249|   113k|  constexpr const ElemT<I>& get() const& {
  250|   113k|    return StorageT<I>::get();
  251|   113k|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEELm2ENS2_10StorageTagIJNS1_19key_compare_adapterINSt3__14lessISA_EESA_E15checked_compareENSG_9allocatorISA_EESD_EEELb0EE3getEv:
   91|   113k|  constexpr const T& get() const& { return value; }

_ZN4absl12lts_2026010718container_internal27SanitizerPoisonMemoryRegionEPKvm:
  240|  28.1M|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|  28.1M|  (void)m;
  248|  28.1M|  (void)s;
  249|  28.1M|}
_ZN4absl12lts_2026010718container_internal29SanitizerUnpoisonMemoryRegionEPKvm:
  251|  32.2M|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|  32.2M|  (void)m;
  259|  32.2M|  (void)s;
  260|  32.2M|}
_ZN4absl12lts_2026010718container_internal15map_slot_policyImPN13sentencepiece3bpe7Trainer6SymbolEE7destroyINSt3__19allocatorINSA_4pairIKmS7_EEEEEEDaPT_PNS1_13map_slot_typeImS7_EE:
  431|  56.8k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|  56.8k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 56.8k, Folded]
  ------------------
  433|  56.8k|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|  56.8k|    } else {
  435|      0|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|  56.8k|    return IsDestructionTrivial<Allocator, value_type>();
  438|  56.8k|  }
_ZN4absl12lts_2026010718container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKmPN13sentencepiece3bpe7Trainer6SymbolEEEEESC_EEDav:
   81|  56.8k|constexpr auto IsDestructionTrivial() {
   82|  56.8k|  constexpr bool result =
   83|  56.8k|      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|  56.8k|  return std::integral_constant<bool, result>();
   88|  56.8k|}
_ZN4absl12lts_2026010718container_internal21SanitizerPoisonObjectIPN13sentencepiece3bpe7Trainer6SymbolEEEvPKT_:
  263|  6.41M|inline void SanitizerPoisonObject(const T* object) {
  264|  6.41M|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  265|  6.41M|}
_ZN4absl12lts_2026010718container_internal10DeallocateILm8ENSt3__19allocatorIPN13sentencepiece3bpe7Trainer6SymbolEEEEEvPT0_Pvm:
   93|  33.4k|void Deallocate(Alloc* alloc, void* p, size_t n) {
   94|  33.4k|  static_assert(Alignment > 0, "");
   95|  33.4k|  assert(n && "n must be positive");
   96|  33.4k|  using M = AlignedType<Alignment>;
   97|  33.4k|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   98|  33.4k|  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|  33.4k|  A my_mem_alloc(*alloc);
  103|  33.4k|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
  104|  33.4k|                 (n + sizeof(M) - 1) / sizeof(M));
  105|  33.4k|}
_ZN4absl12lts_2026010718container_internal21SanitizerPoisonObjectImEEvPKT_:
  263|  15.8M|inline void SanitizerPoisonObject(const T* object) {
  264|  15.8M|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  265|  15.8M|}
_ZN4absl12lts_2026010718container_internal10DeallocateILm8ENSt3__19allocatorImEEEEvPT0_Pvm:
   93|   696k|void Deallocate(Alloc* alloc, void* p, size_t n) {
   94|   696k|  static_assert(Alignment > 0, "");
   95|   696k|  assert(n && "n must be positive");
   96|   696k|  using M = AlignedType<Alignment>;
   97|   696k|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   98|   696k|  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|   696k|  A my_mem_alloc(*alloc);
  103|   696k|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
  104|   696k|                 (n + sizeof(M) - 1) / sizeof(M));
  105|   696k|}
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjlE7destroyINSt3__19allocatorINS5_4pairIKjlEEEEEEDaPT_PNS1_13map_slot_typeIjlEE:
  431|     83|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|     83|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 83, Folded]
  ------------------
  433|     83|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|     83|    } else {
  435|      0|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|     83|    return IsDestructionTrivial<Allocator, value_type>();
  438|     83|  }
_ZN4absl12lts_2026010718container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKjlEEEES7_EEDav:
   81|     83|constexpr auto IsDestructionTrivial() {
   82|     83|  constexpr bool result =
   83|     83|      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|     83|  return std::integral_constant<bool, result>();
   88|     83|}
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjNSt3__14pairIblEEE7destroyINS3_9allocatorINS4_IKjS5_EEEEEEDaPT_PNS1_13map_slot_typeIjS5_EE:
  431|   439k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|   439k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 439k, Folded]
  ------------------
  433|   439k|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|   439k|    } else {
  435|      0|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|   439k|    return IsDestructionTrivial<Allocator, value_type>();
  438|   439k|  }
_ZN4absl12lts_2026010718container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKjNS5_IblEEEEEES8_EEDav:
   81|   439k|constexpr auto IsDestructionTrivial() {
   82|   439k|  constexpr bool result =
   83|   439k|      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|   439k|  return std::integral_constant<bool, result>();
   88|   439k|}
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE7destroyINS7_INS3_4pairIKS9_lEEEEEEDaPT_PNS1_13map_slot_typeIS9_lEE:
  431|  5.16M|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|  5.16M|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 5.16M, Folded]
  ------------------
  433|  5.16M|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|  5.16M|    } else {
  435|      0|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|  5.16M|    return IsDestructionTrivial<Allocator, value_type>();
  438|  5.16M|  }
_ZN4absl12lts_2026010718container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKNS3_12basic_stringIcNS3_11char_traitsIcEENS4_IcEEEElEEEESC_EEDav:
   81|  5.16M|constexpr auto IsDestructionTrivial() {
   82|  5.16M|  constexpr bool result =
   83|  5.16M|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [Folded, False: 5.16M]
  ------------------
   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|  5.16M|  return std::integral_constant<bool, result>();
   88|  5.16M|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementIjNSt3__18equal_toIjEEEEJRNS4_4pairIKjNS8_IblEEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSD_DpOSE_:
  226|  9.04M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  9.04M|  return memory_internal::DecomposePairImpl(
  228|  9.04M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  9.04M|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementIjNSt3__18equal_toIjEEEERKjNS5_5tupleIJRKNS5_4pairIblEEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSB_IJSI_EEEEEclsr3stdE7declvalIT1_EEEEOSH_NSC_ISL_SM_EE:
  158|  9.04M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  9.04M|  const auto& key = std::get<0>(p.first);
  160|  9.04M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  9.04M|                            std::move(p.second));
  162|  9.04M|}
_ZNK4absl12lts_2026010718container_internal12EqualElementIjNSt3__18equal_toIjEEEclIjJRKNS3_21piecewise_construct_tENS3_5tupleIJRKjEEENSB_IJRKNS3_4pairIblEEEEEEEEbRKT_DpOT0_:
  529|  9.04M|  bool operator()(const K2& lhs, Args&&...) const {
  530|  9.04M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  9.04M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  9.04M|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIKjNSt3__14pairIblEEEENS5_INS4_5tupleIJRKT_EEENS7_IJRKT0_EEEEERKNS5_IS8_SC_EE:
  207|  9.39M|    const std::pair<F, S>& p) {
  208|  9.39M|  return PairArgs(p.first, p.second);
  209|  9.39M|}
_ZN4absl12lts_2026010718container_internal8PairArgsIRKjRKNSt3__14pairIblEEEENS6_INS5_5tupleIJOT_EEENSA_IJOT0_EEEEESC_SF_:
  201|  9.39M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  9.39M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  9.39M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  9.39M|}
_ZN4absl12lts_2026010718container_internal23TypeErasedApplyToSlotFnINS0_13hash_internal4HashIjEEjLb1EEEmPKvPvm:
  542|  20.0k|size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
  543|  20.0k|  const auto* f = static_cast<const Fn*>(fn);
  544|  20.0k|  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
  545|  20.0k|}
_ZN4absl12lts_2026010718container_internal11HashElementINS0_13hash_internal4HashIjEELb1EEC2ERKS5_m:
  495|  54.1M|  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
_ZNK4absl12lts_2026010718container_internal11HashElementINS0_13hash_internal4HashIjEELb1EEclIjJEEEmRKT_DpOT0_:
  498|  53.2M|  size_t operator()(const K& key, Args&&...) const {
  499|  53.2M|    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|  53.2M|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|  53.2M|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|  53.2M|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjNSt3__14pairIblEEE8transferINS3_9allocatorINS4_IKjS5_EEEEEEDaPT_PNS1_13map_slot_typeIjS5_EESG_:
  442|   439k|                       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|   439k|    auto is_relocatable = typename std::conjunction<
  449|   439k|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|   439k|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|   439k|        type();
  452|       |
  453|   439k|    emplace(new_slot);
  454|   439k|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [Folded, False: 439k]
  ------------------
  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|   439k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 439k, Folded]
  ------------------
  463|   439k|      absl::allocator_traits<Allocator>::construct(
  464|   439k|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|   439k|    } else {
  466|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                   std::move(old_slot->value));
  468|      0|    }
  469|   439k|    destroy(alloc, old_slot);
  470|   439k|    return is_relocatable;
  471|   439k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjNSt3__14pairIblEEE7emplaceEPNS1_13map_slot_typeIjS5_EE:
  368|   769k|  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|   769k|    new (slot) slot_type;
  372|   769k|  }
_ZN4absl12lts_2026010718container_internal13map_slot_typeIjNSt3__14pairIblEEEC2Ev:
  349|   769k|  map_slot_type() {}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEEJRNSt3__14pairIKjNS9_IblEEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSE_DpOSF_:
  226|   352k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   352k|  return memory_internal::DecomposePairImpl(
  228|   352k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   352k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEERKjNSt3__15tupleIJRKNSB_4pairIblEEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSB_19piecewise_constructEEclsr3stdE7declvalINSC_IJSJ_EEEEEclsr3stdE7declvalIT1_EEEEOSI_NSD_ISM_SN_EE:
  158|   352k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   352k|  const auto& key = std::get<0>(p.first);
  160|   352k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   352k|                            std::move(p.second));
  162|   352k|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS0_13hash_internal4HashIjEELb1EEclIjJRKNSt3__121piecewise_construct_tENS8_5tupleIJRKjEEENSC_IJRKNS8_4pairIblEEEEEEEEmRKT_DpOT0_:
  498|   352k|  size_t operator()(const K& key, Args&&...) const {
  499|   352k|    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|   352k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   352k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   352k|  }
_ZN4absl12lts_2026010718container_internal7HashKeyINS0_13hash_internal4HashIjEEjLb1EEC2ERKS5_RKj:
  515|  30.1k|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026010718container_internal7HashKeyINS0_13hash_internal4HashIjEEjLb1EEclEm:
  517|  20.0k|  size_t operator()(size_t seed) const {
  518|  20.0k|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|  20.0k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjNSt3__14pairIblEEE9constructINS3_9allocatorINS4_IKjS5_EEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRS9_EEENSF_IJEEEEEEvPT_PNS1_13map_slot_typeIjS5_EEDpOT0_:
  397|   330k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   330k|    emplace(slot);
  399|   330k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 330k, Folded]
  ------------------
  400|   330k|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   330k|                                                   std::forward<Args>(args)...);
  402|   330k|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|   330k|  }
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE19EmplaceDecomposableEJRKjRKlEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSC_DpOSD_:
  226|   298k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   298k|  return memory_internal::DecomposePairImpl(
  228|   298k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   298k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE19EmplaceDecomposableERKjNSt3__15tupleIJRKlEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSB_19piecewise_constructEEclsr3stdE7declvalINSC_IJSH_EEEEEclsr3stdE7declvalIT1_EEEEOSG_NSB_4pairISK_SL_EE:
  158|   298k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   298k|  const auto& key = std::get<0>(p.first);
  160|   298k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   298k|                            std::move(p.second));
  162|   298k|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementIjNSt3__18equal_toIjEEEEJRNS4_4pairIKjlEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSC_DpOSD_:
  226|  10.6M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  10.6M|  return memory_internal::DecomposePairImpl(
  228|  10.6M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  10.6M|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementIjNSt3__18equal_toIjEEEERKjNS5_5tupleIJRKlEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSB_IJSG_EEEEEclsr3stdE7declvalIT1_EEEEOSF_NS5_4pairISJ_SK_EE:
  158|  10.6M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  10.6M|  const auto& key = std::get<0>(p.first);
  160|  10.6M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  10.6M|                            std::move(p.second));
  162|  10.6M|}
_ZNK4absl12lts_2026010718container_internal12EqualElementIjNSt3__18equal_toIjEEEclIjJRKNS3_21piecewise_construct_tENS3_5tupleIJRKjEEENSB_IJRKlEEEEEEbRKT_DpOT0_:
  529|  10.6M|  bool operator()(const K2& lhs, Args&&...) const {
  530|  10.6M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  10.6M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  10.6M|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIKjlEENSt3__14pairINS4_5tupleIJRKT_EEENS6_IJRKT0_EEEEERKNS5_IS7_SB_EE:
  207|  10.9M|    const std::pair<F, S>& p) {
  208|  10.9M|  return PairArgs(p.first, p.second);
  209|  10.9M|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEEJRNSt3__14pairIKjlEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSD_DpOSE_:
  226|   302k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   302k|  return memory_internal::DecomposePairImpl(
  228|   302k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   302k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEERKjNSt3__15tupleIJRKlEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSB_19piecewise_constructEEclsr3stdE7declvalINSC_IJSH_EEEEEclsr3stdE7declvalIT1_EEEEOSG_NSB_4pairISK_SL_EE:
  158|   302k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   302k|  const auto& key = std::get<0>(p.first);
  160|   302k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   302k|                            std::move(p.second));
  162|   302k|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS0_13hash_internal4HashIjEELb1EEclIjJRKNSt3__121piecewise_construct_tENS8_5tupleIJRKjEEENSC_IJRKlEEEEEEmRKT_DpOT0_:
  498|   302k|  size_t operator()(const K& key, Args&&...) const {
  499|   302k|    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|   302k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   302k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   302k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjlE8transferINSt3__19allocatorINS5_4pairIKjlEEEEEEDaPT_PNS1_13map_slot_typeIjlEESF_:
  442|   300k|                       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|   300k|    auto is_relocatable = typename std::conjunction<
  449|   300k|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|   300k|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|   300k|        type();
  452|       |
  453|   300k|    emplace(new_slot);
  454|   300k|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [True: 300k, Folded]
  ------------------
  455|       |      // TODO(b/247130232,b/251814870): remove casts after fixing warnings.
  456|   300k|      std::memcpy(static_cast<void*>(std::launder(&new_slot->value)),
  457|   300k|                  static_cast<const void*>(&old_slot->value),
  458|   300k|                  sizeof(value_type));
  459|   300k|      return is_relocatable;
  460|   300k|    }
  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|   300k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjlE7emplaceEPNS1_13map_slot_typeIjlEE:
  368|   598k|  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|   598k|    new (slot) slot_type;
  372|   598k|  }
_ZN4absl12lts_2026010718container_internal13map_slot_typeIjlEC2Ev:
  349|   598k|  map_slot_type() {}
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjlE9constructINSt3__19allocatorINS5_4pairIKjlEEEEJRKNS5_21piecewise_construct_tENS5_5tupleIJRS8_EEENSE_IJRKlEEEEEEvPT_PNS1_13map_slot_typeIjlEEDpOT0_:
  397|   298k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   298k|    emplace(slot);
  399|   298k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 298k, Folded]
  ------------------
  400|   298k|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   298k|                                                   std::forward<Args>(args)...);
  402|   298k|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|   298k|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIRKjRKlEENSt3__14pairINS7_5tupleIJOT_EEENS9_IJOT0_EEEEESB_SE_:
  201|  11.2M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  11.2M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  11.2M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  11.2M|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS1_8StringEqEEEJRNS4_4pairIKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEElEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  226|   107k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   107k|  return memory_internal::DecomposePairImpl(
  228|   107k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   107k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_8StringEqEEERKNS5_12basic_stringIcS8_NS5_9allocatorIcEEEENS5_5tupleIJRKlEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSI_IJSN_EEEEEclsr3stdE7declvalIT1_EEEEOSM_NS5_4pairISQ_SR_EE:
  158|   107k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   107k|  const auto& key = std::get<0>(p.first);
  160|   107k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   107k|                            std::move(p.second));
  162|   107k|}
_ZNK4absl12lts_2026010718container_internal12EqualElementINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_8StringEqEEclINS3_12basic_stringIcS6_NS3_9allocatorIcEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKSE_EEENSI_IJRKlEEEEEEbRKT_DpOT0_:
  529|   107k|  bool operator()(const K2& lhs, Args&&...) const {
  530|   107k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|   107k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|   107k|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE:
  207|  14.3M|    const std::pair<F, S>& p) {
  208|  14.3M|  return PairArgs(p.first, p.second);
  209|  14.3M|}
_ZN4absl12lts_2026010718container_internal8PairArgsIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKlEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_:
  201|  14.3M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  14.3M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  14.3M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  14.3M|}
_ZN4absl12lts_2026010718container_internal23TypeErasedApplyToSlotFnINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEEmPKvPvm:
  542|  27.6k|size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
  543|  27.6k|  const auto* f = static_cast<const Fn*>(fn);
  544|  27.6k|  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
  545|  27.6k|}
_ZN4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEC2ERKS3_m:
  495|  19.3M|  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJEEEmRKT_DpOT0_:
  498|  15.5M|  size_t operator()(const K& key, Args&&...) const {
  499|  15.5M|    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|  15.5M|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|  15.5M|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|  15.5M|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE8transferINS7_INS3_4pairIKS9_lEEEEEEDaPT_PNS1_13map_slot_typeIS9_lEESK_:
  442|  3.02M|                       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|  3.02M|    auto is_relocatable = typename std::conjunction<
  449|  3.02M|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|  3.02M|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|  3.02M|        type();
  452|       |
  453|  3.02M|    emplace(new_slot);
  454|  3.02M|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [Folded, False: 3.02M]
  ------------------
  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|  3.02M|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 3.02M, Folded]
  ------------------
  463|  3.02M|      absl::allocator_traits<Allocator>::construct(
  464|  3.02M|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|  3.02M|    } else {
  466|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                   std::move(old_slot->value));
  468|      0|    }
  469|  3.02M|    destroy(alloc, old_slot);
  470|  3.02M|    return is_relocatable;
  471|  3.02M|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE7emplaceEPNS1_13map_slot_typeIS9_lEE:
  368|  5.16M|  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|  5.16M|    new (slot) slot_type;
  372|  5.16M|  }
_ZN4absl12lts_2026010718container_internal13map_slot_typeINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElEC2Ev:
  349|  5.16M|  map_slot_type() {}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_11HashElementINS1_10StringHashELb1EEEJRNSt3__14pairIKNS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|  2.87M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  2.87M|  return memory_internal::DecomposePairImpl(
  228|  2.87M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  2.87M|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS1_10StringHashELb1EEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENS7_5tupleIJRKlEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS7_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS7_4pairISO_SP_EE:
  158|  2.87M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  2.87M|  const auto& key = std::get<0>(p.first);
  160|  2.87M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  2.87M|                            std::move(p.second));
  162|  2.87M|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSG_IJRKlEEEEEEmRKT_DpOT0_:
  498|  2.87M|  size_t operator()(const K& key, Args&&...) const {
  499|  2.87M|    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|  2.87M|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|  2.87M|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|  2.87M|  }
_ZN4absl12lts_2026010718container_internal7HashKeyINS1_10StringHashENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEELb1EEC2ERKS3_RKS8_:
  515|  15.3k|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026010718container_internal7HashKeyINS1_10StringHashENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEELb1EEclEm:
  517|  6.57k|  size_t operator()(size_t seed) const {
  518|  6.57k|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|  6.57k|  }
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEEmRKT_DpOT0_:
  498|   430k|  size_t operator()(const K& key, Args&&...) const {
  499|   430k|    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|   430k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   430k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   430k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE9constructINS7_INS3_4pairIKS9_lEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKNS3_17basic_string_viewIcS6_EEEEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_lEEDpOT0_:
  397|   189k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   189k|    emplace(slot);
  399|   189k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 189k, Folded]
  ------------------
  400|   189k|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   189k|                                                   std::forward<Args>(args)...);
  402|   189k|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|   189k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE8transferINS7_INS3_4pairIKS9_fEEEEEEDaPT_PNS1_13map_slot_typeIS9_fEESK_:
  442|   315k|                       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|   315k|    auto is_relocatable = typename std::conjunction<
  449|   315k|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|   315k|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|   315k|        type();
  452|       |
  453|   315k|    emplace(new_slot);
  454|   315k|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [Folded, False: 315k]
  ------------------
  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|   315k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 315k, Folded]
  ------------------
  463|   315k|      absl::allocator_traits<Allocator>::construct(
  464|   315k|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|   315k|    } else {
  466|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                   std::move(old_slot->value));
  468|      0|    }
  469|   315k|    destroy(alloc, old_slot);
  470|   315k|    return is_relocatable;
  471|   315k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE7emplaceEPNS1_13map_slot_typeIS9_fEE:
  368|   821k|  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|   821k|    new (slot) slot_type;
  372|   821k|  }
_ZN4absl12lts_2026010718container_internal13map_slot_typeINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEC2Ev:
  349|   821k|  map_slot_type() {}
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE7destroyINS7_INS3_4pairIKS9_fEEEEEEDaPT_PNS1_13map_slot_typeIS9_fEE:
  431|   821k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|   821k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 821k, Folded]
  ------------------
  433|   821k|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|   821k|    } else {
  435|      0|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|   821k|    return IsDestructionTrivial<Allocator, value_type>();
  438|   821k|  }
_ZN4absl12lts_2026010718container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKNS3_12basic_stringIcNS3_11char_traitsIcEENS4_IcEEEEfEEEESC_EEDav:
   81|   821k|constexpr auto IsDestructionTrivial() {
   82|   821k|  constexpr bool result =
   83|   821k|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [Folded, False: 821k]
  ------------------
   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|   821k|  return std::integral_constant<bool, result>();
   88|   821k|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_11HashElementINS1_10StringHashELb1EEEJRNSt3__14pairIKNS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|   252k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   252k|  return memory_internal::DecomposePairImpl(
  228|   252k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   252k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS1_10StringHashELb1EEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENS7_5tupleIJRKfEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS7_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS7_4pairISO_SP_EE:
  158|   252k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   252k|  const auto& key = std::get<0>(p.first);
  160|   252k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   252k|                            std::move(p.second));
  162|   252k|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSG_IJRKfEEEEEEmRKT_DpOT0_:
  498|   252k|  size_t operator()(const K& key, Args&&...) const {
  499|   252k|    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|   252k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   252k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   252k|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE:
  207|   689k|    const std::pair<F, S>& p) {
  208|   689k|  return PairArgs(p.first, p.second);
  209|   689k|}
_ZN4absl12lts_2026010718container_internal8PairArgsIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKfEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_:
  201|   947k|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|   947k|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|   947k|          std::forward_as_tuple(std::forward<S>(s))};
  204|   947k|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEfEEJEE19EmplaceDecomposableEJRKNS5_4pairISB_fEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  226|   258k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   258k|  return memory_internal::DecomposePairImpl(
  228|   258k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   258k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE19EmplaceDecomposableERKSC_NS6_5tupleIJRKfEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSI_IJSN_EEEEEclsr3stdE7declvalIT1_EEEEOSM_NS6_4pairISQ_SR_EE:
  158|   258k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   258k|  const auto& key = std::get<0>(p.first);
  160|   258k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   258k|                            std::move(p.second));
  162|   258k|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_8StringEqEEEJRNS4_4pairIKSA_fEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|   436k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   436k|  return memory_internal::DecomposePairImpl(
  228|   436k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   436k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS1_8StringEqEEERKSB_NS5_5tupleIJRKfEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS5_4pairISO_SP_EE:
  158|   436k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   436k|  const auto& key = std::get<0>(p.first);
  160|   436k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   436k|                            std::move(p.second));
  162|   436k|}
_ZNK4absl12lts_2026010718container_internal12EqualElementINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS1_8StringEqEEclIS9_JRKNS3_21piecewise_construct_tENS3_5tupleIJRKS9_EEENSG_IJRKfEEEEEEbRKT_DpOT0_:
  529|   436k|  bool operator()(const K2& lhs, Args&&...) const {
  530|   436k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|   436k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|   436k|  }
_ZN4absl12lts_2026010718container_internal7HashKeyINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEC2ERKS3_RKSA_:
  515|  42.7k|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026010718container_internal7HashKeyINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEclEm:
  517|  21.0k|  size_t operator()(size_t seed) const {
  518|  21.0k|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|  21.0k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE9constructINS7_INS3_4pairIKS9_fEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJRKfEEEEEEvPT_PNS1_13map_slot_typeIS9_fEEDpOT0_:
  397|   258k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   258k|    emplace(slot);
  399|   258k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 258k, Folded]
  ------------------
  400|   258k|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   258k|                                                   std::forward<Args>(args)...);
  402|   258k|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|   258k|  }
_ZN4absl12lts_2026010718container_internal8PairArgsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEENS3_4pairINS3_5tupleIJRKT_EEENSB_IJRKT0_EEEEERKNSA_ISC_SG_EE:
  207|   258k|    const std::pair<F, S>& p) {
  208|   258k|  return PairArgs(p.first, p.second);
  209|   258k|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_8StringEqEEEJRNS4_4pairIKSA_lEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|  11.3M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  11.3M|  return memory_internal::DecomposePairImpl(
  228|  11.3M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  11.3M|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS1_8StringEqEEERKSB_NS5_5tupleIJRKlEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS5_4pairISO_SP_EE:
  158|  11.3M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  11.3M|  const auto& key = std::get<0>(p.first);
  160|  11.3M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  11.3M|                            std::move(p.second));
  162|  11.3M|}
_ZNK4absl12lts_2026010718container_internal12EqualElementINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS1_8StringEqEEclIS9_JRKNS3_21piecewise_construct_tENS3_5tupleIJRKS9_EEENSG_IJRKlEEEEEEbRKT_DpOT0_:
  529|  11.3M|  bool operator()(const K2& lhs, Args&&...) const {
  530|  11.3M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  11.3M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  11.3M|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE9constructINS7_INS3_4pairIKS9_lEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOS9_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_lEEDpOT0_:
  397|   187k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   187k|    emplace(slot);
  399|   187k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 187k, Folded]
  ------------------
  400|   187k|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   187k|                                                   std::forward<Args>(args)...);
  402|   187k|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|   187k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE9constructINS7_INS3_4pairIKS9_lEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_lEEDpOT0_:
  397|  1.76M|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|  1.76M|    emplace(slot);
  399|  1.76M|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 1.76M, Folded]
  ------------------
  400|  1.76M|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|  1.76M|                                                   std::forward<Args>(args)...);
  402|  1.76M|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|  1.76M|  }
_ZN4absl12lts_2026010718container_internal21SanitizerPoisonObjectINS1_13map_slot_typeINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEEEvPKT_:
  263|    302|inline void SanitizerPoisonObject(const T* object) {
  264|    302|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  265|    302|}
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE9constructINS7_INS3_4pairIKS9_fEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_fEEDpOT0_:
  397|   247k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   247k|    emplace(slot);
  399|   247k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 247k, Folded]
  ------------------
  400|   247k|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   247k|                                                   std::forward<Args>(args)...);
  402|   247k|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|   247k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE7destroyINS7_INS3_4pairIKS9_mEEEEEEDaPT_PNS1_13map_slot_typeIS9_mEE:
  431|   253k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|   253k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 253k, Folded]
  ------------------
  433|   253k|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|   253k|    } else {
  435|      0|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|   253k|    return IsDestructionTrivial<Allocator, value_type>();
  438|   253k|  }
_ZN4absl12lts_2026010718container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKNS3_12basic_stringIcNS3_11char_traitsIcEENS4_IcEEEEmEEEESC_EEDav:
   81|   253k|constexpr auto IsDestructionTrivial() {
   82|   253k|  constexpr bool result =
   83|   253k|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [Folded, False: 253k]
  ------------------
   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|   253k|  return std::integral_constant<bool, result>();
   88|   253k|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS1_8StringEqEEEJRNS4_4pairIKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEmEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  226|  72.0k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  72.0k|  return memory_internal::DecomposePairImpl(
  228|  72.0k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  72.0k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_8StringEqEEERKNS5_12basic_stringIcS8_NS5_9allocatorIcEEEENS5_5tupleIJRKmEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSI_IJSN_EEEEEclsr3stdE7declvalIT1_EEEEOSM_NS5_4pairISQ_SR_EE:
  158|  72.0k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  72.0k|  const auto& key = std::get<0>(p.first);
  160|  72.0k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  72.0k|                            std::move(p.second));
  162|  72.0k|}
_ZNK4absl12lts_2026010718container_internal12EqualElementINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_8StringEqEEclINS3_12basic_stringIcS6_NS3_9allocatorIcEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKSE_EEENSI_IJRKmEEEEEEbRKT_DpOT0_:
  529|  72.0k|  bool operator()(const K2& lhs, Args&&...) const {
  530|  72.0k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  72.0k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  72.0k|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE:
  207|   212k|    const std::pair<F, S>& p) {
  208|   212k|  return PairArgs(p.first, p.second);
  209|   212k|}
_ZN4absl12lts_2026010718container_internal8PairArgsIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKmEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_:
  201|   212k|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|   212k|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|   212k|          std::forward_as_tuple(std::forward<S>(s))};
  204|   212k|}
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE8transferINS7_INS3_4pairIKS9_mEEEEEEDaPT_PNS1_13map_slot_typeIS9_mEESK_:
  442|   150k|                       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|   150k|    auto is_relocatable = typename std::conjunction<
  449|   150k|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|   150k|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|   150k|        type();
  452|       |
  453|   150k|    emplace(new_slot);
  454|   150k|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [Folded, False: 150k]
  ------------------
  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|   150k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 150k, Folded]
  ------------------
  463|   150k|      absl::allocator_traits<Allocator>::construct(
  464|   150k|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|   150k|    } else {
  466|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                   std::move(old_slot->value));
  468|      0|    }
  469|   150k|    destroy(alloc, old_slot);
  470|   150k|    return is_relocatable;
  471|   150k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE7emplaceEPNS1_13map_slot_typeIS9_mEE:
  368|   253k|  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|   253k|    new (slot) slot_type;
  372|   253k|  }
_ZN4absl12lts_2026010718container_internal13map_slot_typeINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmEC2Ev:
  349|   253k|  map_slot_type() {}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_11HashElementINS1_10StringHashELb1EEEJRNSt3__14pairIKNS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEmEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|   140k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   140k|  return memory_internal::DecomposePairImpl(
  228|   140k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   140k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS1_10StringHashELb1EEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENS7_5tupleIJRKmEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS7_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS7_4pairISO_SP_EE:
  158|   140k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   140k|  const auto& key = std::get<0>(p.first);
  160|   140k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   140k|                            std::move(p.second));
  162|   140k|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSG_IJRKmEEEEEEmRKT_DpOT0_:
  498|   140k|  size_t operator()(const K& key, Args&&...) const {
  499|   140k|    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|   140k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   140k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   140k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE9constructINS7_INS3_4pairIKS9_mEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKNS3_17basic_string_viewIcS6_EEEEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_mEEDpOT0_:
  397|   103k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   103k|    emplace(slot);
  399|   103k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 103k, Folded]
  ------------------
  400|   103k|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   103k|                                                   std::forward<Args>(args)...);
  402|   103k|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|   103k|  }
_ZN4absl12lts_2026010718container_internal20IsDestructionTrivialINSt3__19allocatorINS3_12basic_stringIcNS3_11char_traitsIcEENS4_IcEEEEEES9_EEDav:
   81|   134k|constexpr auto IsDestructionTrivial() {
   82|   134k|  constexpr bool result =
   83|   134k|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [Folded, False: 134k]
  ------------------
   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|   134k|  return std::integral_constant<bool, result>();
   88|   134k|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementImNSt3__18equal_toImEEEEJRNS4_4pairIKmPN13sentencepiece3bpe7Trainer6SymbolEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|  5.03M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  5.03M|  return memory_internal::DecomposePairImpl(
  228|  5.03M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  5.03M|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementImNSt3__18equal_toImEEEERKmNS5_5tupleIJRKPN13sentencepiece3bpe7Trainer6SymbolEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSB_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS5_4pairISO_SP_EE:
  158|  5.03M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  5.03M|  const auto& key = std::get<0>(p.first);
  160|  5.03M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  5.03M|                            std::move(p.second));
  162|  5.03M|}
_ZNK4absl12lts_2026010718container_internal12EqualElementImNSt3__18equal_toImEEEclImJRKNS3_21piecewise_construct_tENS3_5tupleIJRKmEEENSB_IJRKPN13sentencepiece3bpe7Trainer6SymbolEEEEEEEbRKT_DpOT0_:
  529|  5.03M|  bool operator()(const K2& lhs, Args&&...) const {
  530|  5.03M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  5.03M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  5.03M|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIKmPN13sentencepiece3bpe7Trainer6SymbolEEENSt3__14pairINS9_5tupleIJRKT_EEENSB_IJRKT0_EEEEERKNSA_ISC_SG_EE:
  207|  5.86M|    const std::pair<F, S>& p) {
  208|  5.86M|  return PairArgs(p.first, p.second);
  209|  5.86M|}
_ZN4absl12lts_2026010718container_internal8PairArgsIRKmRKPN13sentencepiece3bpe7Trainer6SymbolEEENSt3__14pairINSC_5tupleIJOT_EEENSE_IJOT0_EEEEESG_SJ_:
  201|  5.86M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  5.86M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  5.86M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  5.86M|}
_ZN4absl12lts_2026010718container_internal11HashElementINS0_13hash_internal4HashImEELb1EEC2ERKS5_m:
  495|  6.27M|  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
_ZNK4absl12lts_2026010718container_internal11HashElementINS0_13hash_internal4HashImEELb1EEclImJEEEmRKT_DpOT0_:
  498|  5.80M|  size_t operator()(const K& key, Args&&...) const {
  499|  5.80M|    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|  5.80M|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|  5.80M|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|  5.80M|  }
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE19EmplaceDecomposableEJRKNSt3__14pairIKmS9_EEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  226|   359k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   359k|  return memory_internal::DecomposePairImpl(
  228|   359k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   359k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE19EmplaceDecomposableERKmNSt3__15tupleIJRKSA_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSG_19piecewise_constructEEclsr3stdE7declvalINSH_IJSM_EEEEEclsr3stdE7declvalIT1_EEEEOSL_NSG_4pairISP_SQ_EE:
  158|   359k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   359k|  const auto& key = std::get<0>(p.first);
  160|   359k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   359k|                            std::move(p.second));
  162|   359k|}
_ZN4absl12lts_2026010718container_internal23TypeErasedApplyToSlotFnINS0_13hash_internal4HashImEEmLb1EEEmPKvPvm:
  542|  2.11k|size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
  543|  2.11k|  const auto* f = static_cast<const Fn*>(fn);
  544|  2.11k|  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
  545|  2.11k|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_11HashElementINS0_13hash_internal4HashImEELb1EEEJRNSt3__14pairIKmPN13sentencepiece3bpe7Trainer6SymbolEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSI_DpOSJ_:
  226|   468k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   468k|  return memory_internal::DecomposePairImpl(
  228|   468k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   468k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS0_13hash_internal4HashImEELb1EEERKmNSt3__15tupleIJRKPN13sentencepiece3bpe7Trainer6SymbolEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSB_19piecewise_constructEEclsr3stdE7declvalINSC_IJSM_EEEEEclsr3stdE7declvalIT1_EEEEOSL_NSB_4pairISP_SQ_EE:
  158|   468k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   468k|  const auto& key = std::get<0>(p.first);
  160|   468k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   468k|                            std::move(p.second));
  162|   468k|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS0_13hash_internal4HashImEELb1EEclImJRKNSt3__121piecewise_construct_tENS8_5tupleIJRKmEEENSC_IJRKPN13sentencepiece3bpe7Trainer6SymbolEEEEEEEmRKT_DpOT0_:
  498|   468k|  size_t operator()(const K& key, Args&&...) const {
  499|   468k|    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|   468k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   468k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   468k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyImPN13sentencepiece3bpe7Trainer6SymbolEE8transferINSt3__19allocatorINSA_4pairIKmS7_EEEEEEDaPT_PNS1_13map_slot_typeImS7_EESK_:
  442|   465k|                       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|   465k|    auto is_relocatable = typename std::conjunction<
  449|   465k|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|   465k|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|   465k|        type();
  452|       |
  453|   465k|    emplace(new_slot);
  454|   465k|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [True: 465k, Folded]
  ------------------
  455|       |      // TODO(b/247130232,b/251814870): remove casts after fixing warnings.
  456|   465k|      std::memcpy(static_cast<void*>(std::launder(&new_slot->value)),
  457|   465k|                  static_cast<const void*>(&old_slot->value),
  458|   465k|                  sizeof(value_type));
  459|   465k|      return is_relocatable;
  460|   465k|    }
  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|   465k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyImPN13sentencepiece3bpe7Trainer6SymbolEE7emplaceEPNS1_13map_slot_typeImS7_EE:
  368|   825k|  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|   825k|    new (slot) slot_type;
  372|   825k|  }
_ZN4absl12lts_2026010718container_internal13map_slot_typeImPN13sentencepiece3bpe7Trainer6SymbolEEC2Ev:
  349|   825k|  map_slot_type() {}
_ZN4absl12lts_2026010718container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEC2ERKS5_RKm:
  515|  1.79k|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026010718container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEclEm:
  517|  1.79k|  size_t operator()(size_t seed) const {
  518|  1.79k|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|  1.79k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyImPN13sentencepiece3bpe7Trainer6SymbolEE9constructINSt3__19allocatorINSA_4pairIKmS7_EEEEJRKNSA_21piecewise_construct_tENSA_5tupleIJRSD_EEENSJ_IJRKS7_EEEEEEvPT_PNS1_13map_slot_typeImS7_EEDpOT0_:
  397|   359k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   359k|    emplace(slot);
  399|   359k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 359k, Folded]
  ------------------
  400|   359k|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   359k|                                                   std::forward<Args>(args)...);
  402|   359k|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|   359k|  }
_ZN4absl12lts_2026010718container_internal23SanitizerUnpoisonObjectImEEvPKT_:
  268|  15.8M|inline void SanitizerUnpoisonObject(const T* object) {
  269|  15.8M|  SanitizerUnpoisonMemoryRegion(object, sizeof(T));
  270|  15.8M|}
_ZN4absl12lts_2026010718container_internal23SanitizerUnpoisonObjectIPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEvPKT_:
  268|   222k|inline void SanitizerUnpoisonObject(const T* object) {
  269|   222k|  SanitizerUnpoisonMemoryRegion(object, sizeof(T));
  270|   222k|}
_ZN4absl12lts_2026010718container_internal21SanitizerPoisonObjectIPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEvPKT_:
  263|   160k|inline void SanitizerPoisonObject(const T* object) {
  264|   160k|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  265|   160k|}
_ZN4absl12lts_2026010718container_internal8AllocateILm8ENSt3__19allocatorIPN13sentencepiece3bpe7Trainer6SymbolEEEEEPvPT0_m:
   62|  33.4k|void* Allocate(Alloc* alloc, size_t n) {
   63|  33.4k|  static_assert(Alignment > 0, "");
   64|  33.4k|  assert(n && "n must be positive");
   65|  33.4k|  using M = AlignedType<Alignment>;
   66|  33.4k|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   67|  33.4k|  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|  33.4k|  A my_mem_alloc(*alloc);
   72|  33.4k|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   73|       |  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   74|  33.4k|         "allocator does not respect alignment");
   75|  33.4k|  return p;
   76|  33.4k|}
_ZN4absl12lts_2026010718container_internal23SanitizerUnpoisonObjectIPN13sentencepiece3bpe7Trainer6SymbolEEEvPKT_:
  268|  6.41M|inline void SanitizerUnpoisonObject(const T* object) {
  269|  6.41M|  SanitizerUnpoisonMemoryRegion(object, sizeof(T));
  270|  6.41M|}
_ZN4absl12lts_2026010718container_internal21SanitizerPoisonObjectIPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEEEvPKT_:
  263|  15.4k|inline void SanitizerPoisonObject(const T* object) {
  264|  15.4k|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  265|  15.4k|}
_ZN4absl12lts_2026010718container_internal23SanitizerUnpoisonObjectIPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEEEvPKT_:
  268|  70.0k|inline void SanitizerUnpoisonObject(const T* object) {
  269|  70.0k|  SanitizerUnpoisonMemoryRegion(object, sizeof(T));
  270|  70.0k|}
_ZN4absl12lts_2026010718container_internal8AllocateILm8ENSt3__19allocatorImEEEEPvPT0_m:
   62|   696k|void* Allocate(Alloc* alloc, size_t n) {
   63|   696k|  static_assert(Alignment > 0, "");
   64|   696k|  assert(n && "n must be positive");
   65|   696k|  using M = AlignedType<Alignment>;
   66|   696k|  using A = typename absl::allocator_traits<Alloc>::template rebind_alloc<M>;
   67|   696k|  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|   696k|  A my_mem_alloc(*alloc);
   72|   696k|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   73|       |  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   74|   696k|         "allocator does not respect alignment");
   75|   696k|  return p;
   76|   696k|}
_ZN4absl12lts_2026010718container_internal14DecomposeValueINS1_12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEJEE19EmplaceDecomposableESB_EEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEclsr3stdE7declvalISG_EEEEOSF_OSG_:
  234|  56.8k|DecomposeValue(F&& f, Arg&& arg) {
  235|  56.8k|  const auto& key = arg;
  236|  56.8k|  return std::forward<F>(f)(key, std::forward<Arg>(arg));
  237|  56.8k|}
_ZN4absl12lts_2026010718container_internal14DecomposeValueINS1_12EqualElementINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_8StringEqEEERSA_EEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEclsr3stdE7declvalISF_EEEEOSE_OSF_:
  234|  5.62k|DecomposeValue(F&& f, Arg&& arg) {
  235|  5.62k|  const auto& key = arg;
  236|  5.62k|  return std::forward<F>(f)(key, std::forward<Arg>(arg));
  237|  5.62k|}
_ZNK4absl12lts_2026010718container_internal12EqualElementINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS1_8StringEqEEclIS9_JRS9_EEEbRKT_DpOT0_:
  529|  5.62k|  bool operator()(const K2& lhs, Args&&...) const {
  530|  5.62k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  5.62k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  5.62k|  }
_ZN4absl12lts_2026010718container_internal14DecomposeValueINS1_11HashElementINS1_10StringHashELb1EEERNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEclsr3stdE7declvalISF_EEEEOSE_OSF_:
  234|  60.9k|DecomposeValue(F&& f, Arg&& arg) {
  235|  60.9k|  const auto& key = arg;
  236|  60.9k|  return std::forward<F>(f)(key, std::forward<Arg>(arg));
  237|  60.9k|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJRSC_EEEmRKT_DpOT0_:
  498|  60.9k|  size_t operator()(const K& key, Args&&...) const {
  499|  60.9k|    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|  60.9k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|  60.9k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|  60.9k|  }
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementIjNSt3__18equal_toIjEEEEJRNS4_4pairIKjN13sentencepiece14unicode_script10ScriptTypeEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSF_DpOSG_:
  226|  31.3M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  31.3M|  return memory_internal::DecomposePairImpl(
  228|  31.3M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  31.3M|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementIjNSt3__18equal_toIjEEEERKjNS5_5tupleIJRKN13sentencepiece14unicode_script10ScriptTypeEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSB_IJSJ_EEEEEclsr3stdE7declvalIT1_EEEEOSI_NS5_4pairISM_SN_EE:
  158|  31.3M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  31.3M|  const auto& key = std::get<0>(p.first);
  160|  31.3M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  31.3M|                            std::move(p.second));
  162|  31.3M|}
_ZNK4absl12lts_2026010718container_internal12EqualElementIjNSt3__18equal_toIjEEEclIjJRKNS3_21piecewise_construct_tENS3_5tupleIJRKjEEENSB_IJRKN13sentencepiece14unicode_script10ScriptTypeEEEEEEEbRKT_DpOT0_:
  529|  31.3M|  bool operator()(const K2& lhs, Args&&...) const {
  530|  31.3M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  31.3M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  31.3M|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIKjN13sentencepiece14unicode_script10ScriptTypeEEENSt3__14pairINS7_5tupleIJRKT_EEENS9_IJRKT0_EEEEERKNS8_ISA_SE_EE:
  207|  31.6M|    const std::pair<F, S>& p) {
  208|  31.6M|  return PairArgs(p.first, p.second);
  209|  31.6M|}
_ZN4absl12lts_2026010718container_internal8PairArgsIRKjRKN13sentencepiece14unicode_script10ScriptTypeEEENSt3__14pairINSA_5tupleIJOT_EEENSC_IJOT0_EEEEESE_SH_:
  201|  31.6M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  31.6M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  31.6M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  31.6M|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEEJRNSt3__14pairIKjN13sentencepiece14unicode_script10ScriptTypeEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSG_DpOSH_:
  226|   229k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   229k|  return memory_internal::DecomposePairImpl(
  228|   229k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   229k|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEERKjNSt3__15tupleIJRKN13sentencepiece14unicode_script10ScriptTypeEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSB_19piecewise_constructEEclsr3stdE7declvalINSC_IJSK_EEEEEclsr3stdE7declvalIT1_EEEEOSJ_NSB_4pairISN_SO_EE:
  158|   229k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   229k|  const auto& key = std::get<0>(p.first);
  160|   229k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   229k|                            std::move(p.second));
  162|   229k|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS0_13hash_internal4HashIjEELb1EEclIjJRKNSt3__121piecewise_construct_tENS8_5tupleIJRKjEEENSC_IJRKN13sentencepiece14unicode_script10ScriptTypeEEEEEEEmRKT_DpOT0_:
  498|   229k|  size_t operator()(const K& key, Args&&...) const {
  499|   229k|    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|   229k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   229k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   229k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjN13sentencepiece14unicode_script10ScriptTypeEE8transferINSt3__19allocatorINS8_4pairIKjS5_EEEEEEDaPT_PNS1_13map_slot_typeIjS5_EESI_:
  442|   229k|                       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|   229k|    auto is_relocatable = typename std::conjunction<
  449|   229k|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|   229k|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|   229k|        type();
  452|       |
  453|   229k|    emplace(new_slot);
  454|   229k|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [True: 229k, Folded]
  ------------------
  455|       |      // TODO(b/247130232,b/251814870): remove casts after fixing warnings.
  456|   229k|      std::memcpy(static_cast<void*>(std::launder(&new_slot->value)),
  457|   229k|                  static_cast<const void*>(&old_slot->value),
  458|   229k|                  sizeof(value_type));
  459|   229k|      return is_relocatable;
  460|   229k|    }
  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|   229k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjN13sentencepiece14unicode_script10ScriptTypeEE7emplaceEPNS1_13map_slot_typeIjS5_EE:
  368|   357k|  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|   357k|    new (slot) slot_type;
  372|   357k|  }
_ZN4absl12lts_2026010718container_internal13map_slot_typeIjN13sentencepiece14unicode_script10ScriptTypeEEC2Ev:
  349|   357k|  map_slot_type() {}
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjN13sentencepiece14unicode_script10ScriptTypeEE9constructINSt3__19allocatorINS8_4pairIKjS5_EEEEJRKNS8_21piecewise_construct_tENS8_5tupleIJRSB_EEENSH_IJEEEEEEvPT_PNS1_13map_slot_typeIjS5_EEDpOT0_:
  397|   127k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   127k|    emplace(slot);
  399|   127k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 127k, Folded]
  ------------------
  400|   127k|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   127k|                                                   std::forward<Args>(args)...);
  402|   127k|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|   127k|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyIjN13sentencepiece14unicode_script10ScriptTypeEE9constructINSt3__19allocatorINS8_4pairIKjS5_EEEEJRKNS8_21piecewise_construct_tENS8_5tupleIJOjEEENSH_IJEEEEEEvPT_PNS1_13map_slot_typeIjS5_EEDpOT0_:
  397|    697|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|    697|    emplace(slot);
  399|    697|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 697, Folded]
  ------------------
  400|    697|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|    697|                                                   std::forward<Args>(args)...);
  402|    697|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|    697|  }

_ZNK4absl12lts_2026010718container_internal10StringHash14hash_with_seedENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEm:
   86|  19.3M|  size_t hash_with_seed(absl::string_view v, size_t seed) const {
   87|  19.3M|    return absl::hash_internal::HashWithSeed().hash(
   88|  19.3M|        absl::Hash<absl::string_view>{}, v, seed);
   89|  19.3M|  }
_ZNK4absl12lts_2026010718container_internal8StringEqclENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEES7_:
   98|  11.9M|  bool operator()(absl::string_view lhs, absl::string_view rhs) const {
   99|  11.9M|    return lhs == rhs;
  100|  11.9M|  }

_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEvE5applyINS1_12EqualElementIjNS4_8equal_toIjEEEEJRNS5_IKjS6_EEES7_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSI_DpOSJ_:
  130|  9.04M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  9.04M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  9.04M|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEvE5applyINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEEJRNS5_IKjS6_EEES7_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSJ_DpOSK_:
  130|   352k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   352k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   352k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIjlEEvE5applyINS1_12raw_hash_setIS4_JEE19EmplaceDecomposableEJRKjRKlES4_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSF_DpOSG_:
  130|   298k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   298k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   298k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIjlEEvE5applyINS1_12EqualElementIjNSt3__18equal_toIjEEEEJRNS8_4pairIKjlEEES4_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSH_DpOSI_:
  130|  10.6M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  10.6M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  10.6M|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIjlEEvE5applyINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEEJRNSt3__14pairIKjlEEES4_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSI_DpOSJ_:
  130|   302k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   302k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   302k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE5applyINS1_12EqualElementINS4_17basic_string_viewIcS7_EENS1_8StringEqEEEJRNS4_4pairIKSA_lEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSO_DpOSP_:
  130|   107k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   107k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   107k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS4_4pairIKSA_lEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|  2.87M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  2.87M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  2.87M|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS4_4pairIKSA_fEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|   252k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   252k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   252k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE5applyINS1_12raw_hash_setISB_JEE19EmplaceDecomposableEJRKNS4_4pairISA_fEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|   258k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   258k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   258k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE5applyINS1_12EqualElementISA_NS1_8StringEqEEEJRNS4_4pairIKSA_fEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|   436k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   436k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   436k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE5applyINS1_12EqualElementISA_NS1_8StringEqEEEJRNS4_4pairIKSA_lEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|  11.3M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  11.3M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  11.3M|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEvE5applyINS1_12EqualElementINS4_17basic_string_viewIcS7_EENS1_8StringEqEEEJRNS4_4pairIKSA_mEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSO_DpOSP_:
  130|  72.0k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  72.0k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  72.0k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS4_4pairIKSA_mEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|   140k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   140k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   140k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE5applyINS1_12EqualElementImNSt3__18equal_toImEEEEJRNSD_4pairIKmS8_EEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|  5.03M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  5.03M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  5.03M|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE5applyINS1_12raw_hash_setIS9_JEE19EmplaceDecomposableEJRKNSt3__14pairIKmS8_EEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|   359k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   359k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   359k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE5applyINS1_11HashElementINS0_13hash_internal4HashImEELb1EEEJRNSt3__14pairIKmS8_EEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSN_DpOSO_:
  130|   468k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   468k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   468k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE5applyINS1_12raw_hash_setISB_JEE19EmplaceDecomposableEJSA_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSI_DpOSJ_:
  130|  56.8k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  56.8k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  56.8k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE5applyINS1_12EqualElementISA_NS1_8StringEqEEEJRSA_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSJ_DpOSK_:
  130|  5.62k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  5.62k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  5.62k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRSA_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSJ_DpOSK_:
  130|  60.9k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  60.9k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  60.9k|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEvE5applyINS1_12EqualElementIjNSt3__18equal_toIjEEEEJRNSB_4pairIKjS6_EEES7_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSK_DpOSL_:
  130|  31.3M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  31.3M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  31.3M|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEvE5applyINS1_11HashElementINS0_13hash_internal4HashIjEELb1EEEJRNSt3__14pairIKjS6_EEES7_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSL_DpOSM_:
  130|   229k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   229k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   229k|  }

_ZN4absl12lts_2026010718container_internal13GroupSse2ImplC2EPKNS1_6ctrl_tE:
  280|  76.4M|  explicit GroupSse2Impl(const ctrl_t* pos) {
  281|  76.4M|    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
  282|  76.4M|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl5MatchEh:
  285|  75.4M|  BitMaskType Match(h2_t hash) const {
  286|  75.4M|    auto match = _mm_set1_epi8(static_cast<char>(hash));
  287|  75.4M|    return BitMaskType(
  288|  75.4M|        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  289|  75.4M|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl9MaskEmptyEv:
  292|  8.81M|  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|  8.81M|    auto match = _mm_set1_epi8(static_cast<char>(ctrl_t::kEmpty));
  299|  8.81M|    return NonIterableBitMaskType(
  300|  8.81M|        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  301|  8.81M|#endif
  302|  8.81M|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl8MaskFullEv:
  307|   616k|  BitMaskType MaskFull() const {
  308|   616k|    return BitMaskType(static_cast<uint16_t>(_mm_movemask_epi8(ctrl) ^ 0xffff));
  309|   616k|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl11MaskNonFullEv:
  314|   130k|  auto MaskNonFull() const {
  315|   130k|    return BitMaskType(static_cast<uint16_t>(_mm_movemask_epi8(ctrl)));
  316|   130k|  }
_ZN4absl12lts_2026010718container_internal16IsEmptyOrDeletedENS1_6ctrl_tE:
  228|  7.72M|inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
_ZN4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EEC2Et:
  133|   152M|  explicit BitMask(T mask) : Base(mask) {
  134|   152M|    if (Shift == 3 && !NullifyBitsOnIteration) {
  ------------------
  |  Branch (134:9): [Folded, False: 152M]
  |  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|   152M|  }
_ZN4absl12lts_2026010718container_internal18NonIterableBitMaskItLi16ELi0EEC2Et:
   85|   161M|  explicit NonIterableBitMask(T mask) : mask_(mask) {}
_ZNK4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EE5beginEv:
  153|  76.0M|  BitMask begin() const { return *this; }
_ZNK4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EE3endEv:
  154|  76.0M|  BitMask end() const { return BitMask(0); }
_ZN4absl12lts_2026010718container_internalneERKNS1_7BitMaskItLi16ELi0ELb0EEES5_:
  160|  84.7M|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  161|  84.7M|    return a.mask_ != b.mask_;
  162|  84.7M|  }
_ZNK4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EEdeEv:
  151|  75.4M|  uint32_t operator*() const { return Base::LowestBitSet(); }
_ZNK4absl12lts_2026010718container_internal18NonIterableBitMaskItLi16ELi0EE12LowestBitSetEv:
   90|  79.2M|  uint32_t LowestBitSet() const {
   91|  79.2M|    return container_internal::TrailingZeros(mask_) >> Shift;
   92|  79.2M|  }
_ZN4absl12lts_2026010718container_internal13TrailingZerosItEEjT_:
   63|  79.2M|uint32_t TrailingZeros(T x) {
   64|  79.2M|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  270|  79.2M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
   65|  79.2M|  return static_cast<uint32_t>(countr_zero(x));
   66|  79.2M|}
_ZNK4absl12lts_2026010718container_internal18NonIterableBitMaskItLi16ELi0EEcvbEv:
   87|  9.06M|  explicit operator bool() const { return this->mask_ != 0; }
_ZN4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EEppEv:
  143|  8.65M|  BitMask& operator++() {
  144|  8.65M|    if (Shift == 3 && NullifyBitsOnIteration) {
  ------------------
  |  Branch (144:9): [Folded, False: 8.65M]
  |  Branch (144:23): [Folded, False: 0]
  ------------------
  145|      0|      this->mask_ &= kMsbs8Bytes;
  146|      0|    }
  147|  8.65M|    this->mask_ &= (this->mask_ - 1);
  148|  8.65M|    return *this;
  149|  8.65M|  }

_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle10UnregisterEv:
  219|  59.0k|  inline void Unregister() {}
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle15RecordInsertHitEv:
  228|  20.0M|  inline void RecordInsertHit() {}
_ZN4absl12lts_2026010718container_internal21ShouldSampleNextTableEv:
  243|  59.1k|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|  59.1k|  return false;
  251|  59.1k|#endif  // ABSL_INTERNAL_HASHTABLEZ_SAMPLE
  252|  59.1k|}

_ZNK4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE14GetIsAllocatedEv:
  372|  5.84k|  bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
_ZNK4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE21GetSizeAndIsAllocatedEv:
  366|  8.77k|  const SizeType<A>& GetSizeAndIsAllocated() const {
  367|  8.77k|    return metadata_.template get<1>();
  368|  8.77k|  }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE14GetInlinedDataEv:
  396|  4.38k|  ABSL_ATTRIBUTE_NO_SANITIZE_CFI Pointer<A> GetInlinedData() {
  397|  4.38k|    return reinterpret_cast<Pointer<A>>(data_.inlined.inlined_data);
  398|  4.38k|  }
_ZNK4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE7GetSizeEv:
  370|  2.92k|  SizeType<A> GetSize() const { return GetSizeAndIsAllocated() >> 1; }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEEC2Ev:
  337|  1.46k|  Storage() : metadata_(A(), /* size and is_allocated */ 0u) {}
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE11EmplaceBackIJRKjEEERjDpOT_:
  817|  1.46k|auto Storage<T, N, A>::EmplaceBack(Args&&... args) -> Reference<A> {
  818|  1.46k|  StorageView<A> storage_view = MakeStorageView();
  819|  1.46k|  const SizeType<A> n = storage_view.size;
  820|  1.46k|  if (ABSL_PREDICT_TRUE(n != storage_view.capacity)) {
  ------------------
  |  |  190|  1.46k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 1.46k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 1.46k]
  |  |  |  Branch (190:57): [True: 1.46k, False: 0]
  |  |  ------------------
  ------------------
  821|       |    // Fast path; new element fits.
  822|  1.46k|    Pointer<A> last_ptr = storage_view.data + n;
  823|  1.46k|    AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
  824|  1.46k|                                  std::forward<Args>(args)...);
  825|  1.46k|    AddSize(1);
  826|  1.46k|    return *last_ptr;
  827|  1.46k|  }
  828|       |  // TODO(b/173712035): Annotate with musttail attribute to prevent regression.
  829|      0|  return EmplaceBackSlow(std::forward<Args>(args)...);
  830|  1.46k|}
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE15MakeStorageViewEv:
  412|  1.46k|  StorageView<A> MakeStorageView() {
  413|  1.46k|    return GetIsAllocated() ? StorageView<A>{GetAllocatedData(), GetSize(),
  ------------------
  |  Branch (413:12): [True: 0, False: 1.46k]
  ------------------
  414|      0|                                             GetAllocatedCapacity()}
  415|  1.46k|                            : StorageView<A>{GetInlinedData(), GetSize(),
  416|  1.46k|                                             GetInlinedCapacity()};
  417|  1.46k|  }
_ZNK4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE18GetInlinedCapacityEv:
  408|  1.46k|  SizeType<A> GetInlinedCapacity() const {
  409|  1.46k|    return static_cast<SizeType<A>>(kOptimalInlinedSize);
  410|  1.46k|  }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE12GetAllocatorEv:
  419|  1.46k|  A& GetAllocator() { return metadata_.template get<0>(); }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE7AddSizeEm:
  474|  1.46k|  void AddSize(SizeType<A> count) {
  475|  1.46k|    GetSizeAndIsAllocated() += count << static_cast<SizeType<A>>(1);
  476|  1.46k|  }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE21GetSizeAndIsAllocatedEv:
  364|  2.92k|  SizeType<A>& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE21DeallocateIfAllocatedEv:
  521|  1.46k|  void DeallocateIfAllocated() {
  522|  1.46k|    if (GetIsAllocated()) {
  ------------------
  |  Branch (522:9): [True: 0, False: 1.46k]
  ------------------
  523|      0|      MallocAdapter<A>::Deallocate(GetAllocator(), GetAllocatedData(),
  524|      0|                                   GetAllocatedCapacity());
  525|      0|    }
  526|  1.46k|  }
_ZN4absl12lts_2026010723inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEED2Ev:
  342|  1.46k|  ~Storage() {
  343|       |    // Fast path: if we are empty and not allocated, there's nothing to do.
  344|  1.46k|    if (GetSizeAndIsAllocated() == 0) {
  ------------------
  |  Branch (344:9): [True: 0, False: 1.46k]
  ------------------
  345|      0|      return;
  346|      0|    }
  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|  1.46k|    if (absl::is_trivially_destructible<ValueType<A>>::value &&
  ------------------
  |  Branch (351:9): [True: 0, Folded]
  ------------------
  352|  1.46k|        std::is_same<A, std::allocator<ValueType<A>>>::value) {
  ------------------
  |  Branch (352:9): [True: 0, Folded]
  ------------------
  353|  1.46k|      DeallocateIfAllocated();
  354|  1.46k|      return;
  355|  1.46k|    }
  356|       |
  357|      0|    DestroyContents();
  358|      0|  }

_ZN4absl12lts_2026010718container_internal15internal_layout11adl_barrier5AlignEmm:
  294|   558M|constexpr size_t Align(size_t n, size_t m) { return (n + m - 1) & ~(m - 1); }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm0EEEmv:
  418|  1.37M|  constexpr size_t Offset() const {
  419|  1.37M|    if constexpr (N == 0) {
  420|  1.37M|      return 0;
  421|       |    } else {
  422|       |      static_assert(N < NumOffsets, "Index out of bounds");
  423|       |      return adl_barrier::Align(
  424|       |          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|       |          ElementAlignment<N>::value);
  426|       |    }
  427|  1.37M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm0EEEmv:
  456|  1.37M|  constexpr size_t Size() const {
  457|  1.37M|    if constexpr (N < NumStaticSizes) {
  458|  1.37M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  1.37M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm1EEEmv:
  418|  1.37M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  1.37M|    } else {
  422|  1.37M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  1.37M|      return adl_barrier::Align(
  424|  1.37M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  1.37M|          ElementAlignment<N>::value);
  426|  1.37M|    }
  427|  1.37M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm1EEEmv:
  456|  1.37M|  constexpr size_t Size() const {
  457|  1.37M|    if constexpr (N < NumStaticSizes) {
  458|  1.37M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  1.37M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm2EEEmv:
  418|  1.37M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  1.37M|    } else {
  422|  1.37M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  1.37M|      return adl_barrier::Align(
  424|  1.37M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  1.37M|          ElementAlignment<N>::value);
  426|  1.37M|    }
  427|  1.37M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm2EEEmv:
  456|  1.37M|  constexpr size_t Size() const {
  457|  1.37M|    if constexpr (N < NumStaticSizes) {
  458|  1.37M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  1.37M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm3EEEmv:
  418|  1.37M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  1.37M|    } else {
  422|  1.37M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  1.37M|      return adl_barrier::Align(
  424|  1.37M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  1.37M|          ElementAlignment<N>::value);
  426|  1.37M|    }
  427|  1.37M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm3EEEmv:
  456|  1.37M|  constexpr size_t Size() const {
  457|       |    if constexpr (N < NumStaticSizes) {
  458|       |      return kStaticSizes[N];
  459|  1.37M|    } else {
  460|  1.37M|      static_assert(N < NumSizes, "Index out of bounds");
  461|  1.37M|      return size_[N - NumStaticSizes];
  462|  1.37M|    }
  463|  1.37M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm4EEEmv:
  418|  1.37M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  1.37M|    } else {
  422|  1.37M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  1.37M|      return adl_barrier::Align(
  424|  1.37M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  1.37M|          ElementAlignment<N>::value);
  426|  1.37M|    }
  427|  1.37M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm4EEEmv:
  456|  1.37M|  constexpr size_t Size() const {
  457|       |    if constexpr (N < NumStaticSizes) {
  458|       |      return kStaticSizes[N];
  459|  1.37M|    } else {
  460|  1.37M|      static_assert(N < NumSizes, "Index out of bounds");
  461|  1.37M|      return size_[N - NumStaticSizes];
  462|  1.37M|    }
  463|  1.37M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E9AllocSizeEv:
  608|  1.37M|  constexpr size_t AllocSize() const {
  609|  1.37M|    static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
  610|  1.37M|    return Offset<NumTypes - 1>() +
  611|  1.37M|           SizeOf<ElementType<NumTypes - 1>>::value * Size<NumTypes - 1>();
  612|  1.37M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E6OffsetILm0EEEmv:
  418|  62.3k|  constexpr size_t Offset() const {
  419|  62.3k|    if constexpr (N == 0) {
  420|  62.3k|      return 0;
  421|       |    } else {
  422|       |      static_assert(N < NumOffsets, "Index out of bounds");
  423|       |      return adl_barrier::Align(
  424|       |          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|       |          ElementAlignment<N>::value);
  426|       |    }
  427|  62.3k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E4SizeILm0EEEmv:
  456|  62.3k|  constexpr size_t Size() const {
  457|  62.3k|    if constexpr (N < NumStaticSizes) {
  458|  62.3k|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  62.3k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E6OffsetILm1EEEmv:
  418|  62.3k|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  62.3k|    } else {
  422|  62.3k|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  62.3k|      return adl_barrier::Align(
  424|  62.3k|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  62.3k|          ElementAlignment<N>::value);
  426|  62.3k|    }
  427|  62.3k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E4SizeILm1EEEmv:
  456|  62.3k|  constexpr size_t Size() const {
  457|  62.3k|    if constexpr (N < NumStaticSizes) {
  458|  62.3k|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  62.3k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E6OffsetILm2EEEmv:
  418|  62.3k|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  62.3k|    } else {
  422|  62.3k|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  62.3k|      return adl_barrier::Align(
  424|  62.3k|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  62.3k|          ElementAlignment<N>::value);
  426|  62.3k|    }
  427|  62.3k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E4SizeILm2EEEmv:
  456|  62.3k|  constexpr size_t Size() const {
  457|  62.3k|    if constexpr (N < NumStaticSizes) {
  458|  62.3k|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  62.3k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E6OffsetILm3EEEmv:
  418|  62.3k|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  62.3k|    } else {
  422|  62.3k|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  62.3k|      return adl_barrier::Align(
  424|  62.3k|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  62.3k|          ElementAlignment<N>::value);
  426|  62.3k|    }
  427|  62.3k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E4SizeILm3EEEmv:
  456|  62.3k|  constexpr size_t Size() const {
  457|       |    if constexpr (N < NumStaticSizes) {
  458|       |      return kStaticSizes[N];
  459|  62.3k|    } else {
  460|  62.3k|      static_assert(N < NumSizes, "Index out of bounds");
  461|  62.3k|      return size_[N - NumStaticSizes];
  462|  62.3k|    }
  463|  62.3k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E6OffsetILm4EEEmv:
  418|  62.3k|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  62.3k|    } else {
  422|  62.3k|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  62.3k|      return adl_barrier::Align(
  424|  62.3k|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  62.3k|          ElementAlignment<N>::value);
  426|  62.3k|    }
  427|  62.3k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E4SizeILm4EEEmv:
  456|  62.3k|  constexpr size_t Size() const {
  457|       |    if constexpr (N < NumStaticSizes) {
  458|       |      return kStaticSizes[N];
  459|  62.3k|    } else {
  460|  62.3k|      static_assert(N < NumSizes, "Index out of bounds");
  461|  62.3k|      return size_[N - NumStaticSizes];
  462|  62.3k|    }
  463|  62.3k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E9AllocSizeEv:
  608|  62.3k|  constexpr size_t AllocSize() const {
  609|  62.3k|    static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
  610|  62.3k|    return Offset<NumTypes - 1>() +
  611|  62.3k|           SizeOf<ElementType<NumTypes - 1>>::value * Size<NumTypes - 1>();
  612|  62.3k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E6OffsetILm0EEEmv:
  418|  84.8M|  constexpr size_t Offset() const {
  419|  84.8M|    if constexpr (N == 0) {
  420|  84.8M|      return 0;
  421|       |    } else {
  422|       |      static_assert(N < NumOffsets, "Index out of bounds");
  423|       |      return adl_barrier::Align(
  424|       |          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|       |          ElementAlignment<N>::value);
  426|       |    }
  427|  84.8M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E4SizeILm0EEEmv:
  456|  83.4M|  constexpr size_t Size() const {
  457|  83.4M|    if constexpr (N < NumStaticSizes) {
  458|  83.4M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  83.4M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E6OffsetILm1EEEmv:
  418|  83.4M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  83.4M|    } else {
  422|  83.4M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  83.4M|      return adl_barrier::Align(
  424|  83.4M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  83.4M|          ElementAlignment<N>::value);
  426|  83.4M|    }
  427|  83.4M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E4SizeILm1EEEmv:
  456|  83.4M|  constexpr size_t Size() const {
  457|  83.4M|    if constexpr (N < NumStaticSizes) {
  458|  83.4M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  83.4M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E6OffsetILm2EEEmv:
  418|  83.4M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  83.4M|    } else {
  422|  83.4M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  83.4M|      return adl_barrier::Align(
  424|  83.4M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  83.4M|          ElementAlignment<N>::value);
  426|  83.4M|    }
  427|  83.4M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E4SizeILm2EEEmv:
  456|  33.7M|  constexpr size_t Size() const {
  457|  33.7M|    if constexpr (N < NumStaticSizes) {
  458|  33.7M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  33.7M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E6OffsetILm3EEEmv:
  418|  33.7M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  33.7M|    } else {
  422|  33.7M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  33.7M|      return adl_barrier::Align(
  424|  33.7M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  33.7M|          ElementAlignment<N>::value);
  426|  33.7M|    }
  427|  33.7M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E4SizeILm3EEEmv:
  456|  2.60M|  constexpr size_t Size() const {
  457|  2.60M|    if constexpr (N < NumStaticSizes) {
  458|  2.60M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  2.60M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E6OffsetILm4EEEmv:
  418|  2.60M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  2.60M|    } else {
  422|  2.60M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  2.60M|      return adl_barrier::Align(
  424|  2.60M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  2.60M|          ElementAlignment<N>::value);
  426|  2.60M|    }
  427|  2.60M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E4SizeILm4EEEmv:
  456|  4.50k|  constexpr size_t Size() const {
  457|  4.50k|    if constexpr (N < NumStaticSizes) {
  458|  4.50k|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  4.50k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E9AllocSizeEv:
  608|  4.50k|  constexpr size_t AllocSize() const {
  609|  4.50k|    static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
  610|  4.50k|    return Offset<NumTypes - 1>() +
  611|  4.50k|           SizeOf<ElementType<NumTypes - 1>>::value * Size<NumTypes - 1>();
  612|  4.50k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E7PointerILm2EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESG_E4typeESS_E4typeEPSP_:
  496|  48.8M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  48.8M|    using C = typename std::remove_const<Char>::type;
  498|  48.8M|    static_assert(
  499|  48.8M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  48.8M|            std::is_same<C, signed char>(),
  501|  48.8M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  48.8M|    constexpr size_t alignment = Alignment();
  503|  48.8M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  48.8M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  48.8M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E7PointerILm3EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESG_E4typeESR_E4typeEPSO_:
  496|  12.1M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  12.1M|    using C = typename std::remove_const<Char>::type;
  498|  12.1M|    static_assert(
  499|  12.1M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  12.1M|            std::is_same<C, signed char>(),
  501|  12.1M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  12.1M|    constexpr size_t alignment = Alignment();
  503|  12.1M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  12.1M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  12.1M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E7PointerILm0EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESG_E4typeESS_E4typeEPSP_:
  496|  1.33M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  1.33M|    using C = typename std::remove_const<Char>::type;
  498|  1.33M|    static_assert(
  499|  1.33M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  1.33M|            std::is_same<C, signed char>(),
  501|  1.33M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  1.33M|    constexpr size_t alignment = Alignment();
  503|  1.33M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  1.33M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  1.33M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E7PointerILm4EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESG_E4typeESS_E4typeEPSP_:
  496|  2.44M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  2.44M|    using C = typename std::remove_const<Char>::type;
  498|  2.44M|    static_assert(
  499|  2.44M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  2.44M|            std::is_same<C, signed char>(),
  501|  2.44M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  2.44M|    constexpr size_t alignment = Alignment();
  503|  2.44M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  2.44M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  2.44M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm0EEEmv:
  418|   150M|  constexpr size_t Offset() const {
  419|   150M|    if constexpr (N == 0) {
  420|   150M|      return 0;
  421|       |    } else {
  422|       |      static_assert(N < NumOffsets, "Index out of bounds");
  423|       |      return adl_barrier::Align(
  424|       |          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|       |          ElementAlignment<N>::value);
  426|       |    }
  427|   150M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm0EEEmv:
  456|   141M|  constexpr size_t Size() const {
  457|   141M|    if constexpr (N < NumStaticSizes) {
  458|   141M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|   141M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm1EEEmv:
  418|   141M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|   141M|    } else {
  422|   141M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|   141M|      return adl_barrier::Align(
  424|   141M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|   141M|          ElementAlignment<N>::value);
  426|   141M|    }
  427|   141M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm1EEEmv:
  456|   141M|  constexpr size_t Size() const {
  457|   141M|    if constexpr (N < NumStaticSizes) {
  458|   141M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|   141M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm2EEEmv:
  418|   141M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|   141M|    } else {
  422|   141M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|   141M|      return adl_barrier::Align(
  424|   141M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|   141M|          ElementAlignment<N>::value);
  426|   141M|    }
  427|   141M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm2EEEmv:
  456|  63.0M|  constexpr size_t Size() const {
  457|  63.0M|    if constexpr (N < NumStaticSizes) {
  458|  63.0M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  63.0M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm3EEEmv:
  418|  63.0M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  63.0M|    } else {
  422|  63.0M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  63.0M|      return adl_barrier::Align(
  424|  63.0M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  63.0M|          ElementAlignment<N>::value);
  426|  63.0M|    }
  427|  63.0M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm3EEEmv:
  456|  2.87M|  constexpr size_t Size() const {
  457|  2.87M|    if constexpr (N < NumStaticSizes) {
  458|  2.87M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  2.87M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm4EEEmv:
  418|  2.87M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  2.87M|    } else {
  422|  2.87M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  2.87M|      return adl_barrier::Align(
  424|  2.87M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  2.87M|          ElementAlignment<N>::value);
  426|  2.87M|    }
  427|  2.87M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm4EEEmv:
  456|  23.4k|  constexpr size_t Size() const {
  457|  23.4k|    if constexpr (N < NumStaticSizes) {
  458|  23.4k|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  23.4k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E9AllocSizeEv:
  608|  23.4k|  constexpr size_t AllocSize() const {
  609|  23.4k|    static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
  610|  23.4k|    return Offset<NumTypes - 1>() +
  611|  23.4k|           SizeOf<ElementType<NumTypes - 1>>::value * Size<NumTypes - 1>();
  612|  23.4k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm2EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESN_E4typeEPSK_:
  496|  70.9M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  70.9M|    using C = typename std::remove_const<Char>::type;
  498|  70.9M|    static_assert(
  499|  70.9M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  70.9M|            std::is_same<C, signed char>(),
  501|  70.9M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  70.9M|    constexpr size_t alignment = Alignment();
  503|  70.9M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  70.9M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  70.9M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm3EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESM_E4typeEPSJ_:
  496|  18.2M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  18.2M|    using C = typename std::remove_const<Char>::type;
  498|  18.2M|    static_assert(
  499|  18.2M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  18.2M|            std::is_same<C, signed char>(),
  501|  18.2M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  18.2M|    constexpr size_t alignment = Alignment();
  503|  18.2M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  18.2M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  18.2M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm0EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESN_E4typeEPSK_:
  496|  8.15M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  8.15M|    using C = typename std::remove_const<Char>::type;
  498|  8.15M|    static_assert(
  499|  8.15M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  8.15M|            std::is_same<C, signed char>(),
  501|  8.15M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  8.15M|    constexpr size_t alignment = Alignment();
  503|  8.15M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  8.15M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  8.15M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm4EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESN_E4typeEPSK_:
  496|  2.22M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  2.22M|    using C = typename std::remove_const<Char>::type;
  498|  2.22M|    static_assert(
  499|  2.22M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  2.22M|            std::is_same<C, signed char>(),
  501|  2.22M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  2.22M|    constexpr size_t alignment = Alignment();
  503|  2.22M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  2.22M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  2.22M|  }
_ZN4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_EC2Ev:
  401|  84.8M|      : size_{sizes...} {}
_ZN4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSH_ImJLm0ELm1EEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_EC2Emm:
  401|  62.3k|      : size_{sizes...} {}
_ZN4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_EC2Ev:
  401|   150M|      : size_{sizes...} {}
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm2EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESM_E4typeEPSJ_:
  496|  7.48M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  7.48M|    using C = typename std::remove_const<Char>::type;
  498|  7.48M|    static_assert(
  499|  7.48M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  7.48M|            std::is_same<C, signed char>(),
  501|  7.48M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  7.48M|    constexpr size_t alignment = Alignment();
  503|  7.48M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  7.48M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  7.48M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm0EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESM_E4typeEPSJ_:
  496|   730k|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|   730k|    using C = typename std::remove_const<Char>::type;
  498|   730k|    static_assert(
  499|   730k|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|   730k|            std::is_same<C, signed char>(),
  501|   730k|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|   730k|    constexpr size_t alignment = Alignment();
  503|   730k|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|   730k|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|   730k|  }
_ZN4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_EC2Emm:
  401|  1.37M|      : size_{sizes...} {}
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm4EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESM_E4typeEPSJ_:
  496|   617k|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|   617k|    using C = typename std::remove_const<Char>::type;
  498|   617k|    static_assert(
  499|   617k|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|   617k|            std::is_same<C, signed char>(),
  501|   617k|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|   617k|    constexpr size_t alignment = Alignment();
  503|   617k|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|   617k|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|   617k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E7PointerILm0EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESG_E4typeESR_E4typeEPSO_:
  496|  42.7k|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  42.7k|    using C = typename std::remove_const<Char>::type;
  498|  42.7k|    static_assert(
  499|  42.7k|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  42.7k|            std::is_same<C, signed char>(),
  501|  42.7k|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  42.7k|    constexpr size_t alignment = Alignment();
  503|  42.7k|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  42.7k|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  42.7k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E7PointerILm2EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESG_E4typeESR_E4typeEPSO_:
  496|   865k|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|   865k|    using C = typename std::remove_const<Char>::type;
  498|   865k|    static_assert(
  499|   865k|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|   865k|            std::is_same<C, signed char>(),
  501|   865k|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|   865k|    constexpr size_t alignment = Alignment();
  503|   865k|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|   865k|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|   865k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E7PointerILm3EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESG_E4typeESS_E4typeEPSP_:
  496|  19.0M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  19.0M|    using C = typename std::remove_const<Char>::type;
  498|  19.0M|    static_assert(
  499|  19.0M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  19.0M|            std::is_same<C, signed char>(),
  501|  19.0M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  19.0M|    constexpr size_t alignment = Alignment();
  503|  19.0M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  19.0M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  19.0M|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implIPN13sentencepiece3bpe7Trainer6SymbolEJEEEEEjhSC_SF_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSH_ImJEEENSH_ImJLm0ELm1ELm2ELm3ELm4EEEESK_E7PointerILm4EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESG_E4typeESR_E4typeEPSO_:
  496|   157k|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|   157k|    using C = typename std::remove_const<Char>::type;
  498|   157k|    static_assert(
  499|   157k|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|   157k|            std::is_same<C, signed char>(),
  501|   157k|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|   157k|    constexpr size_t alignment = Alignment();
  503|   157k|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|   157k|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|   157k|  }
_ZNK4absl12lts_2026010718container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm3EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESN_E4typeEPSK_:
  496|  41.9M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  41.9M|    using C = typename std::remove_const<Char>::type;
  498|  41.9M|    static_assert(
  499|  41.9M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  41.9M|            std::is_same<C, signed char>(),
  501|  41.9M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  41.9M|    constexpr size_t alignment = Alignment();
  503|  41.9M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  41.9M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  41.9M|  }

_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEEC2Ev:
  107|  1.81k|  raw_hash_map() {}
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjlEEJEEC2Ev:
  107|  10.1k|  raw_hash_map() {}
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEEC2Ev:
  107|  10.1k|  raw_hash_map() {}
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEEixIjS7_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS5_IKjS6_EEEEPT_RSE_EclL_ZNS4_7declvalB8ne220000IRSD_EEDTclsr3stdE9__declvalISE_ELi0EEEvEEEEERSC_:
  331|  9.22M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  332|       |    // It is safe to use unchecked_deref here because try_emplace
  333|       |    // will always return an iterator pointing to a valid item in the table,
  334|       |    // since it inserts if nothing is found for the given key.
  335|  9.22M|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  336|  9.22M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE11try_emplaceIjLi0EJETnNS4_9enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setIS7_JEE14const_iteratorEEE5valueEiE4typeELi0EEENS5_INSD_8iteratorEbEERKjDpOT1_:
  244|  9.22M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|  9.22M|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|  9.22M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE16try_emplace_implIRKjJEEENS5_INS1_12raw_hash_setIS7_JEE8iteratorEbEEOT_DpOT0_:
  367|  9.22M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  368|  9.22M|    auto res = this->find_or_prepare_insert(k);
  369|  9.22M|    if (res.second) {
  ------------------
  |  Branch (369:9): [True: 330k, False: 8.89M]
  ------------------
  370|   330k|      this->emplace_at(res.first, std::piecewise_construct,
  371|   330k|                       std::forward_as_tuple(std::forward<K>(k)),
  372|   330k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  373|   330k|    }
  374|  9.22M|    return res;
  375|  9.22M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEEC2Ev:
  107|  21.2k|  raw_hash_map() {}
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEEixINS4_17basic_string_viewIcS7_EESB_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS4_4pairIKSA_lEEEEPT_RSL_EclL_ZNS4_7declvalB8ne220000IRSK_EEDTclsr3stdE9__declvalISL_ELi0EEEvEEEEERKSL_:
  331|   275k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  332|       |    // It is safe to use unchecked_deref here because try_emplace
  333|       |    // will always return an iterator pointing to a valid item in the table,
  334|       |    // since it inserts if nothing is found for the given key.
  335|   275k|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  336|   275k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE11try_emplaceINS4_17basic_string_viewIcS7_EELi0EJETnNS4_9enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setISB_JEE14const_iteratorEEE5valueEiE4typeELi0EEENS4_4pairINSJ_8iteratorEbEERKSH_DpOT1_:
  244|   275k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|   275k|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|   275k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE16try_emplace_implIRKNS4_17basic_string_viewIcS7_EEJEEENS4_4pairINS1_12raw_hash_setISB_JEE8iteratorEbEEOT_DpOT0_:
  367|   275k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  368|   275k|    auto res = this->find_or_prepare_insert(k);
  369|   275k|    if (res.second) {
  ------------------
  |  Branch (369:9): [True: 189k, False: 86.0k]
  ------------------
  370|   189k|      this->emplace_at(res.first, std::piecewise_construct,
  371|   189k|                       std::forward_as_tuple(std::forward<K>(k)),
  372|   189k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  373|   189k|    }
  374|   275k|    return res;
  375|   275k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEEC2Ev:
  107|  13.7k|  raw_hash_map() {}
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEEixISA_SB_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS4_4pairIKSA_lEEEEPT_RSJ_EclL_ZNS4_7declvalB8ne220000IRSI_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEEEEEOSJ_:
  313|  6.02M|      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|  6.02M|    return Policy::value(&this->unchecked_deref(
  318|  6.02M|        try_emplace(std::forward<key_arg<K>>(key)).first));
  319|  6.02M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE11try_emplaceISA_Li0EJETnNS4_9enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setISB_JEE14const_iteratorEEE5valueEiE4typeELi0EEENS4_4pairINSH_8iteratorEbEEOSF_DpOT1_:
  223|  6.02M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  224|  6.02M|    return try_emplace_impl(std::forward<key_arg<K>>(k),
  225|  6.02M|                            std::forward<Args>(args)...);
  226|  6.02M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE16try_emplace_implISA_JEEENS4_4pairINS1_12raw_hash_setISB_JEE8iteratorEbEEOT_DpOT0_:
  367|  6.02M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  368|  6.02M|    auto res = this->find_or_prepare_insert(k);
  369|  6.02M|    if (res.second) {
  ------------------
  |  Branch (369:9): [True: 187k, False: 5.84M]
  ------------------
  370|   187k|      this->emplace_at(res.first, std::piecewise_construct,
  371|   187k|                       std::forward_as_tuple(std::forward<K>(k)),
  372|   187k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  373|   187k|    }
  374|  6.02M|    return res;
  375|  6.02M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEEixISA_SB_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS4_4pairIKSA_lEEEEPT_RSJ_EclL_ZNS4_7declvalB8ne220000IRSI_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEEEEERKSJ_:
  331|  6.73M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  332|       |    // It is safe to use unchecked_deref here because try_emplace
  333|       |    // will always return an iterator pointing to a valid item in the table,
  334|       |    // since it inserts if nothing is found for the given key.
  335|  6.73M|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  336|  6.73M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE11try_emplaceISA_Li0EJETnNS4_9enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setISB_JEE14const_iteratorEEE5valueEiE4typeELi0EEENS4_4pairINSH_8iteratorEbEERKSF_DpOT1_:
  244|  6.73M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|  6.73M|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|  6.73M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE16try_emplace_implIRKSA_JEEENS4_4pairINS1_12raw_hash_setISB_JEE8iteratorEbEEOT_DpOT0_:
  367|  6.73M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  368|  6.73M|    auto res = this->find_or_prepare_insert(k);
  369|  6.73M|    if (res.second) {
  ------------------
  |  Branch (369:9): [True: 1.76M, False: 4.97M]
  ------------------
  370|  1.76M|      this->emplace_at(res.first, std::piecewise_construct,
  371|  1.76M|                       std::forward_as_tuple(std::forward<K>(k)),
  372|  1.76M|                       std::forward_as_tuple(std::forward<Args>(args)...));
  373|  1.76M|    }
  374|  6.73M|    return res;
  375|  6.73M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEEC2Ev:
  107|  6.79k|  raw_hash_map() {}
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEEixISA_SB_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS4_4pairIKSA_fEEEEPT_RSJ_EclL_ZNS4_7declvalB8ne220000IRSI_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEEEEERKSJ_:
  331|   396k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  332|       |    // It is safe to use unchecked_deref here because try_emplace
  333|       |    // will always return an iterator pointing to a valid item in the table,
  334|       |    // since it inserts if nothing is found for the given key.
  335|   396k|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  336|   396k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE11try_emplaceISA_Li0EJETnNS4_9enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setISB_JEE14const_iteratorEEE5valueEiE4typeELi0EEENS4_4pairINSH_8iteratorEbEERKSF_DpOT1_:
  244|   396k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|   396k|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|   396k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE16try_emplace_implIRKSA_JEEENS4_4pairINS1_12raw_hash_setISB_JEE8iteratorEbEEOT_DpOT0_:
  367|   396k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  368|   396k|    auto res = this->find_or_prepare_insert(k);
  369|   396k|    if (res.second) {
  ------------------
  |  Branch (369:9): [True: 247k, False: 148k]
  ------------------
  370|   247k|      this->emplace_at(res.first, std::piecewise_construct,
  371|   247k|                       std::forward_as_tuple(std::forward<K>(k)),
  372|   247k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  373|   247k|    }
  374|   396k|    return res;
  375|   396k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEEC2Ev:
  107|  1.16k|  raw_hash_map() {}
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEEixINS4_17basic_string_viewIcS7_EESB_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS4_4pairIKSA_mEEEEPT_RSL_EclL_ZNS4_7declvalB8ne220000IRSK_EEDTclsr3stdE9__declvalISL_ELi0EEEvEEEEERKSL_:
  331|   164k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  332|       |    // It is safe to use unchecked_deref here because try_emplace
  333|       |    // will always return an iterator pointing to a valid item in the table,
  334|       |    // since it inserts if nothing is found for the given key.
  335|   164k|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  336|   164k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE11try_emplaceINS4_17basic_string_viewIcS7_EELi0EJETnNS4_9enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setISB_JEE14const_iteratorEEE5valueEiE4typeELi0EEENS4_4pairINSJ_8iteratorEbEERKSH_DpOT1_:
  244|   164k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|   164k|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|   164k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE16try_emplace_implIRKNS4_17basic_string_viewIcS7_EEJEEENS4_4pairINS1_12raw_hash_setISB_JEE8iteratorEbEEOT_DpOT0_:
  367|   164k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  368|   164k|    auto res = this->find_or_prepare_insert(k);
  369|   164k|    if (res.second) {
  ------------------
  |  Branch (369:9): [True: 103k, False: 61.6k]
  ------------------
  370|   103k|      this->emplace_at(res.first, std::piecewise_construct,
  371|   103k|                       std::forward_as_tuple(std::forward<K>(k)),
  372|   103k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  373|   103k|    }
  374|   164k|    return res;
  375|   164k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEEC2Ev:
  107|      1|  raw_hash_map() {}
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEEixIjS7_Li0EEEDTclsrT0_5valueclL_ZNSt3__19addressofB8ne220000INSB_4pairIKjS6_EEEEPT_RSG_EclL_ZNSB_7declvalB8ne220000IRSF_EEDTclsr3stdE9__declvalISG_ELi0EEEvEEEEERSE_:
  331|   127k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  332|       |    // It is safe to use unchecked_deref here because try_emplace
  333|       |    // will always return an iterator pointing to a valid item in the table,
  334|       |    // since it inserts if nothing is found for the given key.
  335|   127k|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  336|   127k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE11try_emplaceIjLi0EJETnNSt3__19enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setIS7_JEE14const_iteratorEEE5valueEiE4typeELi0EEENSA_4pairINSE_8iteratorEbEERKjDpOT1_:
  244|   127k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|   127k|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|   127k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE16try_emplace_implIRKjJEEENSt3__14pairINS1_12raw_hash_setIS7_JEE8iteratorEbEEOT_DpOT0_:
  367|   127k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  368|   127k|    auto res = this->find_or_prepare_insert(k);
  369|   127k|    if (res.second) {
  ------------------
  |  Branch (369:9): [True: 127k, False: 0]
  ------------------
  370|   127k|      this->emplace_at(res.first, std::piecewise_construct,
  371|   127k|                       std::forward_as_tuple(std::forward<K>(k)),
  372|   127k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  373|   127k|    }
  374|   127k|    return res;
  375|   127k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEEixIjS7_Li0EEEDTclsrT0_5valueclL_ZNSt3__19addressofB8ne220000INSB_4pairIKjS6_EEEEPT_RSG_EclL_ZNSB_7declvalB8ne220000IRSF_EEDTclsr3stdE9__declvalISG_ELi0EEEvEEEEEOj:
  313|    697|      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|    697|    return Policy::value(&this->unchecked_deref(
  318|    697|        try_emplace(std::forward<key_arg<K>>(key)).first));
  319|    697|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE11try_emplaceIjLi0EJETnNSt3__19enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setIS7_JEE14const_iteratorEEE5valueEiE4typeELi0EEENSA_4pairINSE_8iteratorEbEEOjDpOT1_:
  223|    697|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  224|    697|    return try_emplace_impl(std::forward<key_arg<K>>(k),
  225|    697|                            std::forward<Args>(args)...);
  226|    697|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE16try_emplace_implIjJEEENSt3__14pairINS1_12raw_hash_setIS7_JEE8iteratorEbEEOT_DpOT0_:
  367|    697|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  368|    697|    auto res = this->find_or_prepare_insert(k);
  369|    697|    if (res.second) {
  ------------------
  |  Branch (369:9): [True: 697, False: 0]
  ------------------
  370|    697|      this->emplace_at(res.first, std::piecewise_construct,
  371|    697|                       std::forward_as_tuple(std::forward<K>(k)),
  372|    697|                       std::forward_as_tuple(std::forward<Args>(args)...));
  373|    697|    }
  374|    697|    return res;
  375|    697|  }

_ZNK4absl12lts_2026010718container_internal12PerTableSeed4seedEv:
  445|  79.8M|  size_t seed() const {
  446|       |    // We use a sign-extended load to ensure high bits are non-zero.
  447|  79.8M|    int16_t seed_signed = absl::bit_cast<int16_t>(seed_);
  448|  79.8M|    auto seed_sign_extended =
  449|  79.8M|        static_cast<std::make_signed_t<size_t>>(seed_signed);
  450|  79.8M|    return absl::bit_cast<size_t>(seed_sign_extended);
  451|  79.8M|  }
_ZN4absl12lts_2026010718container_internal12PerTableSeedC2Et:
  455|  79.8M|  explicit PerTableSeed(uint16_t seed) : seed_(seed) {
  456|       |    ABSL_SWISSTABLE_ASSERT((seed & kSignBit) != 0 || seed == 0);
  ------------------
  |  |  248|  79.8M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  457|  79.8M|  }
_ZN4absl12lts_2026010718container_internal13HashtableSizeC2ENS1_19no_seed_empty_tag_tE:
  472|  75.8k|  explicit HashtableSize(no_seed_empty_tag_t) : data_(0) {}
_ZN4absl12lts_2026010718container_internal13HashtableSizeC2ENS1_14full_soo_tag_tE:
  473|  11.8k|  explicit HashtableSize(full_soo_tag_t) : data_(kSizeOneNoMetadata) {}
_ZNK4absl12lts_2026010718container_internal13HashtableSize4sizeEv:
  476|  7.28M|  size_t size() const { return static_cast<size_t>(data_ >> kSizeShift); }
_ZN4absl12lts_2026010718container_internal13HashtableSize14decrement_sizeEv:
  481|  57.1k|  void decrement_size() { data_ -= kSizeOneNoMetadata; }
_ZNK4absl12lts_2026010718container_internal13HashtableSize4seedEv:
  487|  79.8M|  PerTableSeed seed() const {
  488|  79.8M|    return PerTableSeed(static_cast<size_t>(data_) & kSeedMask);
  489|  79.8M|  }
_ZNK4absl12lts_2026010718container_internal13HashtableSize9has_infozEv:
  502|  24.0M|  bool has_infoz() const {
  503|  24.0M|    return ABSL_PREDICT_FALSE((data_ & kHasInfozMask) != 0);
  ------------------
  |  |  189|  24.0M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:49): [Folded, False: 24.0M]
  |  |  |  Branch (189:58): [True: 0, False: 24.0M]
  |  |  ------------------
  ------------------
  504|  24.0M|  }
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled19set_reserved_growthEm:
  631|  61.0k|  void set_reserved_growth(size_t) {}
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled20set_reservation_sizeEm:
  633|  61.0k|  void set_reservation_size(size_t) {}
_ZNK4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled14generation_ptrEv:
  636|   126M|  GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2026010718container_internal37HashSetIteratorGenerationInfoDisabledC2EPKh:
  660|   126M|  explicit HashSetIteratorGenerationInfoDisabled(const GenerationType*) {}
_ZNK4absl12lts_2026010718container_internal37HashSetIteratorGenerationInfoDisabled10generationEv:
  662|   194M|  GenerationType generation() const { return 0; }
_ZNK4absl12lts_2026010718container_internal37HashSetIteratorGenerationInfoDisabled14generation_ptrEv:
  664|   306M|  const GenerationType* generation_ptr() const { return nullptr; }
_ZNK4absl12lts_2026010718container_internal9HeapOrSoo7controlEv:
  880|   233M|  MaybeInitializedPtr<ctrl_t> control() const {
  881|   233M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.control);
  ------------------
  |  |  488|   233M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  882|   233M|  }
_ZNK4absl12lts_2026010718container_internal9HeapOrSoo10slot_arrayEv:
  886|   218M|  MaybeInitializedPtr<void> slot_array() const {
  887|   218M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.slot_array);
  ------------------
  |  |  488|   218M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  888|   218M|  }
_ZN4absl12lts_2026010718container_internal9HeapOrSoo12get_soo_dataEv:
  889|   113k|  void* get_soo_data() {
  890|   113k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(soo_data);
  ------------------
  |  |  488|   113k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  891|   113k|  }
_ZN4absl12lts_2026010718container_internal12CommonFieldsC2ENS1_9soo_tag_tE:
  915|  11.9k|      : capacity_(SooCapacity()), size_(no_seed_empty_tag_t{}) {}
_ZN4absl12lts_2026010718container_internal12CommonFieldsC2ENS1_13non_soo_tag_tE:
  919|  63.9k|      : capacity_(0), size_(no_seed_empty_tag_t{}) {}
_ZN4absl12lts_2026010718container_internal12CommonFields8soo_dataEv:
  946|   113k|  void* soo_data() { return heap_or_soo_.get_soo_data(); }
_ZNK4absl12lts_2026010718container_internal12CommonFields7controlEv:
  948|   233M|  ctrl_t* control() const {
  949|   233M|    ABSL_SWISSTABLE_ASSERT(capacity() > 0);
  ------------------
  |  |  248|   233M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  950|       |    // Assume that the control bytes don't alias `this`.
  951|   233M|    ctrl_t* ctrl = heap_or_soo_.control().get();
  952|   233M|    [[maybe_unused]] size_t num_control_bytes = NumControlBytes(capacity());
  953|   233M|    ABSL_ASSUME(reinterpret_cast<uintptr_t>(ctrl + num_control_bytes) <=
  ------------------
  |  |  270|   337M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (270:44): [True: 128M, False: 104M]
  |  |  |  Branch (270:44): [True: 104M, False: 0]
  |  |  ------------------
  ------------------
  954|   233M|                    reinterpret_cast<uintptr_t>(this) ||
  955|   233M|                reinterpret_cast<uintptr_t>(this + 1) <=
  956|   233M|                    reinterpret_cast<uintptr_t>(ctrl));
  957|   233M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(ctrl);
  ------------------
  |  |  488|   233M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  958|   233M|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields10slot_arrayEv:
  963|   218M|  void* slot_array() const { return heap_or_soo_.slot_array().get(); }
_ZNK4absl12lts_2026010718container_internal12CommonFields11slots_unionEv:
  964|  47.8k|  MaybeInitializedPtr<void> slots_union() const {
  965|  47.8k|    return heap_or_soo_.slot_array();
  966|  47.8k|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields4sizeEv:
  970|  7.28M|  size_t size() const { return size_.size(); }
_ZN4absl12lts_2026010718container_internal12CommonFields12set_full_sooEv:
  977|  11.8k|  void set_full_soo() {
  978|  11.8k|    AssertInSooMode();
  979|  11.8k|    size_ = HashtableSize(full_soo_tag_t{});
  980|  11.8k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields14decrement_sizeEv:
  989|  57.1k|  void decrement_size() {
  990|       |    ABSL_SWISSTABLE_ASSERT(!empty());
  ------------------
  |  |  248|  57.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  991|  57.1k|    size_.decrement_size();
  992|  57.1k|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields4seedEv:
  996|  79.8M|  PerTableSeed seed() const { return size_.seed(); }
_ZNK4absl12lts_2026010718container_internal12CommonFields8capacityEv:
 1012|   320M|  size_t capacity() const { return capacity_; }
_ZNK4absl12lts_2026010718container_internal12CommonFields8is_smallEv:
 1019|  75.3M|  bool is_small() const { return IsSmallCapacity(capacity_); }
_ZNK4absl12lts_2026010718container_internal12CommonFields9has_infozEv:
 1035|  24.0M|  bool has_infoz() const { return size_.has_infoz(); }
_ZN4absl12lts_2026010718container_internal12CommonFields5infozEv:
 1050|  23.9M|  HashtablezInfoHandle infoz() {
 1051|  23.9M|    return has_infoz() ? *infoz_ptr() : HashtablezInfoHandle();
  ------------------
  |  Branch (1051:12): [True: 0, False: 23.9M]
  ------------------
 1052|  23.9M|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields15AssertInSooModeEv:
 1119|  11.8k|  void AssertInSooMode() const {
 1120|  11.8k|    ABSL_SWISSTABLE_ASSERT(capacity() == SooCapacity());
  ------------------
  |  |  248|  11.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1121|       |    ABSL_SWISSTABLE_ASSERT(!has_infoz());
  ------------------
  |  |  248|  11.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1122|  11.8k|  }
_ZN4absl12lts_2026010718container_internal10SooControlEv:
  395|   135k|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|   135k|  return const_cast<ctrl_t*>(kSooControl);
  399|   135k|}
_ZN4absl12lts_2026010718container_internal11SooCapacityEv:
  419|  14.1k|constexpr size_t SooCapacity() { return 1; }
_ZN4absl12lts_2026010718container_internal2H1Em:
  529|  79.8M|inline size_t H1(size_t hash) { return hash; }
_ZN4absl12lts_2026010718container_internal2H2Em:
  534|  83.5M|inline h2_t H2(size_t hash) { return hash >> (sizeof(size_t) * 8 - 7); }
_ZN4absl12lts_2026010718container_internal15IsSmallCapacityEm:
  775|   308M|constexpr bool IsSmallCapacity(size_t capacity) { return capacity <= 1; }
_ZN4absl12lts_2026010718container_internal14NumClonedBytesEv:
  782|   241M|constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
_ZN4absl12lts_2026010718container_internal15NumControlBytesEm:
  785|   233M|constexpr size_t NumControlBytes(size_t capacity) {
  786|   233M|  return IsSmallCapacity(capacity) ? 0 : capacity + 1 + NumClonedBytes();
  ------------------
  |  Branch (786:10): [True: 121k, False: 233M]
  ------------------
  787|   233M|}
_ZN4absl12lts_2026010718container_internal13ControlOffsetEb:
  791|   495k|constexpr size_t ControlOffset(bool has_infoz) {
  792|   495k|  return (has_infoz ? sizeof(HashtablezInfoHandle) : 0) + sizeof(GrowthInfo);
  ------------------
  |  Branch (792:11): [True: 0, False: 495k]
  ------------------
  793|   495k|}
_ZN4absl12lts_2026010718container_internal16PreviousCapacityEm:
 1151|  71.0k|constexpr size_t PreviousCapacity(size_t n) {
 1152|       |  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(n));
  ------------------
  |  |  248|  71.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1153|  71.0k|  return n / 2;
 1154|  71.0k|}
_ZN4absl12lts_2026010718container_internal14SizeToCapacityEm:
 1196|  6.79k|constexpr size_t SizeToCapacity(size_t size) {
 1197|  6.79k|  if (size == 0) {
  ------------------
  |  Branch (1197:7): [True: 0, False: 6.79k]
  ------------------
 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.79k|  int leading_zeros = absl::countl_zero(size);
 1204|  6.79k|  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.79k|  size_t max_size_for_next_capacity = kLast3Bits >> leading_zeros;
 1210|       |  // Decrease shift if size is too big for the minimum capacity.
 1211|  6.79k|  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.79k|  return (~size_t{}) >> leading_zeros;
 1217|  6.79k|}
_ZN4absl12lts_2026010718container_internal12AssertIsFullEPKNS1_6ctrl_tEhPKhPKc:
 1243|  82.8M|                         const char* operation) {
 1244|  82.8M|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1244:7): [True: 82.8M, 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|   111M|                                       const GenerationType* generation_ptr) {
 1286|   111M|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1286:7): [True: 111M, 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|  55.9M|                                const GenerationType* generation_ptr_b) {
 1339|  55.9M|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1339:7): [True: 55.9M, 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|  75.1M|inline probe_seq<Group::kWidth> probe_h1(size_t capacity, size_t h1) {
 1399|  75.1M|  return probe_seq<Group::kWidth>(h1, capacity);
 1400|  75.1M|}
_ZN4absl12lts_2026010718container_internal5probeEmm:
 1401|  74.9M|inline probe_seq<Group::kWidth> probe(size_t capacity, size_t hash) {
 1402|  74.9M|  return probe_h1(capacity, H1(hash));
 1403|  74.9M|}
_ZN4absl12lts_2026010718container_internal5probeERKNS1_12CommonFieldsEm:
 1404|  74.9M|inline probe_seq<Group::kWidth> probe(const CommonFields& common, size_t hash) {
 1405|  74.9M|  return probe(common.capacity(), hash);
 1406|  74.9M|}
_ZNK4absl12lts_2026010718container_internal19MaybeInitializedPtrINS1_6ctrl_tEE3getEv:
  849|   233M|  T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
  ------------------
  |  |  488|   233M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
_ZNK4absl12lts_2026010718container_internal19MaybeInitializedPtrIvE3getEv:
  849|   218M|  T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
  ------------------
  |  |  488|   218M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEEC2Ev:
 2109|  1.81k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026010718container_internal12CommonFields13CreateDefaultILb1EEES2_v:
  939|  11.9k|  static CommonFields CreateDefault() {
  940|  11.9k|    return kSooEnabled ? CommonFields{soo_tag_t{}}
  ------------------
  |  Branch (940:12): [True: 11.9k, Folded]
  ------------------
  941|  11.9k|                       : CommonFields{non_soo_tag_t{}};
  942|  11.9k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEED2Ev:
 2294|  1.81k|  ~raw_hash_set() {
 2295|  1.81k|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|  1.81k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE15destructor_implEv:
 3019|  1.81k|  void destructor_impl() {
 3020|  1.81k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 1.81k]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|  1.81k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 0, False: 1.81k]
  ------------------
 3025|  1.81k|    if (is_small()) {
  ------------------
  |  Branch (3025:9): [True: 25, False: 1.79k]
  ------------------
 3026|     25|      if (!empty()) {
  ------------------
  |  Branch (3026:11): [True: 0, False: 25]
  ------------------
 3027|      0|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|      0|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3028|      0|      }
 3029|     25|      if constexpr (SooEnabled()) return;
 3030|  1.79k|    } else {
 3031|  1.79k|      destroy_slots();
 3032|  1.79k|    }
 3033|      0|    dealloc();
 3034|  1.81k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8capacityEv:
 2331|  7.20k|  size_t capacity() const {
 2332|  7.20k|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|  7.20k|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|  7.20k|        DefaultCapacity();
 2336|  7.20k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|  7.20k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|  7.20k|    return cap;
 2338|  7.20k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE6commonEv:
 3431|  45.2M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8is_smallEv:
 1874|  5.87M|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE5emptyEv:
 2326|  10.8k|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE4sizeEv:
 2327|  14.7k|  size_t size() const {
 2328|  14.7k|    AssertNotDebugCapacity();
 2329|  14.7k|    return common().size();
 2330|  14.7k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE22AssertNotDebugCapacityEv:
 3285|  11.9M|  void AssertNotDebugCapacity() const {
 3286|  11.9M|#ifdef NDEBUG
 3287|  11.9M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 11.9M, Folded]
  ------------------
 3288|  11.9M|      return;
 3289|  11.9M|    }
 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_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7destroyEPNS1_13map_slot_typeImS8_EE:
 2935|  56.8k|  inline void destroy(slot_type* slot) {
 2936|  56.8k|    common().RunWithReentrancyGuard([&] {
 2937|  56.8k|      allocator_type alloc(char_alloc_ref());
 2938|  56.8k|      PolicyTraits::destroy(&alloc, slot);
 2939|  56.8k|    });
 2940|  56.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE6commonEv:
 3430|  18.3M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7destroyEPNS1_13map_slot_typeImSA_EEEUlvE_EEvT_:
 1099|  56.8k|  void RunWithReentrancyGuard(F f) {
 1100|  56.8k|#ifdef NDEBUG
 1101|  56.8k|    f();
 1102|  56.8k|    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_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7destroyEPNS1_13map_slot_typeImS8_EEENKUlvE_clEv:
 2936|  56.8k|    common().RunWithReentrancyGuard([&] {
 2937|  56.8k|      allocator_type alloc(char_alloc_ref());
 2938|  56.8k|      PolicyTraits::destroy(&alloc, slot);
 2939|  56.8k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE14char_alloc_refEv:
 3479|   883k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE11single_slotEv:
 3450|  5.59k|  slot_type* single_slot() {
 3451|  5.59k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  5.59k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|  5.59k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [True: 5.59k, Folded]
  ------------------
 3453|  5.59k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8soo_slotEv:
 3441|  5.59k|  slot_type* soo_slot() {
 3442|  5.59k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|  5.59k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3443|  5.59k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(
  ------------------
  |  |  488|  5.59k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 3444|  5.59k|        static_cast<slot_type*>(common().soo_data()));
 3445|  5.59k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE13destroy_slotsEv:
 2992|  1.79k|  void destroy_slots() {
 2993|  1.79k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  1.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2994|  1.79k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (2994:9): [True: 1.79k, 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_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7deallocEv:
 3008|  1.79k|  void dealloc() {
 3009|  1.79k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|  1.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3010|       |    // Unpoison before returning the memory to the allocator.
 3011|  1.79k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3012|  1.79k|    infoz().Unregister();
 3013|  1.79k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3014|  1.79k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3015|  1.79k|                                      sizeof(slot_type), alignof(slot_type),
 3016|  1.79k|                                      common().has_infoz());
 3017|  1.79k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE10slot_arrayEv:
 3437|  16.2M|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  16.2M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|  16.2M|    return static_cast<slot_type*>(common().slot_array());
 3440|  16.2M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE5infozEv:
 3470|  1.79k|  HashtablezInfoHandle infoz() {
 3471|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  1.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3472|  1.79k|    return common().infoz();
 3473|  1.79k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7controlEv:
 3433|  16.8M|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  16.8M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|  16.8M|    return common().control();
 3436|  16.8M|  }
_ZN4absl12lts_2026010718container_internal12CommonFields13CreateDefaultILb0EEES2_v:
  939|  61.7k|  static CommonFields CreateDefault() {
  940|  61.7k|    return kSooEnabled ? CommonFields{soo_tag_t{}}
  ------------------
  |  Branch (940:12): [Folded, False: 61.7k]
  ------------------
  941|  61.7k|                       : CommonFields{non_soo_tag_t{}};
  942|  61.7k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE15destructor_implEv:
 3019|  13.7k|  void destructor_impl() {
 3020|  13.7k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 13.7k]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|  13.7k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 13.7k, 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_traitsIcEEEEiEEJEE8capacityEv:
 2331|  66.1k|  size_t capacity() const {
 2332|  66.1k|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|  66.1k|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|  66.1k|        DefaultCapacity();
 2336|  66.1k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|  66.1k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|  66.1k|    return cap;
 2338|  66.1k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6commonEv:
 3431|  66.1k|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22AssertNotDebugCapacityEv:
 3285|  52.3k|  void AssertNotDebugCapacity() const {
 3286|  52.3k|#ifdef NDEBUG
 3287|  52.3k|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 52.3k, Folded]
  ------------------
 3288|  52.3k|      return;
 3289|  52.3k|    }
 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_traitsIcEEEEiEEJEE6commonEv:
 3430|   104k|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEED2Ev:
 2294|  10.1k|  ~raw_hash_set() {
 2295|  10.1k|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|  10.1k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE15destructor_implEv:
 3019|  10.1k|  void destructor_impl() {
 3020|  10.1k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 10.1k]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|  10.1k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 0, False: 10.1k]
  ------------------
 3025|  10.1k|    if (is_small()) {
  ------------------
  |  Branch (3025:9): [True: 136, False: 9.99k]
  ------------------
 3026|    136|      if (!empty()) {
  ------------------
  |  Branch (3026:11): [True: 83, False: 53]
  ------------------
 3027|     83|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|     83|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3028|     83|      }
 3029|    136|      if constexpr (SooEnabled()) return;
 3030|  9.99k|    } else {
 3031|  9.99k|      destroy_slots();
 3032|  9.99k|    }
 3033|      0|    dealloc();
 3034|  10.1k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8capacityEv:
 2331|  30.1k|  size_t capacity() const {
 2332|  30.1k|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|  30.1k|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|  30.1k|        DefaultCapacity();
 2336|  30.1k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|  30.1k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|  30.1k|    return cap;
 2338|  30.1k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE6commonEv:
 3431|  89.0M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8is_smallEv:
 1874|  11.3M|  bool is_small() const { return common().is_small(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE7destroyEPNS1_13map_slot_typeIjlEE:
 2935|     83|  inline void destroy(slot_type* slot) {
 2936|     83|    common().RunWithReentrancyGuard([&] {
 2937|     83|      allocator_type alloc(char_alloc_ref());
 2938|     83|      PolicyTraits::destroy(&alloc, slot);
 2939|     83|    });
 2940|     83|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE6commonEv:
 3430|  34.6M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE7destroyEPNS1_13map_slot_typeIjlEEEUlvE_EEvT_:
 1099|     83|  void RunWithReentrancyGuard(F f) {
 1100|     83|#ifdef NDEBUG
 1101|     83|    f();
 1102|     83|    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_17FlatHashMapPolicyIjlEEJEE7destroyEPNS1_13map_slot_typeIjlEEENKUlvE_clEv:
 2936|     83|    common().RunWithReentrancyGuard([&] {
 2937|     83|      allocator_type alloc(char_alloc_ref());
 2938|     83|      PolicyTraits::destroy(&alloc, slot);
 2939|     83|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE14char_alloc_refEv:
 3479|   609k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE11single_slotEv:
 3450|  84.1k|  slot_type* single_slot() {
 3451|  84.1k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  84.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|  84.1k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [True: 84.1k, Folded]
  ------------------
 3453|  84.1k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8soo_slotEv:
 3441|  84.1k|  slot_type* soo_slot() {
 3442|  84.1k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|  84.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3443|  84.1k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(
  ------------------
  |  |  488|  84.1k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 3444|  84.1k|        static_cast<slot_type*>(common().soo_data()));
 3445|  84.1k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE13destroy_slotsEv:
 2992|  9.99k|  void destroy_slots() {
 2993|  9.99k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  9.99k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2994|  9.99k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (2994:9): [True: 9.99k, 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_17FlatHashMapPolicyIjlEEJEE7deallocEv:
 3008|  9.99k|  void dealloc() {
 3009|  9.99k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|  9.99k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3010|       |    // Unpoison before returning the memory to the allocator.
 3011|  9.99k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3012|  9.99k|    infoz().Unregister();
 3013|  9.99k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3014|  9.99k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3015|  9.99k|                                      sizeof(slot_type), alignof(slot_type),
 3016|  9.99k|                                      common().has_infoz());
 3017|  9.99k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE10slot_arrayEv:
 3437|  32.7M|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  32.7M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|  32.7M|    return static_cast<slot_type*>(common().slot_array());
 3440|  32.7M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE5infozEv:
 3470|  9.99k|  HashtablezInfoHandle infoz() {
 3471|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  9.99k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3472|  9.99k|    return common().infoz();
 3473|  9.99k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE7controlEv:
 3433|  33.3M|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  33.3M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|  33.3M|    return common().control();
 3436|  33.3M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEED2Ev:
 2294|  10.1k|  ~raw_hash_set() {
 2295|  10.1k|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|  10.1k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE15destructor_implEv:
 3019|  10.1k|  void destructor_impl() {
 3020|  10.1k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 10.1k]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|  10.1k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 30, False: 10.0k]
  ------------------
 3025|  10.0k|    if (is_small()) {
  ------------------
  |  Branch (3025:9): [True: 49, False: 10.0k]
  ------------------
 3026|     49|      if (!empty()) {
  ------------------
  |  Branch (3026:11): [True: 49, False: 0]
  ------------------
 3027|     49|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|     49|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3028|     49|      }
 3029|       |      if constexpr (SooEnabled()) return;
 3030|  10.0k|    } else {
 3031|  10.0k|      destroy_slots();
 3032|  10.0k|    }
 3033|  10.0k|    dealloc();
 3034|  10.0k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8capacityEv:
 2331|  30.2k|  size_t capacity() const {
 2332|  30.2k|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|  30.2k|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|  30.2k|        DefaultCapacity();
 2336|  30.2k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|  30.2k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|  30.2k|    return cap;
 2338|  30.2k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE6commonEv:
 3431|  73.9M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8is_smallEv:
 1874|  9.24M|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE5emptyEv:
 2326|  30.4k|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE4sizeEv:
 2327|  30.4k|  size_t size() const {
 2328|  30.4k|    AssertNotDebugCapacity();
 2329|  30.4k|    return common().size();
 2330|  30.4k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE22AssertNotDebugCapacityEv:
 3285|  9.26M|  void AssertNotDebugCapacity() const {
 3286|  9.26M|#ifdef NDEBUG
 3287|  9.26M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 9.26M, Folded]
  ------------------
 3288|  9.26M|      return;
 3289|  9.26M|    }
 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_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE7destroyEPNS1_13map_slot_typeIjS6_EE:
 2935|     49|  inline void destroy(slot_type* slot) {
 2936|     49|    common().RunWithReentrancyGuard([&] {
 2937|     49|      allocator_type alloc(char_alloc_ref());
 2938|     49|      PolicyTraits::destroy(&alloc, slot);
 2939|     49|    });
 2940|     49|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE6commonEv:
 3430|  28.4M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE7destroyEPNS1_13map_slot_typeIjS8_EEEUlvE_EEvT_:
 1099|     49|  void RunWithReentrancyGuard(F f) {
 1100|     49|#ifdef NDEBUG
 1101|     49|    f();
 1102|     49|    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_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE7destroyEPNS1_13map_slot_typeIjS6_EEENKUlvE_clEv:
 2936|     49|    common().RunWithReentrancyGuard([&] {
 2937|     49|      allocator_type alloc(char_alloc_ref());
 2938|     49|      PolicyTraits::destroy(&alloc, slot);
 2939|     49|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE14char_alloc_refEv:
 3479|   779k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE11single_slotEv:
 3450|  10.4k|  slot_type* single_slot() {
 3451|  10.4k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  10.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|  10.4k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [Folded, False: 10.4k]
  ------------------
 3453|  10.4k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE10slot_arrayEv:
 3437|  27.4M|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  27.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|  27.4M|    return static_cast<slot_type*>(common().slot_array());
 3440|  27.4M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE13destroy_slotsEv:
 2992|  10.0k|  void destroy_slots() {
 2993|  10.0k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  10.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2994|  10.0k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (2994:9): [True: 10.0k, 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_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE7deallocEv:
 3008|  10.0k|  void dealloc() {
 3009|  10.0k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|  10.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3010|       |    // Unpoison before returning the memory to the allocator.
 3011|  10.0k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3012|  10.0k|    infoz().Unregister();
 3013|  10.0k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3014|  10.0k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3015|  10.0k|                                      sizeof(slot_type), alignof(slot_type),
 3016|  10.0k|                                      common().has_infoz());
 3017|  10.0k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE5infozEv:
 3470|  10.0k|  HashtablezInfoHandle infoz() {
 3471|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  10.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3472|  10.0k|    return common().infoz();
 3473|  10.0k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE7controlEv:
 3433|  27.6M|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  27.6M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|  27.6M|    return common().control();
 3436|  27.6M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEED2Ev:
 2294|  21.2k|  ~raw_hash_set() {
 2295|  21.2k|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|  21.2k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE15destructor_implEv:
 3019|  21.2k|  void destructor_impl() {
 3020|  21.2k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 21.2k]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|  21.2k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 2.84k, False: 18.4k]
  ------------------
 3025|  18.4k|    if (is_small()) {
  ------------------
  |  Branch (3025:9): [True: 2.52k, False: 15.8k]
  ------------------
 3026|  2.52k|      if (!empty()) {
  ------------------
  |  Branch (3026:11): [True: 2.22k, False: 302]
  ------------------
 3027|  2.22k|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|  2.22k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3028|  2.22k|      }
 3029|       |      if constexpr (SooEnabled()) return;
 3030|  15.8k|    } else {
 3031|  15.8k|      destroy_slots();
 3032|  15.8k|    }
 3033|  18.4k|    dealloc();
 3034|  18.4k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8capacityEv:
 2331|  64.8k|  size_t capacity() const {
 2332|  64.8k|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|  64.8k|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|  64.8k|        DefaultCapacity();
 2336|  64.8k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|  64.8k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|  64.8k|    return cap;
 2338|  64.8k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE6commonEv:
 3431|   121M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8is_smallEv:
 1874|  14.8M|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE5emptyEv:
 2326|   111k|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE4sizeEv:
 2327|  6.85M|  size_t size() const {
 2328|  6.85M|    AssertNotDebugCapacity();
 2329|  6.85M|    return common().size();
 2330|  6.85M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE22AssertNotDebugCapacityEv:
 3285|  25.1M|  void AssertNotDebugCapacity() const {
 3286|  25.1M|#ifdef NDEBUG
 3287|  25.1M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 25.1M, Folded]
  ------------------
 3288|  25.1M|      return;
 3289|  25.1M|    }
 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__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7destroyEPNS1_13map_slot_typeISA_lEE:
 2935|  2.13M|  inline void destroy(slot_type* slot) {
 2936|  2.13M|    common().RunWithReentrancyGuard([&] {
 2937|  2.13M|      allocator_type alloc(char_alloc_ref());
 2938|  2.13M|      PolicyTraits::destroy(&alloc, slot);
 2939|  2.13M|    });
 2940|  2.13M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE6commonEv:
 3430|  51.7M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE7destroyEPNS1_13map_slot_typeISC_lEEEUlvE_EEvT_:
 1099|  2.13M|  void RunWithReentrancyGuard(F f) {
 1100|  2.13M|#ifdef NDEBUG
 1101|  2.13M|    f();
 1102|  2.13M|    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_9allocatorIcEEEElEEJEE7destroyEPNS1_13map_slot_typeISA_lEEENKUlvE_clEv:
 2936|  2.13M|    common().RunWithReentrancyGuard([&] {
 2937|  2.13M|      allocator_type alloc(char_alloc_ref());
 2938|  2.13M|      PolicyTraits::destroy(&alloc, slot);
 2939|  2.13M|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14char_alloc_refEv:
 3479|  7.32M|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE11single_slotEv:
 3450|   120k|  slot_type* single_slot() {
 3451|   120k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|   120k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|   120k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [Folded, False: 120k]
  ------------------
 3453|   120k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10slot_arrayEv:
 3437|  39.4M|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  39.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|  39.4M|    return static_cast<slot_type*>(common().slot_array());
 3440|  39.4M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE13destroy_slotsEv:
 2992|  21.7k|  void destroy_slots() {
 2993|  21.7k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  21.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2994|  21.7k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (2994:9): [Folded, False: 21.7k]
  ------------------
 2995|  21.7k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 2996|  21.7k|      this->destroy(static_cast<slot_type*>(slot));
 2997|  21.7k|    };
 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|  21.7k|    } else {
 3004|  21.7k|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3005|  21.7k|    }
 3006|  21.7k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE13destroy_slotsEvENKUlPKNS1_6ctrl_tEPvE_clESF_SG_:
 2995|  2.13M|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 2996|  2.13M|      this->destroy(static_cast<slot_type*>(slot));
 2997|  2.13M|    };
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7deallocEv:
 3008|  18.4k|  void dealloc() {
 3009|  18.4k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|  18.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3010|       |    // Unpoison before returning the memory to the allocator.
 3011|  18.4k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3012|  18.4k|    infoz().Unregister();
 3013|  18.4k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3014|  18.4k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3015|  18.4k|                                      sizeof(slot_type), alignof(slot_type),
 3016|  18.4k|                                      common().has_infoz());
 3017|  18.4k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE5infozEv:
 3470|  18.4k|  HashtablezInfoHandle infoz() {
 3471|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  18.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3472|  18.4k|    return common().infoz();
 3473|  18.4k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7controlEv:
 3433|  42.4M|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  42.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|  42.4M|    return common().control();
 3436|  42.4M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEEC2Ev:
 2109|  10.1k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE5emptyEv:
 2326|  86.6k|  bool empty() const { return !size(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEEC2Ev:
 2109|  10.1k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE15unchecked_derefENS8_8iteratorE:
 3394|  9.22M|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8iterator15unchecked_derefEv:
 2039|  9.55M|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE22find_or_prepare_insertIjEENS5_INS8_8iteratorEbEERKT_:
 3358|  9.22M|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|  9.22M|    AssertOnFind(key);
 3360|  9.22M|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 20.2k, False: 9.20M]
  ------------------
 3361|  9.20M|    return find_or_prepare_insert_large(key);
 3362|  9.22M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE12AssertOnFindIjEEvRKT_:
 3279|  9.22M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|  9.22M|    AssertHashEqConsistent(key);
 3281|  9.22M|    AssertNotDebugCapacity();
 3282|  9.22M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE22AssertHashEqConsistentIjEEvRKT_:
 3317|  9.22M|  void AssertHashEqConsistent(const K& key) {
 3318|  9.22M|#ifdef NDEBUG
 3319|  9.22M|    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): [True: 0, Folded]
  ------------------
 3328|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3328:9): [True: 0, Folded]
  ------------------
 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_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE28find_or_prepare_insert_smallIjEENS5_INS8_8iteratorEbEERKT_:
 3207|  20.2k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|  20.2k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  20.2k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|       |    if constexpr (SooEnabled()) {
 3210|       |      return find_or_prepare_insert_soo(key);
 3211|       |    }
 3212|  20.2k|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 10.1k, False: 10.0k]
  ------------------
 3213|  10.1k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3213:11): [True: 160, False: 10.0k]
  ------------------
 3214|    160|        common().infoz().RecordInsertHit();
 3215|    160|        return {single_iterator(), false};
 3216|    160|      }
 3217|  10.1k|    }
 3218|  20.1k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|  20.1k|                common(), GetPolicyFunctions(),
 3220|  20.1k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|  20.1k|            true};
 3222|  20.2k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8equal_toIjEEbRKT_PNS1_13map_slot_typeIjS6_EE:
 3056|  9.04M|                                             slot_type* slot) const {
 3057|  9.04M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|  9.04M|                               PolicyTraits::element(slot));
 3059|  9.04M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE6eq_refEv:
 3478|  9.04M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE15single_iteratorEv:
 3464|    209|  iterator single_iterator() {
 3465|    209|    return {SooControl(), single_slot(), common().generation_ptr()};
 3466|    209|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIjS6_EEPKh:
 1993|  9.22M|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|  9.22M|          ctrl_(ctrl),
 1995|  9.22M|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|  9.22M|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  9.22M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|  9.22M|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE15iterator_at_ptrENS5_IPNS1_6ctrl_tEPvEE:
 3390|  20.1k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3391|  20.1k|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3392|  20.1k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE7to_slotEPv:
 3073|  99.8k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|  99.8k|    return static_cast<slot_type*>(buf);
 3075|  99.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE18GetPolicyFunctionsEv:
 3558|   330k|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|   330k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|   330k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|   330k|                  "or use absl::node_hash_{map,set}.");
 3562|   330k|    static_assert(alignof(slot_type) <=
 3563|   330k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|   330k|    static_assert(sizeof(key_type) <=
 3565|   330k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|   330k|    static_assert(sizeof(value_type) <=
 3567|   330k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|   330k|    static constexpr size_t kBackingArrayAlignment =
 3569|   330k|        BackingArrayAlignment(alignof(slot_type));
 3570|   330k|    static constexpr PolicyFunctions value = {
 3571|   330k|        static_cast<uint32_t>(sizeof(key_type)),
 3572|   330k|        static_cast<uint32_t>(sizeof(value_type)),
 3573|   330k|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|   330k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|   330k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|   330k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|   330k|                                : &raw_hash_set::get_hash_ref_fn,
 3580|   330k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|   330k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [Folded, False: 330k]
  ------------------
 3582|   330k|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|   330k|            : &raw_hash_set::transfer_n_slots_fn,
 3584|   330k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|   330k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|   330k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|   330k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|   330k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|   330k|    return value;
 3590|   330k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE19transfer_n_slots_fnEPvS9_S9_m:
 3494|  28.7k|                                  size_t count) {
 3495|  28.7k|    auto* src_slot = to_slot(src);
 3496|  28.7k|    auto* dst_slot = to_slot(dst);
 3497|       |
 3498|  28.7k|    auto* h = static_cast<raw_hash_set*>(set);
 3499|   118k|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3499:12): [True: 89.7k, False: 28.7k]
  ------------------
 3500|  89.7k|      h->transfer(dst_slot, src_slot);
 3501|  89.7k|    }
 3502|  28.7k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8transferEPNS1_13map_slot_typeIjS6_EESB_:
 2941|   439k|  inline void transfer(slot_type* to, slot_type* from) {
 2942|   439k|    common().RunWithReentrancyGuard([&] {
 2943|   439k|      allocator_type alloc(char_alloc_ref());
 2944|   439k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   439k|    });
 2946|   439k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8transferEPNS1_13map_slot_typeIjS8_EESD_EUlvE_EEvT_:
 1099|   439k|  void RunWithReentrancyGuard(F f) {
 1100|   439k|#ifdef NDEBUG
 1101|   439k|    f();
 1102|   439k|    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_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8transferEPNS1_13map_slot_typeIjS6_EESB_ENKUlvE_clEv:
 2942|   439k|    common().RunWithReentrancyGuard([&] {
 2943|   439k|      allocator_type alloc(char_alloc_ref());
 2944|   439k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   439k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSE_PFvSE_hmmE:
 3511|  12.2k|                                    size_t source_offset, size_t h1)) {
 3512|  12.2k|    const size_t new_capacity = common.capacity();
 3513|  12.2k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3514|  12.2k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  270|  12.2k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3515|  12.2k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  270|  12.2k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3516|       |
 3517|  12.2k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3518|  12.2k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3519|  12.2k|    ctrl_t* new_ctrl = common.control();
 3520|  12.2k|    slot_type* new_slots = set->slot_array();
 3521|       |
 3522|  37.3k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3522:34): [True: 25.1k, False: 12.2k]
  ------------------
 3523|  25.1k|         group_index += Group::kWidth) {
 3524|  25.1k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3525|  25.1k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3526|  25.1k|                  Group::kWidth);
 3527|  25.1k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3528|  25.1k|                  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|   352k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3531:38): [True: 352k, False: 25.1k]
  ------------------
 3532|   352k|        size_t old_index = group_index + in_fixed_group_index;
 3533|   352k|        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|   352k|        size_t hash = set->hash_of(old_slot);
 3537|   352k|        size_t h1 = H1(hash);
 3538|   352k|        h2_t h2 = H2(hash);
 3539|   352k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3540|   352k|            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|   352k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  189|   352k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 2.59k, False: 349k]
  |  |  |  Branch (189:49): [Folded, False: 352k]
  |  |  |  Branch (189:58): [True: 2.59k, False: 349k]
  |  |  ------------------
  ------------------
 3544|  2.59k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3545|  2.59k|          continue;
 3546|  2.59k|        }
 3547|   349k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  248|   349k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3548|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  248|   349k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3549|   349k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3550|   349k|        auto* new_slot = new_slots + new_index;
 3551|   349k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3552|   349k|        set->transfer(new_slot, old_slot);
 3553|   349k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3554|   349k|      }
 3555|  25.1k|    }
 3556|  12.2k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE7hash_ofEPNS1_13map_slot_typeIjS6_EE:
 3065|   352k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3066|   352k|    return PolicyTraits::apply(
 3067|   352k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3068|   352k|        PolicyTraits::element(slot));
 3069|   352k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8hash_refEv:
 3476|  9.55M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal29TryFindNewIndexWithoutProbingIvEEmmmmPNS1_6ctrl_tEm:
 1425|  4.68M|                                            size_t new_capacity) {
 1426|  4.68M|  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|  4.68M|  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|  4.68M|  index_diff -= in_floating_group_index;
 1437|  4.68M|  if (ABSL_PREDICT_TRUE((index_diff & old_capacity) == 0)) {
  ------------------
  |  |  190|  4.68M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 4.52M, False: 158k]
  |  |  |  Branch (190:48): [Folded, False: 4.68M]
  |  |  |  Branch (190:57): [True: 4.52M, False: 158k]
  |  |  ------------------
  ------------------
 1438|  4.52M|    size_t new_index = (h1 + in_floating_group_index) & new_capacity;
 1439|  4.52M|    ABSL_ASSUME(new_index != kProbedElementIndexSentinel);
  ------------------
  |  |  270|  4.52M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1440|  4.52M|    return new_index;
 1441|  4.52M|  }
 1442|   158k|  ABSL_SWISSTABLE_ASSERT(((old_index - h1) & old_capacity) >= Group::kWidth);
  ------------------
  |  |  248|   158k|  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|   158k|  if (ABSL_PREDICT_FALSE((h1 & old_capacity) >= old_index)) {
  ------------------
  |  |  189|   158k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 28.0k, False: 130k]
  |  |  |  Branch (189:49): [Folded, False: 158k]
  |  |  |  Branch (189:58): [True: 28.0k, False: 130k]
  |  |  ------------------
  ------------------
 1450|  28.0k|    return kProbedElementIndexSentinel;
 1451|  28.0k|  }
 1452|   130k|  size_t offset = h1 & new_capacity;
 1453|   130k|  Group new_g(new_ctrl + offset);
 1454|   130k|  if (auto mask = new_g.MaskNonFull(); ABSL_PREDICT_TRUE(mask)) {
  ------------------
  |  |  190|   130k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 130k, False: 68]
  |  |  |  Branch (190:48): [Folded, False: 130k]
  |  |  |  Branch (190:57): [True: 130k, False: 68]
  |  |  ------------------
  ------------------
 1455|   130k|    size_t result = offset + mask.LowestBitSet();
 1456|   130k|    ABSL_ASSUME(result != kProbedElementIndexSentinel);
  ------------------
  |  |  270|   130k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1457|   130k|    return result;
 1458|   130k|  }
 1459|     68|  return kProbedElementIndexSentinel;
 1460|   130k|}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8hash_refEv:
 3475|  20.1k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE28find_or_prepare_insert_largeIjEENS5_INS8_8iteratorEbEERKT_:
 3225|  9.20M|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|  9.20M|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  9.20M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|  9.20M|    prefetch_heap_block();
 3228|  9.20M|    const size_t hash = hash_of(key);
 3229|  9.20M|    auto seq = probe(common(), hash);
 3230|  9.20M|    const h2_t h2 = H2(hash);
 3231|  9.20M|    const ctrl_t* ctrl = control();
 3232|  9.20M|    size_t index;
 3233|  9.20M|    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|  9.20M|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|  9.20M|      while (true) {
 3238|  9.20M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|  9.20M|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|  9.20M|#endif
 3241|  9.20M|        Group g{ctrl + seq.offset()};
 3242|  9.20M|        for (uint32_t i : g.Match(h2)) {
 3243|  9.20M|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|  9.20M|            index = seq.offset(i);
 3245|  9.20M|            inserted = false;
 3246|  9.20M|            common().infoz().RecordInsertHit();
 3247|  9.20M|            return;
 3248|  9.20M|          }
 3249|  9.20M|        }
 3250|  9.20M|        auto mask_empty = g.MaskEmpty();
 3251|  9.20M|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|  9.20M|          size_t target_group_offset = seq.offset();
 3253|  9.20M|          index = SwisstableGenerationsEnabled()
 3254|  9.20M|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|  9.20M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|  9.20M|                            FindInfo{target_group_offset, seq.index()},
 3257|  9.20M|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|  9.20M|                      : PrepareInsertLarge(
 3259|  9.20M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|  9.20M|                            FindInfo{target_group_offset, seq.index()});
 3261|  9.20M|          inserted = true;
 3262|  9.20M|          return;
 3263|  9.20M|        }
 3264|  9.20M|        seq.next();
 3265|  9.20M|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|  9.20M|      }
 3267|  9.20M|    }();
 3268|  9.20M|    return {iterator_at(index), inserted};
 3269|  9.20M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE19prefetch_heap_blockEv:
 3423|  9.20M|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  9.20M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|  9.20M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|  9.20M|    __builtin_prefetch(control(), 0, 1);
 3427|  9.20M|#endif
 3428|  9.20M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE7hash_ofIjEEmRKT_:
 3061|  9.20M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|  9.20M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|  9.20M|                                               common().seed().seed()}(key);
 3064|  9.20M|  }
_ZN4absl12lts_2026010718container_internal9probe_seqILm16EEC2Emm:
  327|  75.1M|  probe_seq(size_t hash, size_t mask) {
  328|       |    ABSL_SWISSTABLE_ASSERT(((mask + 1) & mask) == 0 && "not a mask");
  ------------------
  |  |  248|  75.1M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  329|  75.1M|    mask_ = mask;
  330|  75.1M|    offset_ = hash & mask_;
  331|  75.1M|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE28find_or_prepare_insert_largeIjEENS5_INS8_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|  9.20M|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|  9.22M|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 9.22M, Folded]
  ------------------
 3238|  9.22M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|  9.22M|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|  9.22M|#endif
 3241|  9.22M|        Group g{ctrl + seq.offset()};
 3242|  9.22M|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 9.03M, False: 325k]
  ------------------
 3243|  9.03M|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|  9.03M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 8.89M, False: 136k]
  |  |  |  Branch (190:48): [Folded, False: 9.03M]
  |  |  |  Branch (190:57): [True: 8.89M, False: 136k]
  |  |  ------------------
  ------------------
 3244|  8.89M|            index = seq.offset(i);
 3245|  8.89M|            inserted = false;
 3246|  8.89M|            common().infoz().RecordInsertHit();
 3247|  8.89M|            return;
 3248|  8.89M|          }
 3249|  9.03M|        }
 3250|   325k|        auto mask_empty = g.MaskEmpty();
 3251|   325k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|   325k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 310k, False: 14.7k]
  |  |  |  Branch (190:48): [Folded, False: 325k]
  |  |  |  Branch (190:57): [True: 310k, False: 14.7k]
  |  |  ------------------
  ------------------
 3252|   310k|          size_t target_group_offset = seq.offset();
 3253|   310k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 310k]
  ------------------
 3254|   310k|                      ? 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|   310k|                      : PrepareInsertLarge(
 3259|   310k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   310k|                            FindInfo{target_group_offset, seq.index()});
 3261|   310k|          inserted = true;
 3262|   310k|          return;
 3263|   310k|        }
 3264|  14.7k|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  14.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|  14.7k|      }
 3267|  9.20M|    }();
_ZNK4absl12lts_2026010718container_internal9probe_seqILm16EE6offsetEv:
  334|   155M|  size_t offset() const { return offset_; }
_ZNK4absl12lts_2026010718container_internal9probe_seqILm16EE6offsetEm:
  335|   134M|  size_t offset(size_t i) const { return (offset_ + i) & mask_; }
_ZNK4absl12lts_2026010718container_internal9probe_seqILm16EE5indexEv:
  343|  3.92M|  size_t index() const { return index_; }
_ZN4absl12lts_2026010718container_internal9probe_seqILm16EE4nextEv:
  337|   520k|  void next() {
  338|   520k|    index_ += Width;
  339|   520k|    offset_ += index_;
  340|   520k|    offset_ &= mask_;
  341|   520k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE11iterator_atEm:
 3383|  9.20M|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|  9.20M|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|  9.20M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKjEEENSD_IJEEEEEEvNS8_8iteratorEDpOT_:
 3373|   330k|  void emplace_at(iterator iter, Args&&... args) {
 3374|   330k|    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|   330k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|   330k|           "constructed value does not match the lookup key");
 3381|   330k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKjEEENSD_IJEEEEEEvPNS1_13map_slot_typeIjS6_EEDpOT_:
 2929|   330k|  inline void construct(slot_type* slot, Args&&... args) {
 2930|   330k|    common().RunWithReentrancyGuard([&] {
 2931|   330k|      allocator_type alloc(char_alloc_ref());
 2932|   330k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   330k|    });
 2934|   330k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKjEEENSF_IJEEEEEEvPNS1_13map_slot_typeIjS8_EEDpOT_EUlvE_EEvT_:
 1099|   330k|  void RunWithReentrancyGuard(F f) {
 1100|   330k|#ifdef NDEBUG
 1101|   330k|    f();
 1102|   330k|    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_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKjEEENSD_IJEEEEEEvPNS1_13map_slot_typeIjS6_EEDpOT_ENKUlvE_clEv:
 2930|   330k|    common().RunWithReentrancyGuard([&] {
 2931|   330k|      allocator_type alloc(char_alloc_ref());
 2932|   330k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   330k|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8iterator4slotEv:
 2042|   330k|    slot_type* slot() const { return slot_; }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE5beginEv:
 2315|  10.1k|  const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2316|  10.1k|    return const_cast<raw_hash_set*>(this)->begin();
 2317|  10.1k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE5beginEv:
 2301|  10.1k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2302|  10.1k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  189|  10.1k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 30, False: 10.0k]
  |  |  |  Branch (189:49): [Folded, False: 10.1k]
  |  |  |  Branch (189:58): [True: 30, False: 10.0k]
  |  |  ------------------
  ------------------
 2303|  10.0k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2303:9): [True: 49, False: 10.0k]
  ------------------
 2304|  10.0k|    iterator it = {control(), common().slots_union(),
 2305|  10.0k|                   common().generation_ptr()};
 2306|  10.0k|    it.skip_empty_or_deleted();
 2307|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  248|  10.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2308|  10.0k|    return it;
 2309|  10.0k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE3endEv:
 2310|  10.1k|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|  10.1k|    AssertNotDebugCapacity();
 2312|  10.1k|    return iterator(common().generation_ptr());
 2313|  10.1k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8iteratorC2EPKh:
 2014|  10.1k|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2005|  10.0k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2006|  10.0k|          ctrl_(ctrl),
 2007|  10.0k|          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|  10.0k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  10.0k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2011|  10.0k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8iterator21skip_empty_or_deletedEv:
 2022|   670k|    void skip_empty_or_deleted() {
 2023|  1.05M|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2023:14): [True: 385k, False: 670k]
  ------------------
 2024|   385k|        ++ctrl_;
 2025|   385k|        ++slot_;
 2026|   385k|      }
 2027|   670k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE14const_iteratorC2ENS8_8iteratorE:
 2069|  20.2k|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE3endEv:
 2318|  10.1k|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2319|  10.1k|    return const_cast<raw_hash_set*>(this)->end();
 2320|  10.1k|  }
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE14const_iteratorESB_:
 2083|   681k|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2084|   681k|      return !(a == b);
 2085|   681k|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE14const_iteratorESB_:
 2080|   681k|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2081|   681k|      return a.inner_ == b.inner_;
 2082|   681k|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8iteratorESB_:
 1979|   681k|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|   681k|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|   681k|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|   681k|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|   681k|                          a.generation_ptr(), b.generation_ptr());
 1984|   681k|      return a.ctrl_ == b.ctrl_;
 1985|   681k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE14const_iteratorppEv:
 2074|   660k|    const_iterator& operator++() {
 2075|   660k|      ++inner_;
 2076|   660k|      return *this;
 2077|   660k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8iteratorppEv:
 1964|   660k|    iterator& operator++() {
 1965|   660k|      assert_is_full("operator++");
 1966|   660k|      ++ctrl_;
 1967|   660k|      ++slot_;
 1968|   660k|      skip_empty_or_deleted();
 1969|   660k|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  189|   660k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 20.1k, False: 640k]
  |  |  |  Branch (189:49): [Folded, False: 660k]
  |  |  |  Branch (189:58): [True: 20.1k, False: 640k]
  |  |  ------------------
  ------------------
 1970|   660k|      return *this;
 1971|   660k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8iterator14assert_is_fullEPKc:
 2016|   991k|    void assert_is_full(const char* operation) const {
 2017|   991k|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|   991k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE14const_iteratordeEv:
 2071|   330k|    reference operator*() const { return *inner_; }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjNSt3__14pairIblEEEEJEE8iteratordeEv:
 1952|   330k|    reference operator*() const {
 1953|   330k|      assert_is_full("operator*()");
 1954|   330k|      return unchecked_deref();
 1955|   330k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE7emplaceIJRKjRKlETnNSt3__19enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSB_4pairINS5_8iteratorEbEEDpOSD_:
 2526|   298k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2527|   298k|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2528|   298k|                               std::forward<Args>(args)...);
 2529|   298k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE19EmplaceDecomposableclIjJRKNSt3__121piecewise_construct_tENS8_5tupleIJRKjEEENSC_IJRKlEEEEEENS8_4pairINS5_8iteratorEbEERKT_DpOT0_:
 2901|   298k|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 2902|   298k|      auto res = s.find_or_prepare_insert(key);
 2903|   298k|      if (res.second) {
  ------------------
  |  Branch (2903:11): [True: 298k, False: 0]
  ------------------
 2904|   298k|        s.emplace_at(res.first, std::forward<Args>(args)...);
 2905|   298k|      }
 2906|   298k|      return res;
 2907|   298k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE22find_or_prepare_insertIjEENSt3__14pairINS5_8iteratorEbEERKT_:
 3358|   298k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|   298k|    AssertOnFind(key);
 3360|   298k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 20.0k, False: 278k]
  ------------------
 3361|   278k|    return find_or_prepare_insert_large(key);
 3362|   298k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE12AssertOnFindIjEEvRKT_:
 3279|  11.3M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|  11.3M|    AssertHashEqConsistent(key);
 3281|  11.3M|    AssertNotDebugCapacity();
 3282|  11.3M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE22AssertHashEqConsistentIjEEvRKT_:
 3317|  11.3M|  void AssertHashEqConsistent(const K& key) {
 3318|  11.3M|#ifdef NDEBUG
 3319|  11.3M|    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): [True: 0, Folded]
  ------------------
 3328|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3328:9): [True: 0, Folded]
  ------------------
 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_17FlatHashMapPolicyIjlEEJEE22AssertNotDebugCapacityEv:
 3285|  23.0M|  void AssertNotDebugCapacity() const {
 3286|  23.0M|#ifdef NDEBUG
 3287|  23.0M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 23.0M, Folded]
  ------------------
 3288|  23.0M|      return;
 3289|  23.0M|    }
 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_17FlatHashMapPolicyIjlEEJEE28find_or_prepare_insert_smallIjEENSt3__14pairINS5_8iteratorEbEERKT_:
 3207|  20.0k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|  20.0k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  20.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|  20.0k|    if constexpr (SooEnabled()) {
 3210|  20.0k|      return find_or_prepare_insert_soo(key);
 3211|  20.0k|    }
 3212|  20.0k|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 0, False: 20.0k]
  ------------------
 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|  20.0k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|  20.0k|                common(), GetPolicyFunctions(),
 3220|  20.0k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|  20.0k|            true};
 3222|  20.0k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE26find_or_prepare_insert_sooIjEENSt3__14pairINS5_8iteratorEbEERKT_:
 3181|  20.0k|  std::pair<iterator, bool> find_or_prepare_insert_soo(const K& key) {
 3182|  20.0k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|  20.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3183|  20.0k|    bool force_sampling;
 3184|  20.0k|    if (empty()) {
  ------------------
  |  Branch (3184:9): [True: 10.0k, False: 9.99k]
  ------------------
 3185|  10.0k|      if (!should_sample_soo()) {
  ------------------
  |  Branch (3185:11): [True: 10.0k, False: 0]
  ------------------
 3186|  10.0k|        common().set_full_soo();
 3187|  10.0k|        return {single_iterator(), true};
 3188|  10.0k|      }
 3189|      0|      force_sampling = true;
 3190|  9.99k|    } else if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3190:16): [True: 0, False: 9.99k]
  ------------------
 3191|      0|      return {single_iterator(), false};
 3192|  9.99k|    } else {
 3193|  9.99k|      force_sampling = false;
 3194|  9.99k|    }
 3195|  9.99k|    ABSL_SWISSTABLE_ASSERT(capacity() == 1);
  ------------------
  |  |  248|  9.99k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3196|  9.99k|    constexpr bool kUseMemcpy =
 3197|  9.99k|        PolicyTraits::transfer_uses_memcpy() && SooEnabled();
  ------------------
  |  Branch (3197:9): [True: 0, Folded]
  |  Branch (3197:49): [True: 0, Folded]
  ------------------
 3198|  9.99k|    size_t index = GrowSooTableToNextCapacityAndPrepareInsert<
 3199|  9.99k|        kUseMemcpy ? OptimalMemcpySizeForSooSlotTransfer(sizeof(slot_type)) : 0,
 3200|  9.99k|        kUseMemcpy>(common(), GetPolicyFunctions(),
 3201|  9.99k|                    HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key},
 3202|  9.99k|                    force_sampling);
 3203|  9.99k|    return {iterator_at(index), true};
 3204|  20.0k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE17should_sample_sooEv:
 2980|  10.0k|  bool should_sample_soo() const {
 2981|  10.0k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|  10.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2982|  10.0k|    if (!ShouldSampleHashtablezInfoForAlloc<CharAlloc>()) return false;
  ------------------
  |  Branch (2982:9): [Folded, False: 10.0k]
  ------------------
 2983|  10.0k|    return ABSL_PREDICT_FALSE(ShouldSampleNextTable());
  ------------------
  |  |  189|  10.0k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:49): [Folded, False: 10.0k]
  |  |  |  Branch (189:58): [True: 0, False: 10.0k]
  |  |  ------------------
  ------------------
 2984|  10.0k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE15single_iteratorEv:
 3464|  40.4k|  iterator single_iterator() {
 3465|  40.4k|    return {SooControl(), single_slot(), common().generation_ptr()};
 3466|  40.4k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIjlEEPKh:
 1993|  10.7M|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|  10.7M|          ctrl_(ctrl),
 1995|  10.7M|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|  10.7M|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  10.7M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|  10.7M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8equal_toIjEEbRKT_PNS1_13map_slot_typeIjlEE:
 3056|  10.6M|                                             slot_type* slot) const {
 3057|  10.6M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|  10.6M|                               PolicyTraits::element(slot));
 3059|  10.6M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE6eq_refEv:
 3478|  10.6M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE18GetPolicyFunctionsEv:
 3558|   288k|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|   288k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|   288k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|   288k|                  "or use absl::node_hash_{map,set}.");
 3562|   288k|    static_assert(alignof(slot_type) <=
 3563|   288k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|   288k|    static_assert(sizeof(key_type) <=
 3565|   288k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|   288k|    static_assert(sizeof(value_type) <=
 3567|   288k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|   288k|    static constexpr size_t kBackingArrayAlignment =
 3569|   288k|        BackingArrayAlignment(alignof(slot_type));
 3570|   288k|    static constexpr PolicyFunctions value = {
 3571|   288k|        static_cast<uint32_t>(sizeof(key_type)),
 3572|   288k|        static_cast<uint32_t>(sizeof(value_type)),
 3573|   288k|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|   288k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|   288k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|   288k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|   288k|                                : &raw_hash_set::get_hash_ref_fn,
 3580|   288k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|   288k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [True: 0, Folded]
  ------------------
 3582|   288k|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|   288k|            : &raw_hash_set::transfer_n_slots_fn,
 3584|   288k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|   288k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|   288k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|   288k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|   288k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|   288k|    return value;
 3590|   288k|  }
_ZN4absl12lts_2026010718container_internal20TransferNRelocatableILm16EEEvPvS3_S3_m:
 1722|  24.2k|                                                  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|  24.2k|  memcpy(dst, src, SizeOfSlot * count);
 1726|  24.2k|}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSB_PFvSB_hmmE:
 3511|  11.2k|                                    size_t source_offset, size_t h1)) {
 3512|  11.2k|    const size_t new_capacity = common.capacity();
 3513|  11.2k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3514|  11.2k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  270|  11.2k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3515|  11.2k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  270|  11.2k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3516|       |
 3517|  11.2k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3518|  11.2k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3519|  11.2k|    ctrl_t* new_ctrl = common.control();
 3520|  11.2k|    slot_type* new_slots = set->slot_array();
 3521|       |
 3522|  32.8k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3522:34): [True: 21.6k, False: 11.2k]
  ------------------
 3523|  21.6k|         group_index += Group::kWidth) {
 3524|  21.6k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3525|  21.6k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3526|  21.6k|                  Group::kWidth);
 3527|  21.6k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3528|  21.6k|                  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|   302k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3531:38): [True: 302k, False: 21.6k]
  ------------------
 3532|   302k|        size_t old_index = group_index + in_fixed_group_index;
 3533|   302k|        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|   302k|        size_t hash = set->hash_of(old_slot);
 3537|   302k|        size_t h1 = H1(hash);
 3538|   302k|        h2_t h2 = H2(hash);
 3539|   302k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3540|   302k|            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|   302k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  189|   302k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 2.08k, False: 300k]
  |  |  |  Branch (189:49): [Folded, False: 302k]
  |  |  |  Branch (189:58): [True: 2.08k, False: 300k]
  |  |  ------------------
  ------------------
 3544|  2.08k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3545|  2.08k|          continue;
 3546|  2.08k|        }
 3547|   300k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  248|   300k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3548|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  248|   300k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3549|   300k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3550|   300k|        auto* new_slot = new_slots + new_index;
 3551|   300k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3552|   300k|        set->transfer(new_slot, old_slot);
 3553|   300k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3554|   300k|      }
 3555|  21.6k|    }
 3556|  11.2k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE7to_slotEPv:
 3073|  20.2k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|  20.2k|    return static_cast<slot_type*>(buf);
 3075|  20.2k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE7hash_ofEPNS1_13map_slot_typeIjlEE:
 3065|   302k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3066|   302k|    return PolicyTraits::apply(
 3067|   302k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3068|   302k|        PolicyTraits::element(slot));
 3069|   302k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8hash_refEv:
 3476|  11.5M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8transferEPNS1_13map_slot_typeIjlEES8_:
 2941|   300k|  inline void transfer(slot_type* to, slot_type* from) {
 2942|   300k|    common().RunWithReentrancyGuard([&] {
 2943|   300k|      allocator_type alloc(char_alloc_ref());
 2944|   300k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   300k|    });
 2946|   300k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8transferEPNS1_13map_slot_typeIjlEESA_EUlvE_EEvT_:
 1099|   300k|  void RunWithReentrancyGuard(F f) {
 1100|   300k|#ifdef NDEBUG
 1101|   300k|    f();
 1102|   300k|    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_17FlatHashMapPolicyIjlEEJEE8transferEPNS1_13map_slot_typeIjlEES8_ENKUlvE_clEv:
 2942|   300k|    common().RunWithReentrancyGuard([&] {
 2943|   300k|      allocator_type alloc(char_alloc_ref());
 2944|   300k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   300k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8hash_refEv:
 3475|  9.99k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE11iterator_atEm:
 3383|  10.7M|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|  10.7M|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|  10.7M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE28find_or_prepare_insert_largeIjEENSt3__14pairINS5_8iteratorEbEERKT_:
 3225|   278k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|   278k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   278k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|   278k|    prefetch_heap_block();
 3228|   278k|    const size_t hash = hash_of(key);
 3229|   278k|    auto seq = probe(common(), hash);
 3230|   278k|    const h2_t h2 = H2(hash);
 3231|   278k|    const ctrl_t* ctrl = control();
 3232|   278k|    size_t index;
 3233|   278k|    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|   278k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   278k|      while (true) {
 3238|   278k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   278k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   278k|#endif
 3241|   278k|        Group g{ctrl + seq.offset()};
 3242|   278k|        for (uint32_t i : g.Match(h2)) {
 3243|   278k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|   278k|            index = seq.offset(i);
 3245|   278k|            inserted = false;
 3246|   278k|            common().infoz().RecordInsertHit();
 3247|   278k|            return;
 3248|   278k|          }
 3249|   278k|        }
 3250|   278k|        auto mask_empty = g.MaskEmpty();
 3251|   278k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|   278k|          size_t target_group_offset = seq.offset();
 3253|   278k|          index = SwisstableGenerationsEnabled()
 3254|   278k|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|   278k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|   278k|                            FindInfo{target_group_offset, seq.index()},
 3257|   278k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|   278k|                      : PrepareInsertLarge(
 3259|   278k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   278k|                            FindInfo{target_group_offset, seq.index()});
 3261|   278k|          inserted = true;
 3262|   278k|          return;
 3263|   278k|        }
 3264|   278k|        seq.next();
 3265|   278k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|   278k|      }
 3267|   278k|    }();
 3268|   278k|    return {iterator_at(index), inserted};
 3269|   278k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE19prefetch_heap_blockEv:
 3423|  11.2M|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  11.2M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|  11.2M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|  11.2M|    __builtin_prefetch(control(), 0, 1);
 3427|  11.2M|#endif
 3428|  11.2M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE7hash_ofIjEEmRKT_:
 3061|  11.2M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|  11.2M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|  11.2M|                                               common().seed().seed()}(key);
 3064|  11.2M|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE28find_or_prepare_insert_largeIjEENSt3__14pairINS5_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|   278k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   285k|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 285k, Folded]
  ------------------
 3238|   285k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   285k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   285k|#endif
 3241|   285k|        Group g{ctrl + seq.offset()};
 3242|   285k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 12.1k, False: 285k]
  ------------------
 3243|  12.1k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|  12.1k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 12.1k]
  |  |  |  Branch (190:48): [Folded, False: 12.1k]
  |  |  |  Branch (190:57): [True: 0, False: 12.1k]
  |  |  ------------------
  ------------------
 3244|      0|            index = seq.offset(i);
 3245|      0|            inserted = false;
 3246|      0|            common().infoz().RecordInsertHit();
 3247|      0|            return;
 3248|      0|          }
 3249|  12.1k|        }
 3250|   285k|        auto mask_empty = g.MaskEmpty();
 3251|   285k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|   285k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 278k, False: 6.98k]
  |  |  |  Branch (190:48): [Folded, False: 285k]
  |  |  |  Branch (190:57): [True: 278k, False: 6.98k]
  |  |  ------------------
  ------------------
 3252|   278k|          size_t target_group_offset = seq.offset();
 3253|   278k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 278k]
  ------------------
 3254|   278k|                      ? 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|   278k|                      : PrepareInsertLarge(
 3259|   278k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   278k|                            FindInfo{target_group_offset, seq.index()});
 3261|   278k|          inserted = true;
 3262|   278k|          return;
 3263|   278k|        }
 3264|  6.98k|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  6.98k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|  6.98k|      }
 3267|   278k|    }();
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE10emplace_atIJRKNSt3__121piecewise_construct_tENS7_5tupleIJRKjEEENSB_IJRKlEEEEEEvNS5_8iteratorEDpOT_:
 3373|   298k|  void emplace_at(iterator iter, Args&&... args) {
 3374|   298k|    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|   298k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|   298k|           "constructed value does not match the lookup key");
 3381|   298k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE9constructIJRKNSt3__121piecewise_construct_tENS7_5tupleIJRKjEEENSB_IJRKlEEEEEEvPNS1_13map_slot_typeIjlEEDpOT_:
 2929|   298k|  inline void construct(slot_type* slot, Args&&... args) {
 2930|   298k|    common().RunWithReentrancyGuard([&] {
 2931|   298k|      allocator_type alloc(char_alloc_ref());
 2932|   298k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   298k|    });
 2934|   298k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE9constructIJRKNSt3__121piecewise_construct_tENS9_5tupleIJRKjEEENSD_IJRKlEEEEEEvPNS1_13map_slot_typeIjlEEDpOT_EUlvE_EEvT_:
 1099|   298k|  void RunWithReentrancyGuard(F f) {
 1100|   298k|#ifdef NDEBUG
 1101|   298k|    f();
 1102|   298k|    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_17FlatHashMapPolicyIjlEEJEE9constructIJRKNSt3__121piecewise_construct_tENS7_5tupleIJRKjEEENSB_IJRKlEEEEEEvPNS1_13map_slot_typeIjlEEDpOT_ENKUlvE_clEv:
 2930|   298k|    common().RunWithReentrancyGuard([&] {
 2931|   298k|      allocator_type alloc(char_alloc_ref());
 2932|   298k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   298k|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iterator4slotEv:
 2042|   298k|    slot_type* slot() const { return slot_; }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE4sizeEv:
 2327|   107k|  size_t size() const {
 2328|   107k|    AssertNotDebugCapacity();
 2329|   107k|    return common().size();
 2330|   107k|  }
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE14const_iteratorES8_:
 2083|  11.5M|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2084|  11.5M|      return !(a == b);
 2085|  11.5M|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE14const_iteratorES8_:
 2080|  11.5M|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2081|  11.5M|      return a.inner_ == b.inner_;
 2082|  11.5M|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iteratorES8_:
 1979|  11.5M|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|  11.5M|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|  11.5M|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|  11.5M|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|  11.5M|                          a.generation_ptr(), b.generation_ptr());
 1984|  11.5M|      return a.ctrl_ == b.ctrl_;
 1985|  11.5M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE4findIjEENS5_14const_iteratorERKj:
 2803|  11.0M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2804|  11.0M|    return const_cast<raw_hash_set*>(this)->find(key);
 2805|  11.0M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE4findIjEENS5_8iteratorERKj:
 2788|  11.0M|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2789|  11.0M|    AssertOnFind(key);
 2790|  11.0M|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (2790:9): [True: 33.6k, False: 10.9M]
  ------------------
 2791|  10.9M|    prefetch_heap_block();
 2792|  10.9M|    return find_large(key, hash_of(key));
 2793|  11.0M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE10find_smallIjEENS5_8iteratorERKj:
 2951|  33.6k|  iterator find_small(const key_arg<K>& key) {
 2952|  33.6k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  33.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2953|  33.6k|    return empty() || !equal_to(key, single_slot()) ? end() : single_iterator();
  ------------------
  |  Branch (2953:12): [True: 30, False: 33.5k]
  |  Branch (2953:23): [True: 3.27k, False: 30.3k]
  ------------------
 2954|  33.6k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE3endEv:
 2310|  11.5M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|  11.5M|    AssertNotDebugCapacity();
 2312|  11.5M|    return iterator(common().generation_ptr());
 2313|  11.5M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iteratorC2EPKh:
 2014|  11.5M|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE10find_largeIjEENS5_8iteratorERKjm:
 2957|  10.9M|  iterator find_large(const key_arg<K>& key, size_t hash) {
 2958|  10.9M|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  10.9M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2959|  10.9M|    auto seq = probe(common(), hash);
 2960|  10.9M|    const h2_t h2 = H2(hash);
 2961|  10.9M|    const ctrl_t* ctrl = control();
 2962|  11.0M|    while (true) {
  ------------------
  |  Branch (2962:12): [True: 11.0M, Folded]
  ------------------
 2963|  11.0M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 2964|  11.0M|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 2965|  11.0M|#endif
 2966|  11.0M|      Group g{ctrl + seq.offset()};
 2967|  11.0M|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (2967:23): [True: 10.6M, False: 558k]
  ------------------
 2968|  10.6M|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  190|  10.6M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 10.4M, False: 178k]
  |  |  |  Branch (190:48): [Folded, False: 10.6M]
  |  |  |  Branch (190:57): [True: 10.4M, False: 178k]
  |  |  ------------------
  ------------------
 2969|  10.4M|          return iterator_at(seq.offset(i));
 2970|  10.6M|      }
 2971|   558k|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  190|   558k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 531k, False: 27.6k]
  |  |  |  Branch (190:48): [Folded, False: 558k]
  |  |  |  Branch (190:57): [True: 531k, False: 27.6k]
  |  |  ------------------
  ------------------
 2972|  27.6k|      seq.next();
 2973|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  27.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2974|  27.6k|    }
 2975|  10.9M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE14const_iteratorC2ENS5_8iteratorE:
 2069|  22.0M|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE3endEv:
 2318|  11.0M|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2319|  11.0M|    return const_cast<raw_hash_set*>(this)->end();
 2320|  11.0M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEEC2Ev:
 2109|  21.2k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE15unchecked_derefENSC_8iteratorE:
 3394|  13.0M|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iterator15unchecked_derefEv:
 2039|  15.1M|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE22find_or_prepare_insertINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3358|   275k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|   275k|    AssertOnFind(key);
 3360|   275k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 13.5k, False: 262k]
  ------------------
 3361|   262k|    return find_or_prepare_insert_large(key);
 3362|   275k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE12AssertOnFindINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3279|   275k|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|   275k|    AssertHashEqConsistent(key);
 3281|   275k|    AssertNotDebugCapacity();
 3282|   275k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE22AssertHashEqConsistentINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3317|   275k|  void AssertHashEqConsistent(const K& key) {
 3318|   275k|#ifdef NDEBUG
 3319|   275k|    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__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_smallINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3207|  13.5k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|  13.5k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  13.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|       |    if constexpr (SooEnabled()) {
 3210|       |      return find_or_prepare_insert_soo(key);
 3211|       |    }
 3212|  13.5k|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 5.86k, False: 7.64k]
  ------------------
 3213|  5.86k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3213:11): [True: 400, False: 5.46k]
  ------------------
 3214|    400|        common().infoz().RecordInsertHit();
 3215|    400|        return {single_iterator(), false};
 3216|    400|      }
 3217|  5.86k|    }
 3218|  13.1k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|  13.1k|                common(), GetPolicyFunctions(),
 3220|  13.1k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|  13.1k|            true};
 3222|  13.5k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8equal_toINS4_17basic_string_viewIcS7_EEEEbRKT_PNS1_13map_slot_typeISA_lEE:
 3056|   107k|                                             slot_type* slot) const {
 3057|   107k|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|   107k|                               PolicyTraits::element(slot));
 3059|   107k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE6eq_refEv:
 3478|  11.4M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE15single_iteratorEv:
 3464|  50.9k|  iterator single_iterator() {
 3465|  50.9k|    return {SooControl(), single_slot(), common().generation_ptr()};
 3466|  50.9k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeISA_lEEPKh:
 1993|  13.0M|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|  13.0M|          ctrl_(ctrl),
 1995|  13.0M|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|  13.0M|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  13.0M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|  13.0M|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3390|  38.7k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3391|  38.7k|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3392|  38.7k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7to_slotEPv:
 3073|   209k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|   209k|    return static_cast<slot_type*>(buf);
 3075|   209k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE18GetPolicyFunctionsEv:
 3558|  2.14M|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|  2.14M|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|  2.14M|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|  2.14M|                  "or use absl::node_hash_{map,set}.");
 3562|  2.14M|    static_assert(alignof(slot_type) <=
 3563|  2.14M|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|  2.14M|    static_assert(sizeof(key_type) <=
 3565|  2.14M|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|  2.14M|    static_assert(sizeof(value_type) <=
 3567|  2.14M|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|  2.14M|    static constexpr size_t kBackingArrayAlignment =
 3569|  2.14M|        BackingArrayAlignment(alignof(slot_type));
 3570|  2.14M|    static constexpr PolicyFunctions value = {
 3571|  2.14M|        static_cast<uint32_t>(sizeof(key_type)),
 3572|  2.14M|        static_cast<uint32_t>(sizeof(value_type)),
 3573|  2.14M|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|  2.14M|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|  2.14M|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|  2.14M|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|  2.14M|                                : &raw_hash_set::get_hash_ref_fn,
 3580|  2.14M|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|  2.14M|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [Folded, False: 2.14M]
  ------------------
 3582|  2.14M|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|  2.14M|            : &raw_hash_set::transfer_n_slots_fn,
 3584|  2.14M|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|  2.14M|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|  2.14M|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|  2.14M|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|  2.14M|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|  2.14M|    return value;
 3590|  2.14M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE19transfer_n_slots_fnEPvSD_SD_m:
 3494|  62.3k|                                  size_t count) {
 3495|  62.3k|    auto* src_slot = to_slot(src);
 3496|  62.3k|    auto* dst_slot = to_slot(dst);
 3497|       |
 3498|  62.3k|    auto* h = static_cast<raw_hash_set*>(set);
 3499|   229k|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3499:12): [True: 167k, False: 62.3k]
  ------------------
 3500|   167k|      h->transfer(dst_slot, src_slot);
 3501|   167k|    }
 3502|  62.3k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8transferEPNS1_13map_slot_typeISA_lEESF_:
 2941|  3.02M|  inline void transfer(slot_type* to, slot_type* from) {
 2942|  3.02M|    common().RunWithReentrancyGuard([&] {
 2943|  3.02M|      allocator_type alloc(char_alloc_ref());
 2944|  3.02M|      PolicyTraits::transfer(&alloc, to, from);
 2945|  3.02M|    });
 2946|  3.02M|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE8transferEPNS1_13map_slot_typeISC_lEESH_EUlvE_EEvT_:
 1099|  3.02M|  void RunWithReentrancyGuard(F f) {
 1100|  3.02M|#ifdef NDEBUG
 1101|  3.02M|    f();
 1102|  3.02M|    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_9allocatorIcEEEElEEJEE8transferEPNS1_13map_slot_typeISA_lEESF_ENKUlvE_clEv:
 2942|  3.02M|    common().RunWithReentrancyGuard([&] {
 2943|  3.02M|      allocator_type alloc(char_alloc_ref());
 2944|  3.02M|      PolicyTraits::transfer(&alloc, to, from);
 2945|  3.02M|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3511|  28.3k|                                    size_t source_offset, size_t h1)) {
 3512|  28.3k|    const size_t new_capacity = common.capacity();
 3513|  28.3k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3514|  28.3k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  270|  28.3k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3515|  28.3k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  270|  28.3k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3516|       |
 3517|  28.3k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3518|  28.3k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3519|  28.3k|    ctrl_t* new_ctrl = common.control();
 3520|  28.3k|    slot_type* new_slots = set->slot_array();
 3521|       |
 3522|   233k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3522:34): [True: 205k, False: 28.3k]
  ------------------
 3523|   205k|         group_index += Group::kWidth) {
 3524|   205k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3525|   205k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3526|   205k|                  Group::kWidth);
 3527|   205k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3528|   205k|                  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|  2.87M|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3531:38): [True: 2.87M, False: 205k]
  ------------------
 3532|  2.87M|        size_t old_index = group_index + in_fixed_group_index;
 3533|  2.87M|        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|  2.87M|        size_t hash = set->hash_of(old_slot);
 3537|  2.87M|        size_t h1 = H1(hash);
 3538|  2.87M|        h2_t h2 = H2(hash);
 3539|  2.87M|        size_t new_index = TryFindNewIndexWithoutProbing(
 3540|  2.87M|            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|  2.87M|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  189|  2.87M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 16.3k, False: 2.86M]
  |  |  |  Branch (189:49): [Folded, False: 2.87M]
  |  |  |  Branch (189:58): [True: 16.3k, False: 2.86M]
  |  |  ------------------
  ------------------
 3544|  16.3k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3545|  16.3k|          continue;
 3546|  16.3k|        }
 3547|  2.86M|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  248|  2.86M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3548|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  248|  2.86M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3549|  2.86M|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3550|  2.86M|        auto* new_slot = new_slots + new_index;
 3551|  2.86M|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3552|  2.86M|        set->transfer(new_slot, old_slot);
 3553|  2.86M|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3554|  2.86M|      }
 3555|   205k|    }
 3556|  28.3k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7hash_ofEPNS1_13map_slot_typeISA_lEE:
 3065|  2.87M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3066|  2.87M|    return PolicyTraits::apply(
 3067|  2.87M|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3068|  2.87M|        PolicyTraits::element(slot));
 3069|  2.87M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8hash_refEv:
 3476|  17.5M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8hash_refEv:
 3475|  38.7k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_largeINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3225|   262k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|   262k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   262k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|   262k|    prefetch_heap_block();
 3228|   262k|    const size_t hash = hash_of(key);
 3229|   262k|    auto seq = probe(common(), hash);
 3230|   262k|    const h2_t h2 = H2(hash);
 3231|   262k|    const ctrl_t* ctrl = control();
 3232|   262k|    size_t index;
 3233|   262k|    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|   262k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   262k|      while (true) {
 3238|   262k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   262k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   262k|#endif
 3241|   262k|        Group g{ctrl + seq.offset()};
 3242|   262k|        for (uint32_t i : g.Match(h2)) {
 3243|   262k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|   262k|            index = seq.offset(i);
 3245|   262k|            inserted = false;
 3246|   262k|            common().infoz().RecordInsertHit();
 3247|   262k|            return;
 3248|   262k|          }
 3249|   262k|        }
 3250|   262k|        auto mask_empty = g.MaskEmpty();
 3251|   262k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|   262k|          size_t target_group_offset = seq.offset();
 3253|   262k|          index = SwisstableGenerationsEnabled()
 3254|   262k|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|   262k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|   262k|                            FindInfo{target_group_offset, seq.index()},
 3257|   262k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|   262k|                      : PrepareInsertLarge(
 3259|   262k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   262k|                            FindInfo{target_group_offset, seq.index()});
 3261|   262k|          inserted = true;
 3262|   262k|          return;
 3263|   262k|        }
 3264|   262k|        seq.next();
 3265|   262k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|   262k|      }
 3267|   262k|    }();
 3268|   262k|    return {iterator_at(index), inserted};
 3269|   262k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE19prefetch_heap_blockEv:
 3423|  14.7M|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  14.7M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|  14.7M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|  14.7M|    __builtin_prefetch(control(), 0, 1);
 3427|  14.7M|#endif
 3428|  14.7M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7hash_ofINS4_17basic_string_viewIcS7_EEEEmRKT_:
 3061|   262k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|   262k|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|   262k|                                               common().seed().seed()}(key);
 3064|   262k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_largeINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|   262k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   274k|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 274k, Folded]
  ------------------
 3238|   274k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   274k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   274k|#endif
 3241|   274k|        Group g{ctrl + seq.offset()};
 3242|   274k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 101k, False: 188k]
  ------------------
 3243|   101k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|   101k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 85.6k, False: 16.1k]
  |  |  |  Branch (190:48): [Folded, False: 101k]
  |  |  |  Branch (190:57): [True: 85.6k, False: 16.1k]
  |  |  ------------------
  ------------------
 3244|  85.6k|            index = seq.offset(i);
 3245|  85.6k|            inserted = false;
 3246|  85.6k|            common().infoz().RecordInsertHit();
 3247|  85.6k|            return;
 3248|  85.6k|          }
 3249|   101k|        }
 3250|   188k|        auto mask_empty = g.MaskEmpty();
 3251|   188k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|   188k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 176k, False: 12.1k]
  |  |  |  Branch (190:48): [Folded, False: 188k]
  |  |  |  Branch (190:57): [True: 176k, False: 12.1k]
  |  |  ------------------
  ------------------
 3252|   176k|          size_t target_group_offset = seq.offset();
 3253|   176k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 176k]
  ------------------
 3254|   176k|                      ? 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|   176k|                      : PrepareInsertLarge(
 3259|   176k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   176k|                            FindInfo{target_group_offset, seq.index()});
 3261|   176k|          inserted = true;
 3262|   176k|          return;
 3263|   176k|        }
 3264|  12.1k|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  12.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|  12.1k|      }
 3267|   262k|    }();
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE11iterator_atEm:
 3383|  12.9M|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|  12.9M|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|  12.9M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3373|   189k|  void emplace_at(iterator iter, Args&&... args) {
 3374|   189k|    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|   189k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|   189k|           "constructed value does not match the lookup key");
 3381|   189k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_:
 2929|   189k|  inline void construct(slot_type* slot, Args&&... args) {
 2930|   189k|    common().RunWithReentrancyGuard([&] {
 2931|   189k|      allocator_type alloc(char_alloc_ref());
 2932|   189k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   189k|    });
 2934|   189k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKNS6_17basic_string_viewIcS9_EEEEENSJ_IJEEEEEEvPNS1_13map_slot_typeISC_lEEDpOT_EUlvE_EEvT_:
 1099|   189k|  void RunWithReentrancyGuard(F f) {
 1100|   189k|#ifdef NDEBUG
 1101|   189k|    f();
 1102|   189k|    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_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_ENKUlvE_clEv:
 2930|   189k|    common().RunWithReentrancyGuard([&] {
 2931|   189k|      allocator_type alloc(char_alloc_ref());
 2932|   189k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   189k|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iterator4slotEv:
 2042|  2.13M|    slot_type* slot() const { return slot_; }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE5beginEv:
 2315|  14.4k|  const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2316|  14.4k|    return const_cast<raw_hash_set*>(this)->begin();
 2317|  14.4k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE5beginEv:
 2301|  21.2k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2302|  21.2k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  189|  21.2k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 613, False: 20.6k]
  |  |  |  Branch (189:49): [Folded, False: 21.2k]
  |  |  |  Branch (189:58): [True: 613, False: 20.6k]
  |  |  ------------------
  ------------------
 2303|  20.6k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2303:9): [True: 2.52k, False: 18.1k]
  ------------------
 2304|  18.1k|    iterator it = {control(), common().slots_union(),
 2305|  18.1k|                   common().generation_ptr()};
 2306|  18.1k|    it.skip_empty_or_deleted();
 2307|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  248|  18.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2308|  18.1k|    return it;
 2309|  20.6k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE3endEv:
 2310|  3.54M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|  3.54M|    AssertNotDebugCapacity();
 2312|  3.54M|    return iterator(common().generation_ptr());
 2313|  3.54M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorC2EPKh:
 2014|  3.54M|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2005|  18.1k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2006|  18.1k|          ctrl_(ctrl),
 2007|  18.1k|          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|  18.1k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  18.1k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2011|  18.1k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iterator21skip_empty_or_deletedEv:
 2022|  2.53M|    void skip_empty_or_deleted() {
 2023|  4.12M|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2023:14): [True: 1.59M, False: 2.53M]
  ------------------
 2024|  1.59M|        ++ctrl_;
 2025|  1.59M|        ++slot_;
 2026|  1.59M|      }
 2027|  2.53M|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14const_iteratorC2ENSC_8iteratorE:
 2069|  3.55M|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE3endEv:
 2318|  1.77M|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2319|  1.77M|    return const_cast<raw_hash_set*>(this)->end();
 2320|  1.77M|  }
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14const_iteratorESF_:
 2083|  2.54M|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2084|  2.54M|      return !(a == b);
 2085|  2.54M|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14const_iteratorESF_:
 2080|  2.54M|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2081|  2.54M|      return a.inner_ == b.inner_;
 2082|  2.54M|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorESF_:
 1979|  4.31M|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|  4.31M|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|  4.31M|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|  4.31M|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|  4.31M|                          a.generation_ptr(), b.generation_ptr());
 1984|  4.31M|      return a.ctrl_ == b.ctrl_;
 1985|  4.31M|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14const_iteratorppEv:
 2074|   754k|    const_iterator& operator++() {
 2075|   754k|      ++inner_;
 2076|   754k|      return *this;
 2077|   754k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorppEv:
 1964|  2.51M|    iterator& operator++() {
 1965|  2.51M|      assert_is_full("operator++");
 1966|  2.51M|      ++ctrl_;
 1967|  2.51M|      ++slot_;
 1968|  2.51M|      skip_empty_or_deleted();
 1969|  2.51M|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  189|  2.51M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 35.0k, False: 2.47M]
  |  |  |  Branch (189:49): [Folded, False: 2.51M]
  |  |  |  Branch (189:58): [True: 35.0k, False: 2.47M]
  |  |  ------------------
  ------------------
 1970|  2.51M|      return *this;
 1971|  2.51M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iterator14assert_is_fullEPKc:
 2016|  4.65M|    void assert_is_full(const char* operation) const {
 2017|  4.65M|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|  4.65M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14const_iteratordeEv:
 2071|   377k|    reference operator*() const { return *inner_; }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratordeEv:
 1952|  2.13M|    reference operator*() const {
 1953|  2.13M|      assert_is_full("operator*()");
 1954|  2.13M|      return unchecked_deref();
 1955|  2.13M|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10SooEnabledEv:
 1856|  5.89k|  constexpr static bool SooEnabled() {
 1857|  5.89k|    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|  5.89k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEEC2Ev:
 2109|  13.7k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEED2Ev:
 2294|  13.7k|  ~raw_hash_set() {
 2295|  13.7k|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|  13.7k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEEC2INS4_11__wrap_iterIPKNS4_4pairISA_fEEEEEET_SK_mRKNS1_10StringHashERKNS1_8StringEqERKNS8_INSF_IKSA_fEEEE:
 2137|  6.79k|      : raw_hash_set(SelectBucketCountForIterRange(first, last, bucket_count),
 2138|  6.79k|                     hash, eq, alloc) {
 2139|  6.79k|    insert(first, last);
 2140|  6.79k|  }
_ZN4absl12lts_2026010718container_internal29SelectBucketCountForIterRangeINSt3__111__wrap_iterIPKNS3_4pairINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEEEEEEmT_SG_m:
 1221|  6.79k|                                     size_t bucket_count) {
 1222|  6.79k|  if (bucket_count != 0) {
  ------------------
  |  Branch (1222:7): [True: 0, False: 6.79k]
  ------------------
 1223|      0|    return bucket_count;
 1224|      0|  }
 1225|  6.79k|  if (base_internal::IsAtLeastIterator<std::random_access_iterator_tag,
  ------------------
  |  Branch (1225:7): [True: 6.79k, Folded]
  ------------------
 1226|  6.79k|                                       InputIter>()) {
 1227|  6.79k|    return SizeToCapacity(static_cast<size_t>(std::distance(first, last)));
 1228|  6.79k|  }
 1229|      0|  return 0;
 1230|  6.79k|}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEEC2EmRKNS1_10StringHashERKNS1_8StringEqERKNS8_INS4_4pairIKSA_fEEEE:
 2115|  6.79k|      : settings_(CommonFields::CreateDefault<SooEnabled()>(), hash, eq,
 2116|  6.79k|                  alloc) {
 2117|  6.79k|    if (bucket_count > DefaultCapacity()) {
  ------------------
  |  Branch (2117:9): [True: 6.79k, False: 0]
  ------------------
 2118|  6.79k|      ReserveEmptyNonAllocatedTableToFitBucketCount(
 2119|  6.79k|          common(), GetPolicyFunctions(), bucket_count);
 2120|  6.79k|    }
 2121|  6.79k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE15DefaultCapacityEv:
 1862|  6.79k|  constexpr static size_t DefaultCapacity() {
 1863|  6.79k|    return SooEnabled() ? SooCapacity() : 0;
  ------------------
  |  Branch (1863:12): [Folded, False: 6.79k]
  ------------------
 1864|  6.79k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE6commonEv:
 3430|  4.38M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE18GetPolicyFunctionsEv:
 3558|   512k|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|   512k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|   512k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|   512k|                  "or use absl::node_hash_{map,set}.");
 3562|   512k|    static_assert(alignof(slot_type) <=
 3563|   512k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|   512k|    static_assert(sizeof(key_type) <=
 3565|   512k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|   512k|    static_assert(sizeof(value_type) <=
 3567|   512k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|   512k|    static constexpr size_t kBackingArrayAlignment =
 3569|   512k|        BackingArrayAlignment(alignof(slot_type));
 3570|   512k|    static constexpr PolicyFunctions value = {
 3571|   512k|        static_cast<uint32_t>(sizeof(key_type)),
 3572|   512k|        static_cast<uint32_t>(sizeof(value_type)),
 3573|   512k|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|   512k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|   512k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|   512k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|   512k|                                : &raw_hash_set::get_hash_ref_fn,
 3580|   512k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|   512k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [Folded, False: 512k]
  ------------------
 3582|   512k|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|   512k|            : &raw_hash_set::transfer_n_slots_fn,
 3584|   512k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|   512k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|   512k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|   512k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|   512k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|   512k|    return value;
 3590|   512k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE19transfer_n_slots_fnEPvSD_SD_m:
 3494|  20.8k|                                  size_t count) {
 3495|  20.8k|    auto* src_slot = to_slot(src);
 3496|  20.8k|    auto* dst_slot = to_slot(dst);
 3497|       |
 3498|  20.8k|    auto* h = static_cast<raw_hash_set*>(set);
 3499|  85.8k|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3499:12): [True: 64.9k, False: 20.8k]
  ------------------
 3500|  64.9k|      h->transfer(dst_slot, src_slot);
 3501|  64.9k|    }
 3502|  20.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7to_slotEPv:
 3073|  71.9k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|  71.9k|    return static_cast<slot_type*>(buf);
 3075|  71.9k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8transferEPNS1_13map_slot_typeISA_fEESF_:
 2941|   315k|  inline void transfer(slot_type* to, slot_type* from) {
 2942|   315k|    common().RunWithReentrancyGuard([&] {
 2943|   315k|      allocator_type alloc(char_alloc_ref());
 2944|   315k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   315k|    });
 2946|   315k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE8transferEPNS1_13map_slot_typeISC_fEESH_EUlvE_EEvT_:
 1099|   315k|  void RunWithReentrancyGuard(F f) {
 1100|   315k|#ifdef NDEBUG
 1101|   315k|    f();
 1102|   315k|    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_9allocatorIcEEEEfEEJEE8transferEPNS1_13map_slot_typeISA_fEESF_ENKUlvE_clEv:
 2942|   315k|    common().RunWithReentrancyGuard([&] {
 2943|   315k|      allocator_type alloc(char_alloc_ref());
 2944|   315k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   315k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14char_alloc_refEv:
 3479|  1.34M|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3511|  9.67k|                                    size_t source_offset, size_t h1)) {
 3512|  9.67k|    const size_t new_capacity = common.capacity();
 3513|  9.67k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3514|  9.67k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  270|  9.67k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3515|  9.67k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  270|  9.67k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3516|       |
 3517|  9.67k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3518|  9.67k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3519|  9.67k|    ctrl_t* new_ctrl = common.control();
 3520|  9.67k|    slot_type* new_slots = set->slot_array();
 3521|       |
 3522|  27.7k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3522:34): [True: 18.0k, False: 9.67k]
  ------------------
 3523|  18.0k|         group_index += Group::kWidth) {
 3524|  18.0k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3525|  18.0k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3526|  18.0k|                  Group::kWidth);
 3527|  18.0k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3528|  18.0k|                  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|   252k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3531:38): [True: 252k, False: 18.0k]
  ------------------
 3532|   252k|        size_t old_index = group_index + in_fixed_group_index;
 3533|   252k|        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|   252k|        size_t hash = set->hash_of(old_slot);
 3537|   252k|        size_t h1 = H1(hash);
 3538|   252k|        h2_t h2 = H2(hash);
 3539|   252k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3540|   252k|            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|   252k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  189|   252k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 2.49k, False: 250k]
  |  |  |  Branch (189:49): [Folded, False: 252k]
  |  |  |  Branch (189:58): [True: 2.49k, False: 250k]
  |  |  ------------------
  ------------------
 3544|  2.49k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3545|  2.49k|          continue;
 3546|  2.49k|        }
 3547|   250k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  248|   250k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3548|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  248|   250k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3549|   250k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3550|   250k|        auto* new_slot = new_slots + new_index;
 3551|   250k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3552|   250k|        set->transfer(new_slot, old_slot);
 3553|   250k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3554|   250k|      }
 3555|  18.0k|    }
 3556|  9.67k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE10slot_arrayEv:
 3437|  2.35M|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  2.35M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|  2.35M|    return static_cast<slot_type*>(common().slot_array());
 3440|  2.35M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE6commonEv:
 3431|  7.61M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7hash_ofEPNS1_13map_slot_typeISA_fEE:
 3065|   252k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3066|   252k|    return PolicyTraits::apply(
 3067|   252k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3068|   252k|        PolicyTraits::element(slot));
 3069|   252k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8hash_refEv:
 3476|  1.23M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE6insertINS4_11__wrap_iterIPKNS4_4pairISA_fEEEEEEvT_SK_:
 2479|  6.79k|  void insert(InputIt first, InputIt last) {
 2480|  6.79k|    insert_range(first, last);
 2481|  6.79k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE12insert_rangeINS4_11__wrap_iterIPKNS4_4pairISA_fEEEEEEvT_SK_:
 3272|  6.79k|  void insert_range(InputIt first, InputIt last) {
 3273|   264k|    for (; first != last; ++first) emplace(*first);
  ------------------
  |  Branch (3273:12): [True: 258k, False: 6.79k]
  ------------------
 3274|  6.79k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7emplaceIJRKNS4_4pairISA_fEEETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSE_INSC_8iteratorEbEEDpOSJ_:
 2526|   258k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2527|   258k|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2528|   258k|                               std::forward<Args>(args)...);
 2529|   258k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE19EmplaceDecomposableclISA_JRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSI_IJRKfEEEEEENS4_4pairINSC_8iteratorEbEERKT_DpOT0_:
 2901|   258k|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 2902|   258k|      auto res = s.find_or_prepare_insert(key);
 2903|   258k|      if (res.second) {
  ------------------
  |  Branch (2903:11): [True: 258k, False: 0]
  ------------------
 2904|   258k|        s.emplace_at(res.first, std::forward<Args>(args)...);
 2905|   258k|      }
 2906|   258k|      return res;
 2907|   258k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE22find_or_prepare_insertISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3358|   654k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|   654k|    AssertOnFind(key);
 3360|   654k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 13.8k, False: 640k]
  ------------------
 3361|   640k|    return find_or_prepare_insert_large(key);
 3362|   654k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE12AssertOnFindISA_EEvRKT_:
 3279|  1.00M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|  1.00M|    AssertHashEqConsistent(key);
 3281|  1.00M|    AssertNotDebugCapacity();
 3282|  1.00M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE22AssertHashEqConsistentISA_EEvRKT_:
 3317|  1.00M|  void AssertHashEqConsistent(const K& key) {
 3318|  1.00M|#ifdef NDEBUG
 3319|  1.00M|    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_9allocatorIcEEEEfEEJEE22AssertNotDebugCapacityEv:
 3285|  1.54M|  void AssertNotDebugCapacity() const {
 3286|  1.54M|#ifdef NDEBUG
 3287|  1.54M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 1.54M, Folded]
  ------------------
 3288|  1.54M|      return;
 3289|  1.54M|    }
 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_9allocatorIcEEEEfEEJEE8is_smallEv:
 1874|  1.02M|  bool is_small() const { return common().is_small(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE28find_or_prepare_insert_smallISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3207|  13.8k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|  13.8k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  13.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|       |    if constexpr (SooEnabled()) {
 3210|       |      return find_or_prepare_insert_soo(key);
 3211|       |    }
 3212|  13.8k|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 6.87k, False: 6.93k]
  ------------------
 3213|  6.87k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3213:11): [True: 111, False: 6.75k]
  ------------------
 3214|    111|        common().infoz().RecordInsertHit();
 3215|    111|        return {single_iterator(), false};
 3216|    111|      }
 3217|  6.87k|    }
 3218|  13.6k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|  13.6k|                common(), GetPolicyFunctions(),
 3220|  13.6k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|  13.6k|            true};
 3222|  13.8k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE5emptyEv:
 2326|  21.0k|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8equal_toISA_EEbRKT_PNS1_13map_slot_typeISA_fEE:
 3056|   436k|                                             slot_type* slot) const {
 3057|   436k|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|   436k|                               PolicyTraits::element(slot));
 3059|   436k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE6eq_refEv:
 3478|   436k|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE11single_slotEv:
 3450|  7.66k|  slot_type* single_slot() {
 3451|  7.66k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  7.66k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|  7.66k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [Folded, False: 7.66k]
  ------------------
 3453|  7.66k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE15single_iteratorEv:
 3464|    308|  iterator single_iterator() {
 3465|    308|    return {SooControl(), single_slot(), common().generation_ptr()};
 3466|    308|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeISA_fEEPKh:
 1993|   899k|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|   899k|          ctrl_(ctrl),
 1995|   899k|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|   899k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|   899k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|   899k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3390|  13.6k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3391|  13.6k|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3392|  13.6k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8hash_refEv:
 3475|  13.6k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3225|   640k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|   640k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   640k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|   640k|    prefetch_heap_block();
 3228|   640k|    const size_t hash = hash_of(key);
 3229|   640k|    auto seq = probe(common(), hash);
 3230|   640k|    const h2_t h2 = H2(hash);
 3231|   640k|    const ctrl_t* ctrl = control();
 3232|   640k|    size_t index;
 3233|   640k|    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|   640k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   640k|      while (true) {
 3238|   640k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   640k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   640k|#endif
 3241|   640k|        Group g{ctrl + seq.offset()};
 3242|   640k|        for (uint32_t i : g.Match(h2)) {
 3243|   640k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|   640k|            index = seq.offset(i);
 3245|   640k|            inserted = false;
 3246|   640k|            common().infoz().RecordInsertHit();
 3247|   640k|            return;
 3248|   640k|          }
 3249|   640k|        }
 3250|   640k|        auto mask_empty = g.MaskEmpty();
 3251|   640k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|   640k|          size_t target_group_offset = seq.offset();
 3253|   640k|          index = SwisstableGenerationsEnabled()
 3254|   640k|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|   640k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|   640k|                            FindInfo{target_group_offset, seq.index()},
 3257|   640k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|   640k|                      : PrepareInsertLarge(
 3259|   640k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   640k|                            FindInfo{target_group_offset, seq.index()});
 3261|   640k|          inserted = true;
 3262|   640k|          return;
 3263|   640k|        }
 3264|   640k|        seq.next();
 3265|   640k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|   640k|      }
 3267|   640k|    }();
 3268|   640k|    return {iterator_at(index), inserted};
 3269|   640k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE19prefetch_heap_blockEv:
 3423|   986k|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   986k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|   986k|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|   986k|    __builtin_prefetch(control(), 0, 1);
 3427|   986k|#endif
 3428|   986k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7hash_ofISA_EEmRKT_:
 3061|   986k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|   986k|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|   986k|                                               common().seed().seed()}(key);
 3064|   986k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7controlEv:
 3433|  2.87M|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  2.87M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|  2.87M|    return common().control();
 3436|  2.87M|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|   640k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   652k|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 652k, Folded]
  ------------------
 3238|   652k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   652k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   652k|#endif
 3241|   652k|        Group g{ctrl + seq.offset()};
 3242|   652k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 174k, False: 503k]
  ------------------
 3243|   174k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|   174k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 148k, False: 25.1k]
  |  |  |  Branch (190:48): [Folded, False: 174k]
  |  |  |  Branch (190:57): [True: 148k, False: 25.1k]
  |  |  ------------------
  ------------------
 3244|   148k|            index = seq.offset(i);
 3245|   148k|            inserted = false;
 3246|   148k|            common().infoz().RecordInsertHit();
 3247|   148k|            return;
 3248|   148k|          }
 3249|   174k|        }
 3250|   503k|        auto mask_empty = g.MaskEmpty();
 3251|   503k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|   503k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 492k, False: 11.0k]
  |  |  |  Branch (190:48): [Folded, False: 503k]
  |  |  |  Branch (190:57): [True: 492k, False: 11.0k]
  |  |  ------------------
  ------------------
 3252|   492k|          size_t target_group_offset = seq.offset();
 3253|   492k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 492k]
  ------------------
 3254|   492k|                      ? 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|   492k|                      : PrepareInsertLarge(
 3259|   492k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   492k|                            FindInfo{target_group_offset, seq.index()});
 3261|   492k|          inserted = true;
 3262|   492k|          return;
 3263|   492k|        }
 3264|  11.0k|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  11.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|  11.0k|      }
 3267|   640k|    }();
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE11iterator_atEm:
 3383|   885k|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|   885k|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|   885k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJRKfEEEEEEvNSC_8iteratorEDpOT_:
 3373|   258k|  void emplace_at(iterator iter, Args&&... args) {
 3374|   258k|    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|   258k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|   258k|           "constructed value does not match the lookup key");
 3381|   258k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJRKfEEEEEEvPNS1_13map_slot_typeISA_fEEDpOT_:
 2929|   258k|  inline void construct(slot_type* slot, Args&&... args) {
 2930|   258k|    common().RunWithReentrancyGuard([&] {
 2931|   258k|      allocator_type alloc(char_alloc_ref());
 2932|   258k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   258k|    });
 2934|   258k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSJ_IJRKfEEEEEEvPNS1_13map_slot_typeISC_fEEDpOT_EUlvE_EEvT_:
 1099|   258k|  void RunWithReentrancyGuard(F f) {
 1100|   258k|#ifdef NDEBUG
 1101|   258k|    f();
 1102|   258k|    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_9allocatorIcEEEEfEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJRKfEEEEEEvPNS1_13map_slot_typeISA_fEEDpOT_ENKUlvE_clEv:
 2930|   258k|    common().RunWithReentrancyGuard([&] {
 2931|   258k|      allocator_type alloc(char_alloc_ref());
 2932|   258k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   258k|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iterator4slotEv:
 2042|   505k|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEED2Ev:
 2294|  13.5k|  ~raw_hash_set() {
 2295|  13.5k|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|  13.5k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE15destructor_implEv:
 3019|  13.5k|  void destructor_impl() {
 3020|  13.5k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 13.5k]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|  13.5k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 0, False: 13.5k]
  ------------------
 3025|  13.5k|    if (is_small()) {
  ------------------
  |  Branch (3025:9): [True: 172, False: 13.4k]
  ------------------
 3026|    172|      if (!empty()) {
  ------------------
  |  Branch (3026:11): [True: 172, False: 0]
  ------------------
 3027|    172|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|    172|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3028|    172|      }
 3029|       |      if constexpr (SooEnabled()) return;
 3030|  13.4k|    } else {
 3031|  13.4k|      destroy_slots();
 3032|  13.4k|    }
 3033|  13.5k|    dealloc();
 3034|  13.5k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8capacityEv:
 2331|  40.7k|  size_t capacity() const {
 2332|  40.7k|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|  40.7k|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|  40.7k|        DefaultCapacity();
 2336|  40.7k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|  40.7k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|  40.7k|    return cap;
 2338|  40.7k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7destroyEPNS1_13map_slot_typeISA_fEE:
 2935|   505k|  inline void destroy(slot_type* slot) {
 2936|   505k|    common().RunWithReentrancyGuard([&] {
 2937|   505k|      allocator_type alloc(char_alloc_ref());
 2938|   505k|      PolicyTraits::destroy(&alloc, slot);
 2939|   505k|    });
 2940|   505k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE7destroyEPNS1_13map_slot_typeISC_fEEEUlvE_EEvT_:
 1099|   505k|  void RunWithReentrancyGuard(F f) {
 1100|   505k|#ifdef NDEBUG
 1101|   505k|    f();
 1102|   505k|    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_9allocatorIcEEEEfEEJEE7destroyEPNS1_13map_slot_typeISA_fEEENKUlvE_clEv:
 2936|   505k|    common().RunWithReentrancyGuard([&] {
 2937|   505k|      allocator_type alloc(char_alloc_ref());
 2938|   505k|      PolicyTraits::destroy(&alloc, slot);
 2939|   505k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE13destroy_slotsEv:
 2992|  13.4k|  void destroy_slots() {
 2993|  13.4k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  13.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2994|  13.4k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (2994:9): [Folded, False: 13.4k]
  ------------------
 2995|  13.4k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 2996|  13.4k|      this->destroy(static_cast<slot_type*>(slot));
 2997|  13.4k|    };
 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|  13.4k|    } else {
 3004|  13.4k|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3005|  13.4k|    }
 3006|  13.4k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE13destroy_slotsEvENKUlPKNS1_6ctrl_tEPvE_clESF_SG_:
 2995|   505k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 2996|   505k|      this->destroy(static_cast<slot_type*>(slot));
 2997|   505k|    };
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7deallocEv:
 3008|  13.5k|  void dealloc() {
 3009|  13.5k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|  13.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3010|       |    // Unpoison before returning the memory to the allocator.
 3011|  13.5k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3012|  13.5k|    infoz().Unregister();
 3013|  13.5k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3014|  13.5k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3015|  13.5k|                                      sizeof(slot_type), alignof(slot_type),
 3016|  13.5k|                                      common().has_infoz());
 3017|  13.5k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE5infozEv:
 3470|  13.5k|  HashtablezInfoHandle infoz() {
 3471|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  13.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3472|  13.5k|    return common().infoz();
 3473|  13.5k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE22find_or_prepare_insertISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3358|  12.7M|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|  12.7M|    AssertOnFind(key);
 3360|  12.7M|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 73.7k, False: 12.6M]
  ------------------
 3361|  12.6M|    return find_or_prepare_insert_large(key);
 3362|  12.7M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE12AssertOnFindISA_EEvRKT_:
 3279|  14.5M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|  14.5M|    AssertHashEqConsistent(key);
 3281|  14.5M|    AssertNotDebugCapacity();
 3282|  14.5M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE22AssertHashEqConsistentISA_EEvRKT_:
 3317|  14.5M|  void AssertHashEqConsistent(const K& key) {
 3318|  14.5M|#ifdef NDEBUG
 3319|  14.5M|    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__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_smallISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3207|  73.7k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|  73.7k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  73.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|       |    if constexpr (SooEnabled()) {
 3210|       |      return find_or_prepare_insert_soo(key);
 3211|       |    }
 3212|  73.7k|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 60.7k, False: 13.0k]
  ------------------
 3213|  60.7k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3213:11): [True: 48.0k, False: 12.6k]
  ------------------
 3214|  48.0k|        common().infoz().RecordInsertHit();
 3215|  48.0k|        return {single_iterator(), false};
 3216|  48.0k|      }
 3217|  60.7k|    }
 3218|  25.6k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|  25.6k|                common(), GetPolicyFunctions(),
 3220|  25.6k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|  25.6k|            true};
 3222|  73.7k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8equal_toISA_EEbRKT_PNS1_13map_slot_typeISA_lEE:
 3056|  11.3M|                                             slot_type* slot) const {
 3057|  11.3M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|  11.3M|                               PolicyTraits::element(slot));
 3059|  11.3M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3225|  12.6M|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|  12.6M|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  12.6M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|  12.6M|    prefetch_heap_block();
 3228|  12.6M|    const size_t hash = hash_of(key);
 3229|  12.6M|    auto seq = probe(common(), hash);
 3230|  12.6M|    const h2_t h2 = H2(hash);
 3231|  12.6M|    const ctrl_t* ctrl = control();
 3232|  12.6M|    size_t index;
 3233|  12.6M|    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|  12.6M|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|  12.6M|      while (true) {
 3238|  12.6M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|  12.6M|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|  12.6M|#endif
 3241|  12.6M|        Group g{ctrl + seq.offset()};
 3242|  12.6M|        for (uint32_t i : g.Match(h2)) {
 3243|  12.6M|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|  12.6M|            index = seq.offset(i);
 3245|  12.6M|            inserted = false;
 3246|  12.6M|            common().infoz().RecordInsertHit();
 3247|  12.6M|            return;
 3248|  12.6M|          }
 3249|  12.6M|        }
 3250|  12.6M|        auto mask_empty = g.MaskEmpty();
 3251|  12.6M|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|  12.6M|          size_t target_group_offset = seq.offset();
 3253|  12.6M|          index = SwisstableGenerationsEnabled()
 3254|  12.6M|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|  12.6M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|  12.6M|                            FindInfo{target_group_offset, seq.index()},
 3257|  12.6M|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|  12.6M|                      : PrepareInsertLarge(
 3259|  12.6M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|  12.6M|                            FindInfo{target_group_offset, seq.index()});
 3261|  12.6M|          inserted = true;
 3262|  12.6M|          return;
 3263|  12.6M|        }
 3264|  12.6M|        seq.next();
 3265|  12.6M|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|  12.6M|      }
 3267|  12.6M|    }();
 3268|  12.6M|    return {iterator_at(index), inserted};
 3269|  12.6M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7hash_ofISA_EEmRKT_:
 3061|  14.4M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|  14.4M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|  14.4M|                                               common().seed().seed()}(key);
 3064|  14.4M|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|  12.6M|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|  12.8M|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 12.8M, Folded]
  ------------------
 3238|  12.8M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|  12.8M|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|  12.8M|#endif
 3241|  12.8M|        Group g{ctrl + seq.offset()};
 3242|  12.8M|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 11.1M, False: 2.12M]
  ------------------
 3243|  11.1M|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|  11.1M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 10.7M, False: 351k]
  |  |  |  Branch (190:48): [Folded, False: 11.1M]
  |  |  |  Branch (190:57): [True: 10.7M, False: 351k]
  |  |  ------------------
  ------------------
 3244|  10.7M|            index = seq.offset(i);
 3245|  10.7M|            inserted = false;
 3246|  10.7M|            common().infoz().RecordInsertHit();
 3247|  10.7M|            return;
 3248|  10.7M|          }
 3249|  11.1M|        }
 3250|  2.12M|        auto mask_empty = g.MaskEmpty();
 3251|  2.12M|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|  2.12M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 1.92M, False: 201k]
  |  |  |  Branch (190:48): [Folded, False: 2.12M]
  |  |  |  Branch (190:57): [True: 1.92M, False: 201k]
  |  |  ------------------
  ------------------
 3252|  1.92M|          size_t target_group_offset = seq.offset();
 3253|  1.92M|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 1.92M]
  ------------------
 3254|  1.92M|                      ? 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|  1.92M|                      : PrepareInsertLarge(
 3259|  1.92M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|  1.92M|                            FindInfo{target_group_offset, seq.index()});
 3261|  1.92M|          inserted = true;
 3262|  1.92M|          return;
 3263|  1.92M|        }
 3264|   201k|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|   201k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|   201k|      }
 3267|  12.6M|    }();
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3373|   187k|  void emplace_at(iterator iter, Args&&... args) {
 3374|   187k|    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|   187k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|   187k|           "constructed value does not match the lookup key");
 3381|   187k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_:
 2929|   187k|  inline void construct(slot_type* slot, Args&&... args) {
 2930|   187k|    common().RunWithReentrancyGuard([&] {
 2931|   187k|      allocator_type alloc(char_alloc_ref());
 2932|   187k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   187k|    });
 2934|   187k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJOSC_EEENSJ_IJEEEEEEvPNS1_13map_slot_typeISC_lEEDpOT_EUlvE_EEvT_:
 1099|   187k|  void RunWithReentrancyGuard(F f) {
 1100|   187k|#ifdef NDEBUG
 1101|   187k|    f();
 1102|   187k|    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_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_ENKUlvE_clEv:
 2930|   187k|    common().RunWithReentrancyGuard([&] {
 2931|   187k|      allocator_type alloc(char_alloc_ref());
 2932|   187k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   187k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3373|  1.76M|  void emplace_at(iterator iter, Args&&... args) {
 3374|  1.76M|    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|  1.76M|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|  1.76M|           "constructed value does not match the lookup key");
 3381|  1.76M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_:
 2929|  1.76M|  inline void construct(slot_type* slot, Args&&... args) {
 2930|  1.76M|    common().RunWithReentrancyGuard([&] {
 2931|  1.76M|      allocator_type alloc(char_alloc_ref());
 2932|  1.76M|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|  1.76M|    });
 2934|  1.76M|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSJ_IJEEEEEEvPNS1_13map_slot_typeISC_lEEDpOT_EUlvE_EEvT_:
 1099|  1.76M|  void RunWithReentrancyGuard(F f) {
 1100|  1.76M|#ifdef NDEBUG
 1101|  1.76M|    f();
 1102|  1.76M|    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_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_ENKUlvE_clEv:
 2930|  1.76M|    common().RunWithReentrancyGuard([&] {
 2931|  1.76M|      allocator_type alloc(char_alloc_ref());
 2932|  1.76M|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|  1.76M|    });
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorESF_:
 1986|  1.76M|    friend bool operator!=(const iterator& a, const iterator& b) {
 1987|  1.76M|      return !(a == b);
 1988|  1.76M|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE5clearEv:
 2341|  6.80k|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2342|  6.80k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (2342:9): [Folded, False: 6.80k]
  ------------------
 2343|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (2343:9): [True: 0, False: 0]
  ------------------
 2344|      0|      common().set_capacity(DefaultCapacity());
 2345|      0|    }
 2346|  6.80k|    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|  6.80k|    const size_t cap = capacity();
 2355|  6.80k|    if (cap == 0) {
  ------------------
  |  Branch (2355:9): [True: 610, False: 6.19k]
  ------------------
 2356|       |      // Already guaranteed to be empty; so nothing to do.
 2357|  6.19k|    } else if (is_small()) {
  ------------------
  |  Branch (2357:16): [True: 302, False: 5.89k]
  ------------------
 2358|    302|      if (!empty()) {
  ------------------
  |  Branch (2358:11): [True: 302, False: 0]
  ------------------
 2359|    302|        destroy(single_slot());
 2360|    302|        decrement_small_size();
 2361|    302|      }
 2362|  5.89k|    } else {
 2363|  5.89k|      destroy_slots();
 2364|  5.89k|      clear_backing_array(/*reuse=*/cap < 128);
 2365|  5.89k|    }
 2366|  6.80k|    common().set_reserved_growth(0);
 2367|  6.80k|    common().set_reservation_size(0);
 2368|  6.80k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE20decrement_small_sizeEv:
 3457|    302|  void decrement_small_size() {
 3458|    302|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|    302|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3459|    302|    SooEnabled() ? common().set_empty_soo() : common().decrement_size();
  ------------------
  |  Branch (3459:5): [Folded, False: 302]
  ------------------
 3460|    302|    if (!SooEnabled()) {
  ------------------
  |  Branch (3460:9): [True: 302, Folded]
  ------------------
 3461|    302|      SanitizerPoisonObject(single_slot());
 3462|    302|    }
 3463|    302|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE19clear_backing_arrayEb:
 2986|  5.89k|  void clear_backing_array(bool reuse) {
 2987|       |    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|  5.89k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2988|  5.89k|    ClearBackingArray(common(), GetPolicyFunctions(), &char_alloc_ref(), reuse,
 2989|  5.89k|                      SooEnabled());
 2990|  5.89k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE4findISA_EENSC_14const_iteratorERKT_:
 2803|  1.76M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2804|  1.76M|    return const_cast<raw_hash_set*>(this)->find(key);
 2805|  1.76M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE4findISA_EENSC_8iteratorERKT_:
 2788|  1.76M|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2789|  1.76M|    AssertOnFind(key);
 2790|  1.76M|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (2790:9): [True: 198, False: 1.76M]
  ------------------
 2791|  1.76M|    prefetch_heap_block();
 2792|  1.76M|    return find_large(key, hash_of(key));
 2793|  1.76M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10find_smallISA_EENSC_8iteratorERKT_:
 2951|    198|  iterator find_small(const key_arg<K>& key) {
 2952|    198|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|    198|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2953|    198|    return empty() || !equal_to(key, single_slot()) ? end() : single_iterator();
  ------------------
  |  Branch (2953:12): [True: 0, False: 198]
  |  Branch (2953:23): [True: 198, False: 0]
  ------------------
 2954|    198|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10find_largeISA_EENSC_8iteratorERKT_m:
 2957|  1.76M|  iterator find_large(const key_arg<K>& key, size_t hash) {
 2958|  1.76M|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  1.76M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2959|  1.76M|    auto seq = probe(common(), hash);
 2960|  1.76M|    const h2_t h2 = H2(hash);
 2961|  1.76M|    const ctrl_t* ctrl = control();
 2962|  1.81M|    while (true) {
  ------------------
  |  Branch (2962:12): [True: 1.81M, Folded]
  ------------------
 2963|  1.81M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 2964|  1.81M|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 2965|  1.81M|#endif
 2966|  1.81M|      Group g{ctrl + seq.offset()};
 2967|  1.81M|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (2967:23): [True: 147k, False: 1.81M]
  ------------------
 2968|   147k|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  190|   147k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 147k]
  |  |  |  Branch (190:48): [Folded, False: 147k]
  |  |  |  Branch (190:57): [True: 0, False: 147k]
  |  |  ------------------
  ------------------
 2969|      0|          return iterator_at(seq.offset(i));
 2970|   147k|      }
 2971|  1.81M|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  190|  1.81M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 1.76M, False: 58.4k]
  |  |  |  Branch (190:48): [Folded, False: 1.81M]
  |  |  |  Branch (190:57): [True: 1.76M, False: 58.4k]
  |  |  ------------------
  ------------------
 2972|  58.4k|      seq.next();
 2973|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  58.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2974|  58.4k|    }
 2975|  1.76M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEEC2Ev:
 2109|  6.79k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE5beginEv:
 2315|  8.82k|  const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2316|  8.82k|    return const_cast<raw_hash_set*>(this)->begin();
 2317|  8.82k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE5beginEv:
 2301|  9.05k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2302|  9.05k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  189|  9.05k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 14, False: 9.03k]
  |  |  |  Branch (189:49): [Folded, False: 9.05k]
  |  |  |  Branch (189:58): [True: 14, False: 9.03k]
  |  |  ------------------
  ------------------
 2303|  9.03k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2303:9): [True: 78, False: 8.96k]
  ------------------
 2304|  8.96k|    iterator it = {control(), common().slots_union(),
 2305|  8.96k|                   common().generation_ptr()};
 2306|  8.96k|    it.skip_empty_or_deleted();
 2307|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  248|  8.96k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2308|  8.96k|    return it;
 2309|  9.03k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2005|  8.96k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2006|  8.96k|          ctrl_(ctrl),
 2007|  8.96k|          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|  8.96k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  8.96k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2011|  8.96k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iterator21skip_empty_or_deletedEv:
 2022|   545k|    void skip_empty_or_deleted() {
 2023|   848k|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2023:14): [True: 303k, False: 545k]
  ------------------
 2024|   303k|        ++ctrl_;
 2025|   303k|        ++slot_;
 2026|   303k|      }
 2027|   545k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE14const_iteratorppEv:
 2074|   505k|    const_iterator& operator++() {
 2075|   505k|      ++inner_;
 2076|   505k|      return *this;
 2077|   505k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iteratorppEv:
 1964|   536k|    iterator& operator++() {
 1965|   536k|      assert_is_full("operator++");
 1966|   536k|      ++ctrl_;
 1967|   536k|      ++slot_;
 1968|   536k|      skip_empty_or_deleted();
 1969|   536k|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  189|   536k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 17.8k, False: 518k]
  |  |  |  Branch (189:49): [Folded, False: 536k]
  |  |  |  Branch (189:58): [True: 17.8k, False: 518k]
  |  |  ------------------
  ------------------
 1970|   536k|      return *this;
 1971|   536k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iterator14assert_is_fullEPKc:
 2016|  3.46M|    void assert_is_full(const char* operation) const {
 2017|  3.46M|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|  3.46M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE14const_iteratordeEv:
 2071|   252k|    reference operator*() const { return *inner_; }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iteratordeEv:
 1952|  1.60M|    reference operator*() const {
 1953|  1.60M|      assert_is_full("operator*()");
 1954|  1.60M|      return unchecked_deref();
 1955|  1.60M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iterator15unchecked_derefEv:
 2039|  1.60M|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14const_iteratorESF_:
 2083|   855k|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2084|   855k|      return !(a == b);
 2085|   855k|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14const_iteratorESF_:
 2080|   855k|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2081|   855k|      return a.inner_ == b.inner_;
 2082|   855k|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratorESF_:
 1979|   855k|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|   855k|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|   855k|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|   855k|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|   855k|                          a.generation_ptr(), b.generation_ptr());
 1984|   855k|      return a.ctrl_ == b.ctrl_;
 1985|   855k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE4findISA_EENSC_14const_iteratorERKT_:
 2803|   346k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2804|   346k|    return const_cast<raw_hash_set*>(this)->find(key);
 2805|   346k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE4findISA_EENSC_8iteratorERKT_:
 2788|   346k|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2789|   346k|    AssertOnFind(key);
 2790|   346k|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (2790:9): [True: 317, False: 345k]
  ------------------
 2791|   345k|    prefetch_heap_block();
 2792|   345k|    return find_large(key, hash_of(key));
 2793|   346k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE10find_smallISA_EENSC_8iteratorERKT_:
 2951|    317|  iterator find_small(const key_arg<K>& key) {
 2952|    317|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|    317|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2953|    317|    return empty() || !equal_to(key, single_slot()) ? end() : single_iterator();
  ------------------
  |  Branch (2953:12): [True: 0, False: 317]
  |  Branch (2953:23): [True: 160, False: 157]
  ------------------
 2954|    317|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE3endEv:
 2310|   454k|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|   454k|    AssertNotDebugCapacity();
 2312|   454k|    return iterator(common().generation_ptr());
 2313|   454k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratorC2EPKh:
 2014|   454k|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE10find_largeISA_EENSC_8iteratorERKT_m:
 2957|   345k|  iterator find_large(const key_arg<K>& key, size_t hash) {
 2958|   345k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|   345k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2959|   345k|    auto seq = probe(common(), hash);
 2960|   345k|    const h2_t h2 = H2(hash);
 2961|   345k|    const ctrl_t* ctrl = control();
 2962|   355k|    while (true) {
  ------------------
  |  Branch (2962:12): [True: 355k, Folded]
  ------------------
 2963|   355k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 2964|   355k|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 2965|   355k|#endif
 2966|   355k|      Group g{ctrl + seq.offset()};
 2967|   355k|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (2967:23): [True: 255k, False: 111k]
  ------------------
 2968|   255k|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  190|   255k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 244k, False: 10.9k]
  |  |  |  Branch (190:48): [Folded, False: 255k]
  |  |  |  Branch (190:57): [True: 244k, False: 10.9k]
  |  |  ------------------
  ------------------
 2969|   244k|          return iterator_at(seq.offset(i));
 2970|   255k|      }
 2971|   111k|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  190|   111k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 101k, False: 9.88k]
  |  |  |  Branch (190:48): [Folded, False: 111k]
  |  |  |  Branch (190:57): [True: 101k, False: 9.88k]
  |  |  ------------------
  ------------------
 2972|  9.88k|      seq.next();
 2973|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  9.88k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2974|  9.88k|    }
 2975|   345k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14const_iteratorC2ENSC_8iteratorE:
 2069|   706k|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE3endEv:
 2318|   353k|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2319|   353k|    return const_cast<raw_hash_set*>(this)->end();
 2320|   353k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE15unchecked_derefENSC_8iteratorE:
 3394|   396k|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iterator15unchecked_derefEv:
 2039|   644k|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3373|   247k|  void emplace_at(iterator iter, Args&&... args) {
 3374|   247k|    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|   247k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|   247k|           "constructed value does not match the lookup key");
 3381|   247k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_fEEDpOT_:
 2929|   247k|  inline void construct(slot_type* slot, Args&&... args) {
 2930|   247k|    common().RunWithReentrancyGuard([&] {
 2931|   247k|      allocator_type alloc(char_alloc_ref());
 2932|   247k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   247k|    });
 2934|   247k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSJ_IJEEEEEEvPNS1_13map_slot_typeISC_fEEDpOT_EUlvE_EEvT_:
 1099|   247k|  void RunWithReentrancyGuard(F f) {
 1100|   247k|#ifdef NDEBUG
 1101|   247k|    f();
 1102|   247k|    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_9allocatorIcEEEEfEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_fEEDpOT_ENKUlvE_clEv:
 2930|   247k|    common().RunWithReentrancyGuard([&] {
 2931|   247k|      allocator_type alloc(char_alloc_ref());
 2932|   247k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   247k|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE4sizeEv:
 2327|  84.4k|  size_t size() const {
 2328|  84.4k|    AssertNotDebugCapacity();
 2329|  84.4k|    return common().size();
 2330|  84.4k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE5beginEv:
 2315|  6.79k|  const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2316|  6.79k|    return const_cast<raw_hash_set*>(this)->begin();
 2317|  6.79k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE5beginEv:
 2301|  6.79k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2302|  6.79k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  189|  6.79k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 6.79k]
  |  |  |  Branch (189:49): [Folded, False: 6.79k]
  |  |  |  Branch (189:58): [True: 0, False: 6.79k]
  |  |  ------------------
  ------------------
 2303|  6.79k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2303:9): [True: 40, False: 6.75k]
  ------------------
 2304|  6.75k|    iterator it = {control(), common().slots_union(),
 2305|  6.75k|                   common().generation_ptr()};
 2306|  6.75k|    it.skip_empty_or_deleted();
 2307|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  248|  6.75k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2308|  6.75k|    return it;
 2309|  6.79k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2005|  6.75k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2006|  6.75k|          ctrl_(ctrl),
 2007|  6.75k|          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|  6.75k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  6.75k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2011|  6.75k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iterator21skip_empty_or_deletedEv:
 2022|   502k|    void skip_empty_or_deleted() {
 2023|   757k|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2023:14): [True: 254k, False: 502k]
  ------------------
 2024|   254k|        ++ctrl_;
 2025|   254k|        ++slot_;
 2026|   254k|      }
 2027|   502k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14const_iteratorppEv:
 2074|   495k|    const_iterator& operator++() {
 2075|   495k|      ++inner_;
 2076|   495k|      return *this;
 2077|   495k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratorppEv:
 1964|   495k|    iterator& operator++() {
 1965|   495k|      assert_is_full("operator++");
 1966|   495k|      ++ctrl_;
 1967|   495k|      ++slot_;
 1968|   495k|      skip_empty_or_deleted();
 1969|   495k|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  189|   495k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 13.5k, False: 481k]
  |  |  |  Branch (189:49): [Folded, False: 495k]
  |  |  |  Branch (189:58): [True: 13.5k, False: 481k]
  |  |  ------------------
  ------------------
 1970|   495k|      return *this;
 1971|   495k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iterator14assert_is_fullEPKc:
 2016|   742k|    void assert_is_full(const char* operation) const {
 2017|   742k|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|   742k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14const_iteratordeEv:
 2071|   247k|    reference operator*() const { return *inner_; }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratordeEv:
 1952|   247k|    reference operator*() const {
 1953|   247k|      assert_is_full("operator*()");
 1954|   247k|      return unchecked_deref();
 1955|   247k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEED2Ev:
 2294|  1.16k|  ~raw_hash_set() {
 2295|  1.16k|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|  1.16k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE15destructor_implEv:
 3019|  1.16k|  void destructor_impl() {
 3020|  1.16k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 1.16k]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|  1.16k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 7, False: 1.16k]
  ------------------
 3025|  1.16k|    if (is_small()) {
  ------------------
  |  Branch (3025:9): [True: 47, False: 1.11k]
  ------------------
 3026|     47|      if (!empty()) {
  ------------------
  |  Branch (3026:11): [True: 47, False: 0]
  ------------------
 3027|     47|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|     47|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3028|     47|      }
 3029|       |      if constexpr (SooEnabled()) return;
 3030|  1.11k|    } else {
 3031|  1.11k|      destroy_slots();
 3032|  1.11k|    }
 3033|  1.16k|    dealloc();
 3034|  1.16k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8capacityEv:
 2331|  3.48k|  size_t capacity() const {
 2332|  3.48k|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|  3.48k|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|  3.48k|        DefaultCapacity();
 2336|  3.48k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|  3.48k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|  3.48k|    return cap;
 2338|  3.48k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE6commonEv:
 3431|  1.37M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8is_smallEv:
 1874|   168k|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE5emptyEv:
 2326|  5.13k|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE4sizeEv:
 2327|  5.13k|  size_t size() const {
 2328|  5.13k|    AssertNotDebugCapacity();
 2329|  5.13k|    return common().size();
 2330|  5.13k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE22AssertNotDebugCapacityEv:
 3285|   172k|  void AssertNotDebugCapacity() const {
 3286|   172k|#ifdef NDEBUG
 3287|   172k|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 172k, Folded]
  ------------------
 3288|   172k|      return;
 3289|   172k|    }
 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__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7destroyEPNS1_13map_slot_typeISA_mEE:
 2935|   103k|  inline void destroy(slot_type* slot) {
 2936|   103k|    common().RunWithReentrancyGuard([&] {
 2937|   103k|      allocator_type alloc(char_alloc_ref());
 2938|   103k|      PolicyTraits::destroy(&alloc, slot);
 2939|   103k|    });
 2940|   103k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE6commonEv:
 3430|   857k|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEmEEJEE7destroyEPNS1_13map_slot_typeISC_mEEEUlvE_EEvT_:
 1099|   103k|  void RunWithReentrancyGuard(F f) {
 1100|   103k|#ifdef NDEBUG
 1101|   103k|    f();
 1102|   103k|    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_9allocatorIcEEEEmEEJEE7destroyEPNS1_13map_slot_typeISA_mEEENKUlvE_clEv:
 2936|   103k|    common().RunWithReentrancyGuard([&] {
 2937|   103k|      allocator_type alloc(char_alloc_ref());
 2938|   103k|      PolicyTraits::destroy(&alloc, slot);
 2939|   103k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14char_alloc_refEv:
 3479|   357k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE11single_slotEv:
 3450|  2.27k|  slot_type* single_slot() {
 3451|  2.27k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  2.27k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|  2.27k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [Folded, False: 2.27k]
  ------------------
 3453|  2.27k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE10slot_arrayEv:
 3437|   408k|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   408k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|   408k|    return static_cast<slot_type*>(common().slot_array());
 3440|   408k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE13destroy_slotsEv:
 2992|  1.11k|  void destroy_slots() {
 2993|  1.11k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  1.11k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2994|  1.11k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (2994:9): [Folded, False: 1.11k]
  ------------------
 2995|  1.11k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 2996|  1.11k|      this->destroy(static_cast<slot_type*>(slot));
 2997|  1.11k|    };
 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|  1.11k|    } else {
 3004|  1.11k|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3005|  1.11k|    }
 3006|  1.11k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE13destroy_slotsEvENKUlPKNS1_6ctrl_tEPvE_clESF_SG_:
 2995|   103k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 2996|   103k|      this->destroy(static_cast<slot_type*>(slot));
 2997|   103k|    };
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7deallocEv:
 3008|  1.16k|  void dealloc() {
 3009|  1.16k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|  1.16k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3010|       |    // Unpoison before returning the memory to the allocator.
 3011|  1.16k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3012|  1.16k|    infoz().Unregister();
 3013|  1.16k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3014|  1.16k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3015|  1.16k|                                      sizeof(slot_type), alignof(slot_type),
 3016|  1.16k|                                      common().has_infoz());
 3017|  1.16k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE5infozEv:
 3470|  1.16k|  HashtablezInfoHandle infoz() {
 3471|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  1.16k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3472|  1.16k|    return common().infoz();
 3473|  1.16k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7controlEv:
 3433|   489k|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   489k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|   489k|    return common().control();
 3436|   489k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEEC2Ev:
 2109|  1.16k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE15unchecked_derefENSC_8iteratorE:
 3394|   164k|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iterator15unchecked_derefEv:
 2039|   370k|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE22find_or_prepare_insertINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3358|   164k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|   164k|    AssertOnFind(key);
 3360|   164k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 2.79k, False: 161k]
  ------------------
 3361|   161k|    return find_or_prepare_insert_large(key);
 3362|   164k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE12AssertOnFindINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3279|   164k|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|   164k|    AssertHashEqConsistent(key);
 3281|   164k|    AssertNotDebugCapacity();
 3282|   164k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE22AssertHashEqConsistentINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3317|   164k|  void AssertHashEqConsistent(const K& key) {
 3318|   164k|#ifdef NDEBUG
 3319|   164k|    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__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE28find_or_prepare_insert_smallINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3207|  2.79k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|  2.79k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  2.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|       |    if constexpr (SooEnabled()) {
 3210|       |      return find_or_prepare_insert_soo(key);
 3211|       |    }
 3212|  2.79k|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 1.63k, False: 1.16k]
  ------------------
 3213|  1.63k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3213:11): [True: 517, False: 1.11k]
  ------------------
 3214|    517|        common().infoz().RecordInsertHit();
 3215|    517|        return {single_iterator(), false};
 3216|    517|      }
 3217|  1.63k|    }
 3218|  2.27k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|  2.27k|                common(), GetPolicyFunctions(),
 3220|  2.27k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|  2.27k|            true};
 3222|  2.79k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8equal_toINS4_17basic_string_viewIcS7_EEEEbRKT_PNS1_13map_slot_typeISA_mEE:
 3056|  72.0k|                                             slot_type* slot) const {
 3057|  72.0k|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|  72.0k|                               PolicyTraits::element(slot));
 3059|  72.0k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE6eq_refEv:
 3478|  72.0k|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE15single_iteratorEv:
 3464|    601|  iterator single_iterator() {
 3465|    601|    return {SooControl(), single_slot(), common().generation_ptr()};
 3466|    601|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeISA_mEEPKh:
 1993|   164k|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|   164k|          ctrl_(ctrl),
 1995|   164k|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|   164k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|   164k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|   164k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3390|  2.27k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3391|  2.27k|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3392|  2.27k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7to_slotEPv:
 3073|  14.9k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|  14.9k|    return static_cast<slot_type*>(buf);
 3075|  14.9k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE18GetPolicyFunctionsEv:
 3558|   103k|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|   103k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|   103k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|   103k|                  "or use absl::node_hash_{map,set}.");
 3562|   103k|    static_assert(alignof(slot_type) <=
 3563|   103k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|   103k|    static_assert(sizeof(key_type) <=
 3565|   103k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|   103k|    static_assert(sizeof(value_type) <=
 3567|   103k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|   103k|    static constexpr size_t kBackingArrayAlignment =
 3569|   103k|        BackingArrayAlignment(alignof(slot_type));
 3570|   103k|    static constexpr PolicyFunctions value = {
 3571|   103k|        static_cast<uint32_t>(sizeof(key_type)),
 3572|   103k|        static_cast<uint32_t>(sizeof(value_type)),
 3573|   103k|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|   103k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|   103k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|   103k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|   103k|                                : &raw_hash_set::get_hash_ref_fn,
 3580|   103k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|   103k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [Folded, False: 103k]
  ------------------
 3582|   103k|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|   103k|            : &raw_hash_set::transfer_n_slots_fn,
 3584|   103k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|   103k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|   103k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|   103k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|   103k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|   103k|    return value;
 3590|   103k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE19transfer_n_slots_fnEPvSD_SD_m:
 3494|  4.13k|                                  size_t count) {
 3495|  4.13k|    auto* src_slot = to_slot(src);
 3496|  4.13k|    auto* dst_slot = to_slot(dst);
 3497|       |
 3498|  4.13k|    auto* h = static_cast<raw_hash_set*>(set);
 3499|  15.0k|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3499:12): [True: 10.9k, False: 4.13k]
  ------------------
 3500|  10.9k|      h->transfer(dst_slot, src_slot);
 3501|  10.9k|    }
 3502|  4.13k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8transferEPNS1_13map_slot_typeISA_mEESF_:
 2941|   150k|  inline void transfer(slot_type* to, slot_type* from) {
 2942|   150k|    common().RunWithReentrancyGuard([&] {
 2943|   150k|      allocator_type alloc(char_alloc_ref());
 2944|   150k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   150k|    });
 2946|   150k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEmEEJEE8transferEPNS1_13map_slot_typeISC_mEESH_EUlvE_EEvT_:
 1099|   150k|  void RunWithReentrancyGuard(F f) {
 1100|   150k|#ifdef NDEBUG
 1101|   150k|    f();
 1102|   150k|    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_9allocatorIcEEEEmEEJEE8transferEPNS1_13map_slot_typeISA_mEESF_ENKUlvE_clEv:
 2942|   150k|    common().RunWithReentrancyGuard([&] {
 2943|   150k|      allocator_type alloc(char_alloc_ref());
 2944|   150k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   150k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3511|  2.20k|                                    size_t source_offset, size_t h1)) {
 3512|  2.20k|    const size_t new_capacity = common.capacity();
 3513|  2.20k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3514|  2.20k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  270|  2.20k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3515|  2.20k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  270|  2.20k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3516|       |
 3517|  2.20k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3518|  2.20k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3519|  2.20k|    ctrl_t* new_ctrl = common.control();
 3520|  2.20k|    slot_type* new_slots = set->slot_array();
 3521|       |
 3522|  12.2k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3522:34): [True: 10.0k, False: 2.20k]
  ------------------
 3523|  10.0k|         group_index += Group::kWidth) {
 3524|  10.0k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3525|  10.0k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3526|  10.0k|                  Group::kWidth);
 3527|  10.0k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3528|  10.0k|                  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|   140k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3531:38): [True: 140k, False: 10.0k]
  ------------------
 3532|   140k|        size_t old_index = group_index + in_fixed_group_index;
 3533|   140k|        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|   140k|        size_t hash = set->hash_of(old_slot);
 3537|   140k|        size_t h1 = H1(hash);
 3538|   140k|        h2_t h2 = H2(hash);
 3539|   140k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3540|   140k|            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|   140k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  189|   140k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1.22k, False: 139k]
  |  |  |  Branch (189:49): [Folded, False: 140k]
  |  |  |  Branch (189:58): [True: 1.22k, False: 139k]
  |  |  ------------------
  ------------------
 3544|  1.22k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3545|  1.22k|          continue;
 3546|  1.22k|        }
 3547|   139k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  248|   139k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3548|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  248|   139k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3549|   139k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3550|   139k|        auto* new_slot = new_slots + new_index;
 3551|   139k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3552|   139k|        set->transfer(new_slot, old_slot);
 3553|   139k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3554|   139k|      }
 3555|  10.0k|    }
 3556|  2.20k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7hash_ofEPNS1_13map_slot_typeISA_mEE:
 3065|   140k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3066|   140k|    return PolicyTraits::apply(
 3067|   140k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3068|   140k|        PolicyTraits::element(slot));
 3069|   140k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8hash_refEv:
 3476|   302k|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8hash_refEv:
 3475|  2.27k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE28find_or_prepare_insert_largeINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3225|   161k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|   161k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   161k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|   161k|    prefetch_heap_block();
 3228|   161k|    const size_t hash = hash_of(key);
 3229|   161k|    auto seq = probe(common(), hash);
 3230|   161k|    const h2_t h2 = H2(hash);
 3231|   161k|    const ctrl_t* ctrl = control();
 3232|   161k|    size_t index;
 3233|   161k|    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|   161k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   161k|      while (true) {
 3238|   161k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   161k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   161k|#endif
 3241|   161k|        Group g{ctrl + seq.offset()};
 3242|   161k|        for (uint32_t i : g.Match(h2)) {
 3243|   161k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|   161k|            index = seq.offset(i);
 3245|   161k|            inserted = false;
 3246|   161k|            common().infoz().RecordInsertHit();
 3247|   161k|            return;
 3248|   161k|          }
 3249|   161k|        }
 3250|   161k|        auto mask_empty = g.MaskEmpty();
 3251|   161k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|   161k|          size_t target_group_offset = seq.offset();
 3253|   161k|          index = SwisstableGenerationsEnabled()
 3254|   161k|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|   161k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|   161k|                            FindInfo{target_group_offset, seq.index()},
 3257|   161k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|   161k|                      : PrepareInsertLarge(
 3259|   161k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   161k|                            FindInfo{target_group_offset, seq.index()});
 3261|   161k|          inserted = true;
 3262|   161k|          return;
 3263|   161k|        }
 3264|   161k|        seq.next();
 3265|   161k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|   161k|      }
 3267|   161k|    }();
 3268|   161k|    return {iterator_at(index), inserted};
 3269|   161k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE19prefetch_heap_blockEv:
 3423|   161k|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   161k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|   161k|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|   161k|    __builtin_prefetch(control(), 0, 1);
 3427|   161k|#endif
 3428|   161k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7hash_ofINS4_17basic_string_viewIcS7_EEEEmRKT_:
 3061|   161k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|   161k|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|   161k|                                               common().seed().seed()}(key);
 3064|   161k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE28find_or_prepare_insert_largeINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|   161k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   170k|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 170k, Folded]
  ------------------
 3238|   170k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   170k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   170k|#endif
 3241|   170k|        Group g{ctrl + seq.offset()};
 3242|   170k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 70.4k, False: 109k]
  ------------------
 3243|  70.4k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|  70.4k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 61.1k, False: 9.35k]
  |  |  |  Branch (190:48): [Folded, False: 70.4k]
  |  |  |  Branch (190:57): [True: 61.1k, False: 9.35k]
  |  |  ------------------
  ------------------
 3244|  61.1k|            index = seq.offset(i);
 3245|  61.1k|            inserted = false;
 3246|  61.1k|            common().infoz().RecordInsertHit();
 3247|  61.1k|            return;
 3248|  61.1k|          }
 3249|  70.4k|        }
 3250|   109k|        auto mask_empty = g.MaskEmpty();
 3251|   109k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|   109k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 100k, False: 8.49k]
  |  |  |  Branch (190:48): [Folded, False: 109k]
  |  |  |  Branch (190:57): [True: 100k, False: 8.49k]
  |  |  ------------------
  ------------------
 3252|   100k|          size_t target_group_offset = seq.offset();
 3253|   100k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 100k]
  ------------------
 3254|   100k|                      ? 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|   100k|                      : PrepareInsertLarge(
 3259|   100k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   100k|                            FindInfo{target_group_offset, seq.index()});
 3261|   100k|          inserted = true;
 3262|   100k|          return;
 3263|   100k|        }
 3264|  8.49k|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  8.49k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|  8.49k|      }
 3267|   161k|    }();
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE11iterator_atEm:
 3383|   161k|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|   161k|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|   161k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3373|   103k|  void emplace_at(iterator iter, Args&&... args) {
 3374|   103k|    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|   103k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|   103k|           "constructed value does not match the lookup key");
 3381|   103k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_mEEDpOT_:
 2929|   103k|  inline void construct(slot_type* slot, Args&&... args) {
 2930|   103k|    common().RunWithReentrancyGuard([&] {
 2931|   103k|      allocator_type alloc(char_alloc_ref());
 2932|   103k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   103k|    });
 2934|   103k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEmEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKNS6_17basic_string_viewIcS9_EEEEENSJ_IJEEEEEEvPNS1_13map_slot_typeISC_mEEDpOT_EUlvE_EEvT_:
 1099|   103k|  void RunWithReentrancyGuard(F f) {
 1100|   103k|#ifdef NDEBUG
 1101|   103k|    f();
 1102|   103k|    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_9allocatorIcEEEEmEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_mEEDpOT_ENKUlvE_clEv:
 2930|   103k|    common().RunWithReentrancyGuard([&] {
 2931|   103k|      allocator_type alloc(char_alloc_ref());
 2932|   103k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   103k|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iterator4slotEv:
 2042|   103k|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE5beginEv:
 2301|  2.29k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2302|  2.29k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  189|  2.29k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 12, False: 2.28k]
  |  |  |  Branch (189:49): [Folded, False: 2.29k]
  |  |  |  Branch (189:58): [True: 12, False: 2.28k]
  |  |  ------------------
  ------------------
 2303|  2.28k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2303:9): [True: 84, False: 2.20k]
  ------------------
 2304|  2.20k|    iterator it = {control(), common().slots_union(),
 2305|  2.20k|                   common().generation_ptr()};
 2306|  2.20k|    it.skip_empty_or_deleted();
 2307|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  248|  2.20k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2308|  2.20k|    return it;
 2309|  2.28k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2005|  2.20k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2006|  2.20k|          ctrl_(ctrl),
 2007|  2.20k|          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|  2.20k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  2.20k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2011|  2.20k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iterator21skip_empty_or_deletedEv:
 2022|   310k|    void skip_empty_or_deleted() {
 2023|   523k|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2023:14): [True: 212k, False: 310k]
  ------------------
 2024|   212k|        ++ctrl_;
 2025|   212k|        ++slot_;
 2026|   212k|      }
 2027|   310k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE3endEv:
 2310|  2.31k|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|  2.31k|    AssertNotDebugCapacity();
 2312|  2.31k|    return iterator(common().generation_ptr());
 2313|  2.31k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorC2EPKh:
 2014|  2.31k|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorESF_:
 1986|   103k|    friend bool operator!=(const iterator& a, const iterator& b) {
 1987|   103k|      return !(a == b);
 1988|   103k|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorESF_:
 1979|   311k|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|   311k|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|   311k|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|   311k|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|   311k|                          a.generation_ptr(), b.generation_ptr());
 1984|   311k|      return a.ctrl_ == b.ctrl_;
 1985|   311k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorppEv:
 1964|   308k|    iterator& operator++() {
 1965|   308k|      assert_is_full("operator++");
 1966|   308k|      ++ctrl_;
 1967|   308k|      ++slot_;
 1968|   308k|      skip_empty_or_deleted();
 1969|   308k|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  189|   308k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 3.42k, False: 304k]
  |  |  |  Branch (189:49): [Folded, False: 308k]
  |  |  |  Branch (189:58): [True: 3.42k, False: 304k]
  |  |  ------------------
  ------------------
 1970|   308k|      return *this;
 1971|   308k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iterator14assert_is_fullEPKc:
 2016|   513k|    void assert_is_full(const char* operation) const {
 2017|   513k|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|   513k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratordeEv:
 1952|   205k|    reference operator*() const {
 1953|   205k|      assert_is_full("operator*()");
 1954|   205k|      return unchecked_deref();
 1955|   205k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE5beginEv:
 2315|  1.14k|  const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2316|  1.14k|    return const_cast<raw_hash_set*>(this)->begin();
 2317|  1.14k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14const_iteratorC2ENSC_8iteratorE:
 2069|  2.29k|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE3endEv:
 2318|  1.14k|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2319|  1.14k|    return const_cast<raw_hash_set*>(this)->end();
 2320|  1.14k|  }
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14const_iteratorESF_:
 2083|   207k|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2084|   207k|      return !(a == b);
 2085|   207k|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14const_iteratorESF_:
 2080|   207k|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2081|   207k|      return a.inner_ == b.inner_;
 2082|   207k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14const_iteratorppEv:
 2074|   205k|    const_iterator& operator++() {
 2075|   205k|      ++inner_;
 2076|   205k|      return *this;
 2077|   205k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14const_iteratordeEv:
 2071|   102k|    reference operator*() const { return *inner_; }
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iteratorES8_:
 1986|  30.3k|    friend bool operator!=(const iterator& a, const iterator& b) {
 1987|  30.3k|      return !(a == b);
 1988|  30.3k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEED2Ev:
 2294|  1.79k|  ~raw_hash_set() {
 2295|  1.79k|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|  1.79k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE15destructor_implEv:
 3019|  1.79k|  void destructor_impl() {
 3020|  1.79k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 1.79k]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|  1.79k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 39, False: 1.75k]
  ------------------
 3025|  1.75k|    if (is_small()) {
  ------------------
  |  Branch (3025:9): [True: 75, False: 1.68k]
  ------------------
 3026|     75|      if (!empty()) {
  ------------------
  |  Branch (3026:11): [True: 75, False: 0]
  ------------------
 3027|     75|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|     75|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3028|     75|      }
 3029|       |      if constexpr (SooEnabled()) return;
 3030|  1.68k|    } else {
 3031|  1.68k|      destroy_slots();
 3032|  1.68k|    }
 3033|  1.75k|    dealloc();
 3034|  1.75k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8capacityEv:
 2331|  5.30k|  size_t capacity() const {
 2332|  5.30k|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|  5.30k|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|  5.30k|        DefaultCapacity();
 2336|  5.30k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|  5.30k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|  5.30k|    return cap;
 2338|  5.30k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE6commonEv:
 3431|   462k|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8is_smallEv:
 1874|  58.6k|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE5emptyEv:
 2326|  3.51k|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE4sizeEv:
 2327|  3.51k|  size_t size() const {
 2328|  3.51k|    AssertNotDebugCapacity();
 2329|  3.51k|    return common().size();
 2330|  3.51k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE22AssertNotDebugCapacityEv:
 3285|  60.3k|  void AssertNotDebugCapacity() const {
 3286|  60.3k|#ifdef NDEBUG
 3287|  60.3k|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 60.3k, Folded]
  ------------------
 3288|  60.3k|      return;
 3289|  60.3k|    }
 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_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7destroyEPSA_:
 2935|  56.8k|  inline void destroy(slot_type* slot) {
 2936|  56.8k|    common().RunWithReentrancyGuard([&] {
 2937|  56.8k|      allocator_type alloc(char_alloc_ref());
 2938|  56.8k|      PolicyTraits::destroy(&alloc, slot);
 2939|  56.8k|    });
 2940|  56.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE6commonEv:
 3430|   363k|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEE7destroyEPSC_EUlvE_EEvT_:
 1099|  56.8k|  void RunWithReentrancyGuard(F f) {
 1100|  56.8k|#ifdef NDEBUG
 1101|  56.8k|    f();
 1102|  56.8k|    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_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7destroyEPSA_ENKUlvE_clEv:
 2936|  56.8k|    common().RunWithReentrancyGuard([&] {
 2937|  56.8k|      allocator_type alloc(char_alloc_ref());
 2938|  56.8k|      PolicyTraits::destroy(&alloc, slot);
 2939|  56.8k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE14char_alloc_refEv:
 3479|   192k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE11single_slotEv:
 3450|  1.75k|  slot_type* single_slot() {
 3451|  1.75k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  1.75k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|  1.75k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [Folded, False: 1.75k]
  ------------------
 3453|  1.75k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE10slot_arrayEv:
 3437|   118k|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   118k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|   118k|    return static_cast<slot_type*>(common().slot_array());
 3440|   118k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE13destroy_slotsEv:
 2992|  1.68k|  void destroy_slots() {
 2993|  1.68k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  1.68k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2994|  1.68k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (2994:9): [Folded, False: 1.68k]
  ------------------
 2995|  1.68k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 2996|  1.68k|      this->destroy(static_cast<slot_type*>(slot));
 2997|  1.68k|    };
 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|  1.68k|    } else {
 3004|  1.68k|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3005|  1.68k|    }
 3006|  1.68k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE13destroy_slotsEvENKUlPKNS1_6ctrl_tEPvE_clESF_SG_:
 2995|  56.7k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 2996|  56.7k|      this->destroy(static_cast<slot_type*>(slot));
 2997|  56.7k|    };
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7deallocEv:
 3008|  1.75k|  void dealloc() {
 3009|  1.75k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|  1.75k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3010|       |    // Unpoison before returning the memory to the allocator.
 3011|  1.75k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3012|  1.75k|    infoz().Unregister();
 3013|  1.75k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3014|  1.75k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3015|  1.75k|                                      sizeof(slot_type), alignof(slot_type),
 3016|  1.75k|                                      common().has_infoz());
 3017|  1.75k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE5infozEv:
 3470|  1.75k|  HashtablezInfoHandle infoz() {
 3471|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  1.75k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3472|  1.75k|    return common().infoz();
 3473|  1.75k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7controlEv:
 3433|   162k|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   162k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|   162k|    return common().control();
 3436|   162k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE14const_iteratorptEv:
 2072|  1.32M|    pointer operator->() const { return inner_.operator->(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjlEEJEE8iteratorptEv:
 1958|  1.32M|    pointer operator->() const {
 1959|  1.32M|      assert_is_full("operator->");
 1960|  1.32M|      return &operator*();
 1961|  1.32M|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE4findImEENSA_8iteratorERKm:
 2788|  5.45M|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2789|  5.45M|    AssertOnFind(key);
 2790|  5.45M|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (2790:9): [True: 3.69k, False: 5.44M]
  ------------------
 2791|  5.44M|    prefetch_heap_block();
 2792|  5.44M|    return find_large(key, hash_of(key));
 2793|  5.45M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE12AssertOnFindImEEvRKT_:
 3279|  5.81M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|  5.81M|    AssertHashEqConsistent(key);
 3281|  5.81M|    AssertNotDebugCapacity();
 3282|  5.81M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE22AssertHashEqConsistentImEEvRKT_:
 3317|  5.81M|  void AssertHashEqConsistent(const K& key) {
 3318|  5.81M|#ifdef NDEBUG
 3319|  5.81M|    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): [True: 0, Folded]
  ------------------
 3328|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3328:9): [True: 0, Folded]
  ------------------
 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_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE10find_smallImEENSA_8iteratorERKm:
 2951|  3.69k|  iterator find_small(const key_arg<K>& key) {
 2952|  3.69k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  3.69k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2953|  3.69k|    return empty() || !equal_to(key, single_slot()) ? end() : single_iterator();
  ------------------
  |  Branch (2953:12): [True: 1.79k, False: 1.90k]
  |  Branch (2953:23): [True: 1.79k, False: 114]
  ------------------
 2954|  3.69k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8equal_toImEEbRKT_PNS1_13map_slot_typeImS8_EE:
 3056|  5.03M|                                             slot_type* slot) const {
 3057|  5.03M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|  5.03M|                               PolicyTraits::element(slot));
 3059|  5.03M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE6eq_refEv:
 3478|  5.03M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE15single_iteratorEv:
 3464|  1.90k|  iterator single_iterator() {
 3465|  1.90k|    return {SooControl(), single_slot(), common().generation_ptr()};
 3466|  1.90k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeImS8_EEPKh:
 1993|  5.21M|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|  5.21M|          ctrl_(ctrl),
 1995|  5.21M|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|  5.21M|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  5.21M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|  5.21M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE19prefetch_heap_blockEv:
 3423|  5.80M|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  5.80M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|  5.80M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|  5.80M|    __builtin_prefetch(control(), 0, 1);
 3427|  5.80M|#endif
 3428|  5.80M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE10find_largeImEENSA_8iteratorERKmm:
 2957|  5.44M|  iterator find_large(const key_arg<K>& key, size_t hash) {
 2958|  5.44M|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  5.44M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2959|  5.44M|    auto seq = probe(common(), hash);
 2960|  5.44M|    const h2_t h2 = H2(hash);
 2961|  5.44M|    const ctrl_t* ctrl = control();
 2962|  5.55M|    while (true) {
  ------------------
  |  Branch (2962:12): [True: 5.55M, Folded]
  ------------------
 2963|  5.55M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 2964|  5.55M|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 2965|  5.55M|#endif
 2966|  5.55M|      Group g{ctrl + seq.offset()};
 2967|  5.55M|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (2967:23): [True: 5.00M, False: 695k]
  ------------------
 2968|  5.00M|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  190|  5.00M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 4.85M, False: 142k]
  |  |  |  Branch (190:48): [Folded, False: 5.00M]
  |  |  |  Branch (190:57): [True: 4.85M, False: 142k]
  |  |  ------------------
  ------------------
 2969|  4.85M|          return iterator_at(seq.offset(i));
 2970|  5.00M|      }
 2971|   695k|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  190|   695k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 589k, False: 105k]
  |  |  |  Branch (190:48): [Folded, False: 695k]
  |  |  |  Branch (190:57): [True: 589k, False: 105k]
  |  |  ------------------
  ------------------
 2972|   105k|      seq.next();
 2973|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|   105k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2974|   105k|    }
 2975|  5.44M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE11iterator_atEm:
 3383|  5.21M|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|  5.21M|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|  5.21M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7hash_ofImEEmRKT_:
 3061|  5.80M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|  5.80M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|  5.80M|                                               common().seed().seed()}(key);
 3064|  5.80M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8hash_refEv:
 3476|  6.27M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE3endEv:
 2310|  6.04M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|  6.04M|    AssertNotDebugCapacity();
 2312|  6.04M|    return iterator(common().generation_ptr());
 2313|  6.04M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorC2EPKh:
 2014|  6.04M|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorESD_:
 1986|  5.53M|    friend bool operator!=(const iterator& a, const iterator& b) {
 1987|  5.53M|      return !(a == b);
 1988|  5.53M|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorESD_:
 1979|  5.59M|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|  5.59M|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|  5.59M|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|  5.59M|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|  5.59M|                          a.generation_ptr(), b.generation_ptr());
 1984|  5.59M|      return a.ctrl_ == b.ctrl_;
 1985|  5.59M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorptEv:
 1958|  4.80M|    pointer operator->() const {
 1959|  4.80M|      assert_is_full("operator->");
 1960|  4.80M|      return &operator*();
 1961|  4.80M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iterator14assert_is_fullEPKc:
 2016|  9.93M|    void assert_is_full(const char* operation) const {
 2017|  9.93M|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|  9.93M|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE6insertINSt3__14pairIKmS8_EELi0EEENSD_INSA_8iteratorEbEERKT_:
 2411|   359k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2412|   359k|    return emplace(value);
 2413|   359k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7emplaceIJRKNSt3__14pairIKmS8_EEETnNSC_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSD_INSA_8iteratorEbEEDpOSJ_:
 2526|   359k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2527|   359k|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2528|   359k|                               std::forward<Args>(args)...);
 2529|   359k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE19EmplaceDecomposableclImJRKNSt3__121piecewise_construct_tENSD_5tupleIJRKmEEENSH_IJRKS8_EEEEEENSD_4pairINSA_8iteratorEbEERKT_DpOT0_:
 2901|   359k|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 2902|   359k|      auto res = s.find_or_prepare_insert(key);
 2903|   359k|      if (res.second) {
  ------------------
  |  Branch (2903:11): [True: 359k, False: 0]
  ------------------
 2904|   359k|        s.emplace_at(res.first, std::forward<Args>(args)...);
 2905|   359k|      }
 2906|   359k|      return res;
 2907|   359k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE22find_or_prepare_insertImEENSt3__14pairINSA_8iteratorEbEERKT_:
 3358|   359k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|   359k|    AssertOnFind(key);
 3360|   359k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 3.58k, False: 356k]
  ------------------
 3361|   356k|    return find_or_prepare_insert_large(key);
 3362|   359k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE28find_or_prepare_insert_smallImEENSt3__14pairINSA_8iteratorEbEERKT_:
 3207|  3.58k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|  3.58k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  3.58k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|  3.58k|    if constexpr (SooEnabled()) {
 3210|  3.58k|      return find_or_prepare_insert_soo(key);
 3211|  3.58k|    }
 3212|  3.58k|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 0, False: 3.58k]
  ------------------
 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|  3.58k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|  3.58k|                common(), GetPolicyFunctions(),
 3220|  3.58k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|  3.58k|            true};
 3222|  3.58k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE26find_or_prepare_insert_sooImEENSt3__14pairINSA_8iteratorEbEERKT_:
 3181|  3.58k|  std::pair<iterator, bool> find_or_prepare_insert_soo(const K& key) {
 3182|  3.58k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|  3.58k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3183|  3.58k|    bool force_sampling;
 3184|  3.58k|    if (empty()) {
  ------------------
  |  Branch (3184:9): [True: 1.79k, False: 1.79k]
  ------------------
 3185|  1.79k|      if (!should_sample_soo()) {
  ------------------
  |  Branch (3185:11): [True: 1.79k, False: 0]
  ------------------
 3186|  1.79k|        common().set_full_soo();
 3187|  1.79k|        return {single_iterator(), true};
 3188|  1.79k|      }
 3189|      0|      force_sampling = true;
 3190|  1.79k|    } else if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3190:16): [True: 0, False: 1.79k]
  ------------------
 3191|      0|      return {single_iterator(), false};
 3192|  1.79k|    } else {
 3193|  1.79k|      force_sampling = false;
 3194|  1.79k|    }
 3195|  1.79k|    ABSL_SWISSTABLE_ASSERT(capacity() == 1);
  ------------------
  |  |  248|  1.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3196|  1.79k|    constexpr bool kUseMemcpy =
 3197|  1.79k|        PolicyTraits::transfer_uses_memcpy() && SooEnabled();
  ------------------
  |  Branch (3197:9): [True: 0, Folded]
  |  Branch (3197:49): [True: 0, Folded]
  ------------------
 3198|  1.79k|    size_t index = GrowSooTableToNextCapacityAndPrepareInsert<
 3199|  1.79k|        kUseMemcpy ? OptimalMemcpySizeForSooSlotTransfer(sizeof(slot_type)) : 0,
 3200|  1.79k|        kUseMemcpy>(common(), GetPolicyFunctions(),
 3201|  1.79k|                    HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key},
 3202|  1.79k|                    force_sampling);
 3203|  1.79k|    return {iterator_at(index), true};
 3204|  3.58k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE17should_sample_sooEv:
 2980|  1.79k|  bool should_sample_soo() const {
 2981|  1.79k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|  1.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2982|  1.79k|    if (!ShouldSampleHashtablezInfoForAlloc<CharAlloc>()) return false;
  ------------------
  |  Branch (2982:9): [Folded, False: 1.79k]
  ------------------
 2983|  1.79k|    return ABSL_PREDICT_FALSE(ShouldSampleNextTable());
  ------------------
  |  |  189|  1.79k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:49): [Folded, False: 1.79k]
  |  |  |  Branch (189:58): [True: 0, False: 1.79k]
  |  |  ------------------
  ------------------
 2984|  1.79k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE18GetPolicyFunctionsEv:
 3558|   358k|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|   358k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|   358k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|   358k|                  "or use absl::node_hash_{map,set}.");
 3562|   358k|    static_assert(alignof(slot_type) <=
 3563|   358k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|   358k|    static_assert(sizeof(key_type) <=
 3565|   358k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|   358k|    static_assert(sizeof(value_type) <=
 3567|   358k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|   358k|    static constexpr size_t kBackingArrayAlignment =
 3569|   358k|        BackingArrayAlignment(alignof(slot_type));
 3570|   358k|    static constexpr PolicyFunctions value = {
 3571|   358k|        static_cast<uint32_t>(sizeof(key_type)),
 3572|   358k|        static_cast<uint32_t>(sizeof(value_type)),
 3573|   358k|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|   358k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|   358k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|   358k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|   358k|                                : &raw_hash_set::get_hash_ref_fn,
 3580|   358k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|   358k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [True: 0, Folded]
  ------------------
 3582|   358k|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|   358k|            : &raw_hash_set::transfer_n_slots_fn,
 3584|   358k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|   358k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|   358k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|   358k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|   358k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|   358k|    return value;
 3590|   358k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSG_PFvSG_hmmE:
 3511|  4.88k|                                    size_t source_offset, size_t h1)) {
 3512|  4.88k|    const size_t new_capacity = common.capacity();
 3513|  4.88k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3514|  4.88k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  270|  4.88k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3515|  4.88k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  270|  4.88k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3516|       |
 3517|  4.88k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3518|  4.88k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3519|  4.88k|    ctrl_t* new_ctrl = common.control();
 3520|  4.88k|    slot_type* new_slots = set->slot_array();
 3521|       |
 3522|  38.4k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3522:34): [True: 33.5k, False: 4.88k]
  ------------------
 3523|  33.5k|         group_index += Group::kWidth) {
 3524|  33.5k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3525|  33.5k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3526|  33.5k|                  Group::kWidth);
 3527|  33.5k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3528|  33.5k|                  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|   468k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3531:38): [True: 468k, False: 33.5k]
  ------------------
 3532|   468k|        size_t old_index = group_index + in_fixed_group_index;
 3533|   468k|        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|   468k|        size_t hash = set->hash_of(old_slot);
 3537|   468k|        size_t h1 = H1(hash);
 3538|   468k|        h2_t h2 = H2(hash);
 3539|   468k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3540|   468k|            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|   468k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  189|   468k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 2.77k, False: 465k]
  |  |  |  Branch (189:49): [Folded, False: 468k]
  |  |  |  Branch (189:58): [True: 2.77k, False: 465k]
  |  |  ------------------
  ------------------
 3544|  2.77k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3545|  2.77k|          continue;
 3546|  2.77k|        }
 3547|   465k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  248|   465k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3548|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  248|   465k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3549|   465k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3550|   465k|        auto* new_slot = new_slots + new_index;
 3551|   465k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3552|   465k|        set->transfer(new_slot, old_slot);
 3553|   465k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3554|   465k|      }
 3555|  33.5k|    }
 3556|  4.88k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7to_slotEPv:
 3073|  6.66k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|  6.66k|    return static_cast<slot_type*>(buf);
 3075|  6.66k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7hash_ofEPNS1_13map_slot_typeImS8_EE:
 3065|   468k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3066|   468k|    return PolicyTraits::apply(
 3067|   468k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3068|   468k|        PolicyTraits::element(slot));
 3069|   468k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8transferEPNS1_13map_slot_typeImS8_EESD_:
 2941|   465k|  inline void transfer(slot_type* to, slot_type* from) {
 2942|   465k|    common().RunWithReentrancyGuard([&] {
 2943|   465k|      allocator_type alloc(char_alloc_ref());
 2944|   465k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   465k|    });
 2946|   465k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8transferEPNS1_13map_slot_typeImSA_EESF_EUlvE_EEvT_:
 1099|   465k|  void RunWithReentrancyGuard(F f) {
 1100|   465k|#ifdef NDEBUG
 1101|   465k|    f();
 1102|   465k|    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_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8transferEPNS1_13map_slot_typeImS8_EESD_ENKUlvE_clEv:
 2942|   465k|    common().RunWithReentrancyGuard([&] {
 2943|   465k|      allocator_type alloc(char_alloc_ref());
 2944|   465k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   465k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8hash_refEv:
 3475|  1.79k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE28find_or_prepare_insert_largeImEENSt3__14pairINSA_8iteratorEbEERKT_:
 3225|   356k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|   356k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   356k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|   356k|    prefetch_heap_block();
 3228|   356k|    const size_t hash = hash_of(key);
 3229|   356k|    auto seq = probe(common(), hash);
 3230|   356k|    const h2_t h2 = H2(hash);
 3231|   356k|    const ctrl_t* ctrl = control();
 3232|   356k|    size_t index;
 3233|   356k|    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|   356k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   356k|      while (true) {
 3238|   356k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   356k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   356k|#endif
 3241|   356k|        Group g{ctrl + seq.offset()};
 3242|   356k|        for (uint32_t i : g.Match(h2)) {
 3243|   356k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|   356k|            index = seq.offset(i);
 3245|   356k|            inserted = false;
 3246|   356k|            common().infoz().RecordInsertHit();
 3247|   356k|            return;
 3248|   356k|          }
 3249|   356k|        }
 3250|   356k|        auto mask_empty = g.MaskEmpty();
 3251|   356k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|   356k|          size_t target_group_offset = seq.offset();
 3253|   356k|          index = SwisstableGenerationsEnabled()
 3254|   356k|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|   356k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|   356k|                            FindInfo{target_group_offset, seq.index()},
 3257|   356k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|   356k|                      : PrepareInsertLarge(
 3259|   356k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   356k|                            FindInfo{target_group_offset, seq.index()});
 3261|   356k|          inserted = true;
 3262|   356k|          return;
 3263|   356k|        }
 3264|   356k|        seq.next();
 3265|   356k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|   356k|      }
 3267|   356k|    }();
 3268|   356k|    return {iterator_at(index), inserted};
 3269|   356k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE28find_or_prepare_insert_largeImEENSt3__14pairINSA_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|   356k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   390k|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 390k, Folded]
  ------------------
 3238|   390k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   390k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   390k|#endif
 3241|   390k|        Group g{ctrl + seq.offset()};
 3242|   390k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 30.5k, False: 390k]
  ------------------
 3243|  30.5k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|  30.5k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 30.5k]
  |  |  |  Branch (190:48): [Folded, False: 30.5k]
  |  |  |  Branch (190:57): [True: 0, False: 30.5k]
  |  |  ------------------
  ------------------
 3244|      0|            index = seq.offset(i);
 3245|      0|            inserted = false;
 3246|      0|            common().infoz().RecordInsertHit();
 3247|      0|            return;
 3248|      0|          }
 3249|  30.5k|        }
 3250|   390k|        auto mask_empty = g.MaskEmpty();
 3251|   390k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|   390k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 356k, False: 34.6k]
  |  |  |  Branch (190:48): [Folded, False: 390k]
  |  |  |  Branch (190:57): [True: 356k, False: 34.6k]
  |  |  ------------------
  ------------------
 3252|   356k|          size_t target_group_offset = seq.offset();
 3253|   356k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 356k]
  ------------------
 3254|   356k|                      ? 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|   356k|                      : PrepareInsertLarge(
 3259|   356k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   356k|                            FindInfo{target_group_offset, seq.index()});
 3261|   356k|          inserted = true;
 3262|   356k|          return;
 3263|   356k|        }
 3264|  34.6k|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  34.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|  34.6k|      }
 3267|   356k|    }();
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE10emplace_atIJRKNSt3__121piecewise_construct_tENSC_5tupleIJRKmEEENSG_IJRKS8_EEEEEEvNSA_8iteratorEDpOT_:
 3373|   359k|  void emplace_at(iterator iter, Args&&... args) {
 3374|   359k|    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|   359k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|   359k|           "constructed value does not match the lookup key");
 3381|   359k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSC_5tupleIJRKmEEENSG_IJRKS8_EEEEEEvPNS1_13map_slot_typeImS8_EEDpOT_:
 2929|   359k|  inline void construct(slot_type* slot, Args&&... args) {
 2930|   359k|    common().RunWithReentrancyGuard([&] {
 2931|   359k|      allocator_type alloc(char_alloc_ref());
 2932|   359k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   359k|    });
 2934|   359k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSE_5tupleIJRKmEEENSI_IJRKSA_EEEEEEvPNS1_13map_slot_typeImSA_EEDpOT_EUlvE_EEvT_:
 1099|   359k|  void RunWithReentrancyGuard(F f) {
 1100|   359k|#ifdef NDEBUG
 1101|   359k|    f();
 1102|   359k|    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_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSC_5tupleIJRKmEEENSG_IJRKS8_EEEEEEvPNS1_13map_slot_typeImS8_EEDpOT_ENKUlvE_clEv:
 2930|   359k|    common().RunWithReentrancyGuard([&] {
 2931|   359k|      allocator_type alloc(char_alloc_ref());
 2932|   359k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   359k|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iterator4slotEv:
 2042|   416k|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE5eraseImEEmRKm:
 2621|  56.8k|  size_type erase(const key_arg<K>& key) {
 2622|  56.8k|    auto it = find(key);
 2623|  56.8k|    if (it == end()) return 0;
  ------------------
  |  Branch (2623:9): [True: 0, False: 56.8k]
  ------------------
 2624|  56.8k|    erase(it);
 2625|  56.8k|    return 1;
 2626|  56.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE5eraseENSA_8iteratorE:
 2636|  56.8k|  void erase(iterator it) {
 2637|       |    ABSL_SWISSTABLE_ASSERT(capacity() > 0);
  ------------------
  |  |  248|  56.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2638|  56.8k|    AssertNotDebugCapacity();
 2639|  56.8k|    it.assert_is_full("erase()");
 2640|  56.8k|    destroy(it.slot());
 2641|  56.8k|    erase_meta_only(it);
 2642|  56.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE15erase_meta_onlyENSA_14const_iteratorE:
 3040|  56.8k|  void erase_meta_only(const_iterator it) {
 3041|  56.8k|    if (is_small()) {
  ------------------
  |  Branch (3041:9): [True: 0, False: 56.8k]
  ------------------
 3042|      0|      erase_meta_only_small();
 3043|      0|      return;
 3044|      0|    }
 3045|  56.8k|    erase_meta_only_large(it);
 3046|  56.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE21erase_meta_only_largeENSA_14const_iteratorE:
 3050|  56.8k|  void erase_meta_only_large(const_iterator it) {
 3051|  56.8k|    EraseMetaOnlyLarge(common(), it.control(), sizeof(slot_type));
 3052|  56.8k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE14const_iterator7controlEv:
 2095|  56.8k|    ctrl_t* control() const { return inner_.control(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iterator7controlEv:
 2041|  56.8k|    ctrl_t* control() const { return ctrl_; }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE14const_iteratorC2ENSA_8iteratorE:
 2069|  56.8k|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE5beginEv:
 2301|  1.78k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2302|  1.78k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  189|  1.78k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 4, False: 1.77k]
  |  |  |  Branch (189:49): [Folded, False: 1.78k]
  |  |  |  Branch (189:58): [True: 4, False: 1.77k]
  |  |  ------------------
  ------------------
 2303|  1.77k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2303:9): [True: 0, False: 1.77k]
  ------------------
 2304|  1.77k|    iterator it = {control(), common().slots_union(),
 2305|  1.77k|                   common().generation_ptr()};
 2306|  1.77k|    it.skip_empty_or_deleted();
 2307|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  248|  1.77k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2308|  1.77k|    return it;
 2309|  1.77k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2005|  1.77k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2006|  1.77k|          ctrl_(ctrl),
 2007|  1.77k|          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.77k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  1.77k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2011|  1.77k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iterator21skip_empty_or_deletedEv:
 2022|   138k|    void skip_empty_or_deleted() {
 2023|   234k|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2023:14): [True: 95.1k, False: 138k]
  ------------------
 2024|  95.1k|        ++ctrl_;
 2025|  95.1k|        ++slot_;
 2026|  95.1k|      }
 2027|   138k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorppEv:
 1964|   137k|    iterator& operator++() {
 1965|   137k|      assert_is_full("operator++");
 1966|   137k|      ++ctrl_;
 1967|   137k|      ++slot_;
 1968|   137k|      skip_empty_or_deleted();
 1969|   137k|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  189|   137k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1.77k, False: 135k]
  |  |  |  Branch (189:49): [Folded, False: 137k]
  |  |  |  Branch (189:58): [True: 1.77k, False: 135k]
  |  |  ------------------
  ------------------
 1970|   137k|      return *this;
 1971|   137k|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratordeEv:
 1952|  4.93M|    reference operator*() const {
 1953|  4.93M|      assert_is_full("operator*()");
 1954|  4.93M|      return unchecked_deref();
 1955|  4.93M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iterator15unchecked_derefEv:
 2039|  4.93M|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE5clearEv:
 2341|  1.81k|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2342|  1.81k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (2342:9): [Folded, False: 1.81k]
  ------------------
 2343|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (2343:9): [True: 0, False: 0]
  ------------------
 2344|      0|      common().set_capacity(DefaultCapacity());
 2345|      0|    }
 2346|  1.81k|    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|  1.81k|    const size_t cap = capacity();
 2355|  1.81k|    if (cap == 0) {
  ------------------
  |  Branch (2355:9): [True: 0, False: 1.81k]
  ------------------
 2356|       |      // Already guaranteed to be empty; so nothing to do.
 2357|  1.81k|    } else if (is_small()) {
  ------------------
  |  Branch (2357:16): [True: 1.81k, False: 0]
  ------------------
 2358|  1.81k|      if (!empty()) {
  ------------------
  |  Branch (2358:11): [True: 0, False: 1.81k]
  ------------------
 2359|      0|        destroy(single_slot());
 2360|      0|        decrement_small_size();
 2361|      0|      }
 2362|  1.81k|    } else {
 2363|      0|      destroy_slots();
 2364|      0|      clear_backing_array(/*reuse=*/cap < 128);
 2365|      0|    }
 2366|  1.81k|    common().set_reserved_growth(0);
 2367|  1.81k|    common().set_reservation_size(0);
 2368|  1.81k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEEC2Ev:
 2109|  1.79k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE6insertEOSA_:
 2434|  56.8k|  {
 2435|  56.8k|    return emplace(std::move(value));
 2436|  56.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7emplaceIJSA_ETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENS4_4pairINSC_8iteratorEbEEDpOSF_:
 2526|  56.8k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2527|  56.8k|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2528|  56.8k|                               std::forward<Args>(args)...);
 2529|  56.8k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE19EmplaceDecomposableclISA_JSA_EEENS4_4pairINSC_8iteratorEbEERKT_DpOT0_:
 2901|  56.8k|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 2902|  56.8k|      auto res = s.find_or_prepare_insert(key);
 2903|  56.8k|      if (res.second) {
  ------------------
  |  Branch (2903:11): [True: 56.8k, False: 0]
  ------------------
 2904|  56.8k|        s.emplace_at(res.first, std::forward<Args>(args)...);
 2905|  56.8k|      }
 2906|  56.8k|      return res;
 2907|  56.8k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE22find_or_prepare_insertISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3358|  56.8k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|  56.8k|    AssertOnFind(key);
 3360|  56.8k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 3.43k, False: 53.4k]
  ------------------
 3361|  53.4k|    return find_or_prepare_insert_large(key);
 3362|  56.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE12AssertOnFindISA_EEvRKT_:
 3279|  56.8k|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|  56.8k|    AssertHashEqConsistent(key);
 3281|  56.8k|    AssertNotDebugCapacity();
 3282|  56.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE22AssertHashEqConsistentISA_EEvRKT_:
 3317|  56.8k|  void AssertHashEqConsistent(const K& key) {
 3318|  56.8k|#ifdef NDEBUG
 3319|  56.8k|    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_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE28find_or_prepare_insert_smallISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3207|  3.43k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|  3.43k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|  3.43k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|       |    if constexpr (SooEnabled()) {
 3210|       |      return find_or_prepare_insert_soo(key);
 3211|       |    }
 3212|  3.43k|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 1.68k, False: 1.75k]
  ------------------
 3213|  1.68k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3213:11): [True: 0, False: 1.68k]
  ------------------
 3214|      0|        common().infoz().RecordInsertHit();
 3215|      0|        return {single_iterator(), false};
 3216|      0|      }
 3217|  1.68k|    }
 3218|  3.43k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|  3.43k|                common(), GetPolicyFunctions(),
 3220|  3.43k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|  3.43k|            true};
 3222|  3.43k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8equal_toISA_EEbRKT_PSA_:
 3056|  5.62k|                                             slot_type* slot) const {
 3057|  5.62k|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|  5.62k|                               PolicyTraits::element(slot));
 3059|  5.62k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE6eq_refEv:
 3478|  5.62k|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8iteratorC2EPNS1_6ctrl_tEPSA_PKh:
 1993|  56.8k|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|  56.8k|          ctrl_(ctrl),
 1995|  56.8k|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|  56.8k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  56.8k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|  56.8k|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3390|  3.43k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3391|  3.43k|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3392|  3.43k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7to_slotEPv:
 3073|  16.3k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|  16.3k|    return static_cast<slot_type*>(buf);
 3075|  16.3k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE18GetPolicyFunctionsEv:
 3558|  56.8k|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|  56.8k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|  56.8k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|  56.8k|                  "or use absl::node_hash_{map,set}.");
 3562|  56.8k|    static_assert(alignof(slot_type) <=
 3563|  56.8k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|  56.8k|    static_assert(sizeof(key_type) <=
 3565|  56.8k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|  56.8k|    static_assert(sizeof(value_type) <=
 3567|  56.8k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|  56.8k|    static constexpr size_t kBackingArrayAlignment =
 3569|  56.8k|        BackingArrayAlignment(alignof(slot_type));
 3570|  56.8k|    static constexpr PolicyFunctions value = {
 3571|  56.8k|        static_cast<uint32_t>(sizeof(key_type)),
 3572|  56.8k|        static_cast<uint32_t>(sizeof(value_type)),
 3573|  56.8k|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|  56.8k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|  56.8k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|  56.8k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|  56.8k|                                : &raw_hash_set::get_hash_ref_fn,
 3580|  56.8k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|  56.8k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [Folded, False: 56.8k]
  ------------------
 3582|  56.8k|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|  56.8k|            : &raw_hash_set::transfer_n_slots_fn,
 3584|  56.8k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|  56.8k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|  56.8k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|  56.8k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|  56.8k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|  56.8k|    return value;
 3590|  56.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE19transfer_n_slots_fnEPvSD_SD_m:
 3494|  5.25k|                                  size_t count) {
 3495|  5.25k|    auto* src_slot = to_slot(src);
 3496|  5.25k|    auto* dst_slot = to_slot(dst);
 3497|       |
 3498|  5.25k|    auto* h = static_cast<raw_hash_set*>(set);
 3499|  22.1k|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3499:12): [True: 16.8k, False: 5.25k]
  ------------------
 3500|  16.8k|      h->transfer(dst_slot, src_slot);
 3501|  16.8k|    }
 3502|  5.25k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8transferEPSA_SD_:
 2941|  77.2k|  inline void transfer(slot_type* to, slot_type* from) {
 2942|  77.2k|    common().RunWithReentrancyGuard([&] {
 2943|  77.2k|      allocator_type alloc(char_alloc_ref());
 2944|  77.2k|      PolicyTraits::transfer(&alloc, to, from);
 2945|  77.2k|    });
 2946|  77.2k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEE8transferEPSC_SF_EUlvE_EEvT_:
 1099|  77.2k|  void RunWithReentrancyGuard(F f) {
 1100|  77.2k|#ifdef NDEBUG
 1101|  77.2k|    f();
 1102|  77.2k|    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_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8transferEPSA_SD_ENKUlvE_clEv:
 2942|  77.2k|    common().RunWithReentrancyGuard([&] {
 2943|  77.2k|      allocator_type alloc(char_alloc_ref());
 2944|  77.2k|      PolicyTraits::transfer(&alloc, to, from);
 2945|  77.2k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3511|  2.42k|                                    size_t source_offset, size_t h1)) {
 3512|  2.42k|    const size_t new_capacity = common.capacity();
 3513|  2.42k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3514|  2.42k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  270|  2.42k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3515|  2.42k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  270|  2.42k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3516|       |
 3517|  2.42k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3518|  2.42k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3519|  2.42k|    ctrl_t* new_ctrl = common.control();
 3520|  2.42k|    slot_type* new_slots = set->slot_array();
 3521|       |
 3522|  6.78k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3522:34): [True: 4.35k, False: 2.42k]
  ------------------
 3523|  4.35k|         group_index += Group::kWidth) {
 3524|  4.35k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3525|  4.35k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3526|  4.35k|                  Group::kWidth);
 3527|  4.35k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3528|  4.35k|                  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|  60.9k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3531:38): [True: 60.9k, False: 4.35k]
  ------------------
 3532|  60.9k|        size_t old_index = group_index + in_fixed_group_index;
 3533|  60.9k|        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|  60.9k|        size_t hash = set->hash_of(old_slot);
 3537|  60.9k|        size_t h1 = H1(hash);
 3538|  60.9k|        h2_t h2 = H2(hash);
 3539|  60.9k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3540|  60.9k|            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|  60.9k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  189|  60.9k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 595, False: 60.4k]
  |  |  |  Branch (189:49): [Folded, False: 60.9k]
  |  |  |  Branch (189:58): [True: 595, False: 60.4k]
  |  |  ------------------
  ------------------
 3544|    595|          encode_probed_element(probed_storage, h2, old_index, h1);
 3545|    595|          continue;
 3546|    595|        }
 3547|  60.4k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  248|  60.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3548|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  248|  60.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3549|  60.4k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3550|  60.4k|        auto* new_slot = new_slots + new_index;
 3551|  60.4k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3552|  60.4k|        set->transfer(new_slot, old_slot);
 3553|  60.4k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3554|  60.4k|      }
 3555|  4.35k|    }
 3556|  2.42k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7hash_ofEPSA_:
 3065|  60.9k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3066|  60.9k|    return PolicyTraits::apply(
 3067|  60.9k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3068|  60.9k|        PolicyTraits::element(slot));
 3069|  60.9k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8hash_refEv:
 3476|   114k|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8hash_refEv:
 3475|  3.43k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3225|  53.4k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|  53.4k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  53.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|  53.4k|    prefetch_heap_block();
 3228|  53.4k|    const size_t hash = hash_of(key);
 3229|  53.4k|    auto seq = probe(common(), hash);
 3230|  53.4k|    const h2_t h2 = H2(hash);
 3231|  53.4k|    const ctrl_t* ctrl = control();
 3232|  53.4k|    size_t index;
 3233|  53.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|  53.4k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|  53.4k|      while (true) {
 3238|  53.4k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|  53.4k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|  53.4k|#endif
 3241|  53.4k|        Group g{ctrl + seq.offset()};
 3242|  53.4k|        for (uint32_t i : g.Match(h2)) {
 3243|  53.4k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|  53.4k|            index = seq.offset(i);
 3245|  53.4k|            inserted = false;
 3246|  53.4k|            common().infoz().RecordInsertHit();
 3247|  53.4k|            return;
 3248|  53.4k|          }
 3249|  53.4k|        }
 3250|  53.4k|        auto mask_empty = g.MaskEmpty();
 3251|  53.4k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|  53.4k|          size_t target_group_offset = seq.offset();
 3253|  53.4k|          index = SwisstableGenerationsEnabled()
 3254|  53.4k|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|  53.4k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|  53.4k|                            FindInfo{target_group_offset, seq.index()},
 3257|  53.4k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|  53.4k|                      : PrepareInsertLarge(
 3259|  53.4k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|  53.4k|                            FindInfo{target_group_offset, seq.index()});
 3261|  53.4k|          inserted = true;
 3262|  53.4k|          return;
 3263|  53.4k|        }
 3264|  53.4k|        seq.next();
 3265|  53.4k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|  53.4k|      }
 3267|  53.4k|    }();
 3268|  53.4k|    return {iterator_at(index), inserted};
 3269|  53.4k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE19prefetch_heap_blockEv:
 3423|  53.4k|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  53.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|  53.4k|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|  53.4k|    __builtin_prefetch(control(), 0, 1);
 3427|  53.4k|#endif
 3428|  53.4k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7hash_ofISA_EEmRKT_:
 3061|  53.4k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|  53.4k|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|  53.4k|                                               common().seed().seed()}(key);
 3064|  53.4k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|  53.4k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|  55.1k|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 55.1k, Folded]
  ------------------
 3238|  55.1k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|  55.1k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|  55.1k|#endif
 3241|  55.1k|        Group g{ctrl + seq.offset()};
 3242|  55.1k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 3.94k, False: 55.1k]
  ------------------
 3243|  3.94k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|  3.94k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 3.94k]
  |  |  |  Branch (190:48): [Folded, False: 3.94k]
  |  |  |  Branch (190:57): [True: 0, False: 3.94k]
  |  |  ------------------
  ------------------
 3244|      0|            index = seq.offset(i);
 3245|      0|            inserted = false;
 3246|      0|            common().infoz().RecordInsertHit();
 3247|      0|            return;
 3248|      0|          }
 3249|  3.94k|        }
 3250|  55.1k|        auto mask_empty = g.MaskEmpty();
 3251|  55.1k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|  55.1k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 53.4k, False: 1.77k]
  |  |  |  Branch (190:48): [Folded, False: 55.1k]
  |  |  |  Branch (190:57): [True: 53.4k, False: 1.77k]
  |  |  ------------------
  ------------------
 3252|  53.4k|          size_t target_group_offset = seq.offset();
 3253|  53.4k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 53.4k]
  ------------------
 3254|  53.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|  53.4k|                      : PrepareInsertLarge(
 3259|  53.4k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|  53.4k|                            FindInfo{target_group_offset, seq.index()});
 3261|  53.4k|          inserted = true;
 3262|  53.4k|          return;
 3263|  53.4k|        }
 3264|  1.77k|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  1.77k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|  1.77k|      }
 3267|  53.4k|    }();
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE11iterator_atEm:
 3383|  53.4k|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|  53.4k|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|  53.4k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE10emplace_atIJSA_EEEvNSC_8iteratorEDpOT_:
 3373|  56.8k|  void emplace_at(iterator iter, Args&&... args) {
 3374|  56.8k|    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|  56.8k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|  56.8k|           "constructed value does not match the lookup key");
 3381|  56.8k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE9constructIJSA_EEEvPSA_DpOT_:
 2929|  56.8k|  inline void construct(slot_type* slot, Args&&... args) {
 2930|  56.8k|    common().RunWithReentrancyGuard([&] {
 2931|  56.8k|      allocator_type alloc(char_alloc_ref());
 2932|  56.8k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|  56.8k|    });
 2934|  56.8k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEE9constructIJSC_EEEvPSC_DpOT_EUlvE_EEvT_:
 1099|  56.8k|  void RunWithReentrancyGuard(F f) {
 1100|  56.8k|#ifdef NDEBUG
 1101|  56.8k|    f();
 1102|  56.8k|    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_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE9constructIJSA_EEEvPSA_DpOT_ENKUlvE_clEv:
 2930|  56.8k|    common().RunWithReentrancyGuard([&] {
 2931|  56.8k|      allocator_type alloc(char_alloc_ref());
 2932|  56.8k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|  56.8k|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8iterator4slotEv:
 2042|  56.8k|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEEC2Ev:
 2109|      1|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE15unchecked_derefENS8_8iteratorE:
 3394|   128k|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iterator15unchecked_derefEv:
 2039|  31.3M|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE22find_or_prepare_insertIjEENSt3__14pairINS8_8iteratorEbEERKT_:
 3358|   128k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|   128k|    AssertOnFind(key);
 3360|   128k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 2, False: 128k]
  ------------------
 3361|   128k|    return find_or_prepare_insert_large(key);
 3362|   128k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE12AssertOnFindIjEEvRKT_:
 3279|  32.7M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|  32.7M|    AssertHashEqConsistent(key);
 3281|  32.7M|    AssertNotDebugCapacity();
 3282|  32.7M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE22AssertHashEqConsistentIjEEvRKT_:
 3317|  32.7M|  void AssertHashEqConsistent(const K& key) {
 3318|  32.7M|#ifdef NDEBUG
 3319|  32.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): [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): [True: 0, Folded]
  ------------------
 3328|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3328:9): [True: 0, Folded]
  ------------------
 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_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE22AssertNotDebugCapacityEv:
 3285|  66.8M|  void AssertNotDebugCapacity() const {
 3286|  66.8M|#ifdef NDEBUG
 3287|  66.8M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 66.8M, Folded]
  ------------------
 3288|  66.8M|      return;
 3289|  66.8M|    }
 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_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8is_smallEv:
 1874|  32.7M|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE6commonEv:
 3431|   258M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE28find_or_prepare_insert_smallIjEENSt3__14pairINS8_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|      2|    if constexpr (SooEnabled()) {
 3210|      2|      return find_or_prepare_insert_soo(key);
 3211|      2|    }
 3212|      2|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 0, False: 2]
  ------------------
 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|      2|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|      2|                common(), GetPolicyFunctions(),
 3220|      2|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|      2|            true};
 3222|      2|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE26find_or_prepare_insert_sooIjEENSt3__14pairINS8_8iteratorEbEERKT_:
 3181|      2|  std::pair<iterator, bool> find_or_prepare_insert_soo(const K& key) {
 3182|      2|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3183|      2|    bool force_sampling;
 3184|      2|    if (empty()) {
  ------------------
  |  Branch (3184:9): [True: 1, False: 1]
  ------------------
 3185|      1|      if (!should_sample_soo()) {
  ------------------
  |  Branch (3185:11): [True: 1, False: 0]
  ------------------
 3186|      1|        common().set_full_soo();
 3187|      1|        return {single_iterator(), true};
 3188|      1|      }
 3189|      0|      force_sampling = true;
 3190|      1|    } else if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3190:16): [True: 0, False: 1]
  ------------------
 3191|      0|      return {single_iterator(), false};
 3192|      1|    } else {
 3193|      1|      force_sampling = false;
 3194|      1|    }
 3195|      1|    ABSL_SWISSTABLE_ASSERT(capacity() == 1);
  ------------------
  |  |  248|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3196|      1|    constexpr bool kUseMemcpy =
 3197|      1|        PolicyTraits::transfer_uses_memcpy() && SooEnabled();
  ------------------
  |  Branch (3197:9): [True: 0, Folded]
  |  Branch (3197:49): [True: 0, Folded]
  ------------------
 3198|      1|    size_t index = GrowSooTableToNextCapacityAndPrepareInsert<
 3199|      1|        kUseMemcpy ? OptimalMemcpySizeForSooSlotTransfer(sizeof(slot_type)) : 0,
 3200|      1|        kUseMemcpy>(common(), GetPolicyFunctions(),
 3201|      1|                    HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key},
 3202|      1|                    force_sampling);
 3203|      1|    return {iterator_at(index), true};
 3204|      2|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE5emptyEv:
 2326|      2|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE4sizeEv:
 2327|      2|  size_t size() const {
 2328|      2|    AssertNotDebugCapacity();
 2329|      2|    return common().size();
 2330|      2|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE17should_sample_sooEv:
 2980|      1|  bool should_sample_soo() const {
 2981|      1|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2982|      1|    if (!ShouldSampleHashtablezInfoForAlloc<CharAlloc>()) return false;
  ------------------
  |  Branch (2982:9): [Folded, False: 1]
  ------------------
 2983|      1|    return ABSL_PREDICT_FALSE(ShouldSampleNextTable());
  ------------------
  |  |  189|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:49): [Folded, False: 1]
  |  |  |  Branch (189:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2984|      1|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE6commonEv:
 3430|  98.6M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE15single_iteratorEv:
 3464|      1|  iterator single_iterator() {
 3465|      1|    return {SooControl(), single_slot(), common().generation_ptr()};
 3466|      1|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIjS6_EEPKh:
 1993|  31.3M|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|  31.3M|          ctrl_(ctrl),
 1995|  31.3M|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|  31.3M|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|  31.3M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|  31.3M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8equal_toIjEEbRKT_PNS1_13map_slot_typeIjS6_EE:
 3056|  31.3M|                                             slot_type* slot) const {
 3057|  31.3M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|  31.3M|                               PolicyTraits::element(slot));
 3059|  31.3M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE6eq_refEv:
 3478|  31.3M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE11single_slotEv:
 3450|      2|  slot_type* single_slot() {
 3451|      2|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|      2|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [True: 2, Folded]
  ------------------
 3453|      2|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8soo_slotEv:
 3441|      2|  slot_type* soo_slot() {
 3442|      2|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  248|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3443|      2|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(
  ------------------
  |  |  488|      2|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 3444|      2|        static_cast<slot_type*>(common().soo_data()));
 3445|      2|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE18GetPolicyFunctionsEv:
 3558|   128k|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|   128k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|   128k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|   128k|                  "or use absl::node_hash_{map,set}.");
 3562|   128k|    static_assert(alignof(slot_type) <=
 3563|   128k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|   128k|    static_assert(sizeof(key_type) <=
 3565|   128k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|   128k|    static_assert(sizeof(value_type) <=
 3567|   128k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|   128k|    static constexpr size_t kBackingArrayAlignment =
 3569|   128k|        BackingArrayAlignment(alignof(slot_type));
 3570|   128k|    static constexpr PolicyFunctions value = {
 3571|   128k|        static_cast<uint32_t>(sizeof(key_type)),
 3572|   128k|        static_cast<uint32_t>(sizeof(value_type)),
 3573|   128k|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|   128k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|   128k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|   128k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|   128k|                                : &raw_hash_set::get_hash_ref_fn,
 3580|   128k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|   128k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [True: 0, Folded]
  ------------------
 3582|   128k|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|   128k|            : &raw_hash_set::transfer_n_slots_fn,
 3584|   128k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|   128k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|   128k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|   128k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|   128k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|   128k|    return value;
 3590|   128k|  }
_ZN4absl12lts_2026010718container_internal20TransferNRelocatableILm8EEEvPvS3_S3_m:
 1722|     14|                                                  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|     14|  memcpy(dst, src, SizeOfSlot * count);
 1726|     14|}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSE_PFvSE_hmmE:
 3511|     14|                                    size_t source_offset, size_t h1)) {
 3512|     14|    const size_t new_capacity = common.capacity();
 3513|     14|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3514|     14|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  270|     14|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3515|     14|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  270|     14|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3516|       |
 3517|     14|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3518|     14|    slot_type* old_slots_ptr = to_slot(old_slots);
 3519|     14|    ctrl_t* new_ctrl = common.control();
 3520|     14|    slot_type* new_slots = set->slot_array();
 3521|       |
 3522|  16.3k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3522:34): [True: 16.3k, False: 14]
  ------------------
 3523|  16.3k|         group_index += Group::kWidth) {
 3524|  16.3k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3525|  16.3k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3526|  16.3k|                  Group::kWidth);
 3527|  16.3k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3528|  16.3k|                  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|   229k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3531:38): [True: 229k, False: 16.3k]
  ------------------
 3532|   229k|        size_t old_index = group_index + in_fixed_group_index;
 3533|   229k|        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|   229k|        size_t hash = set->hash_of(old_slot);
 3537|   229k|        size_t h1 = H1(hash);
 3538|   229k|        h2_t h2 = H2(hash);
 3539|   229k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3540|   229k|            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|   229k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  189|   229k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 12, False: 229k]
  |  |  |  Branch (189:49): [Folded, False: 229k]
  |  |  |  Branch (189:58): [True: 12, False: 229k]
  |  |  ------------------
  ------------------
 3544|     12|          encode_probed_element(probed_storage, h2, old_index, h1);
 3545|     12|          continue;
 3546|     12|        }
 3547|   229k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  248|   229k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3548|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  248|   229k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3549|   229k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3550|   229k|        auto* new_slot = new_slots + new_index;
 3551|   229k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3552|   229k|        set->transfer(new_slot, old_slot);
 3553|   229k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3554|   229k|      }
 3555|  16.3k|    }
 3556|     14|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE7to_slotEPv:
 3073|     14|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|     14|    return static_cast<slot_type*>(buf);
 3075|     14|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE10slot_arrayEv:
 3437|  95.5M|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  95.5M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|  95.5M|    return static_cast<slot_type*>(common().slot_array());
 3440|  95.5M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE7hash_ofEPNS1_13map_slot_typeIjS6_EE:
 3065|   229k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3066|   229k|    return PolicyTraits::apply(
 3067|   229k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3068|   229k|        PolicyTraits::element(slot));
 3069|   229k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8hash_refEv:
 3476|  33.0M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8transferEPNS1_13map_slot_typeIjS6_EESB_:
 2941|   229k|  inline void transfer(slot_type* to, slot_type* from) {
 2942|   229k|    common().RunWithReentrancyGuard([&] {
 2943|   229k|      allocator_type alloc(char_alloc_ref());
 2944|   229k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   229k|    });
 2946|   229k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8transferEPNS1_13map_slot_typeIjS8_EESD_EUlvE_EEvT_:
 1099|   229k|  void RunWithReentrancyGuard(F f) {
 1100|   229k|#ifdef NDEBUG
 1101|   229k|    f();
 1102|   229k|    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_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8transferEPNS1_13map_slot_typeIjS6_EESB_ENKUlvE_clEv:
 2942|   229k|    common().RunWithReentrancyGuard([&] {
 2943|   229k|      allocator_type alloc(char_alloc_ref());
 2944|   229k|      PolicyTraits::transfer(&alloc, to, from);
 2945|   229k|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE14char_alloc_refEv:
 3479|   357k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8hash_refEv:
 3475|      1|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE11iterator_atEm:
 3383|  31.3M|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|  31.3M|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|  31.3M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE7controlEv:
 3433|  96.9M|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  96.9M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|  96.9M|    return common().control();
 3436|  96.9M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE28find_or_prepare_insert_largeIjEENSt3__14pairINS8_8iteratorEbEERKT_:
 3225|   128k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|   128k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|   128k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|   128k|    prefetch_heap_block();
 3228|   128k|    const size_t hash = hash_of(key);
 3229|   128k|    auto seq = probe(common(), hash);
 3230|   128k|    const h2_t h2 = H2(hash);
 3231|   128k|    const ctrl_t* ctrl = control();
 3232|   128k|    size_t index;
 3233|   128k|    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|   128k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   128k|      while (true) {
 3238|   128k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   128k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   128k|#endif
 3241|   128k|        Group g{ctrl + seq.offset()};
 3242|   128k|        for (uint32_t i : g.Match(h2)) {
 3243|   128k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|   128k|            index = seq.offset(i);
 3245|   128k|            inserted = false;
 3246|   128k|            common().infoz().RecordInsertHit();
 3247|   128k|            return;
 3248|   128k|          }
 3249|   128k|        }
 3250|   128k|        auto mask_empty = g.MaskEmpty();
 3251|   128k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|   128k|          size_t target_group_offset = seq.offset();
 3253|   128k|          index = SwisstableGenerationsEnabled()
 3254|   128k|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|   128k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|   128k|                            FindInfo{target_group_offset, seq.index()},
 3257|   128k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|   128k|                      : PrepareInsertLarge(
 3259|   128k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   128k|                            FindInfo{target_group_offset, seq.index()});
 3261|   128k|          inserted = true;
 3262|   128k|          return;
 3263|   128k|        }
 3264|   128k|        seq.next();
 3265|   128k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|   128k|      }
 3267|   128k|    }();
 3268|   128k|    return {iterator_at(index), inserted};
 3269|   128k|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE19prefetch_heap_blockEv:
 3423|  32.7M|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  32.7M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|  32.7M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|  32.7M|    __builtin_prefetch(control(), 0, 1);
 3427|  32.7M|#endif
 3428|  32.7M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE7hash_ofIjEEmRKT_:
 3061|  32.7M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|  32.7M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|  32.7M|                                               common().seed().seed()}(key);
 3064|  32.7M|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE28find_or_prepare_insert_largeIjEENSt3__14pairINS8_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|   128k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|   137k|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 137k, Folded]
  ------------------
 3238|   137k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|   137k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|   137k|#endif
 3241|   137k|        Group g{ctrl + seq.offset()};
 3242|   137k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 11.6k, False: 137k]
  ------------------
 3243|  11.6k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|  11.6k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 11.6k]
  |  |  |  Branch (190:48): [Folded, False: 11.6k]
  |  |  |  Branch (190:57): [True: 0, False: 11.6k]
  |  |  ------------------
  ------------------
 3244|      0|            index = seq.offset(i);
 3245|      0|            inserted = false;
 3246|      0|            common().infoz().RecordInsertHit();
 3247|      0|            return;
 3248|      0|          }
 3249|  11.6k|        }
 3250|   137k|        auto mask_empty = g.MaskEmpty();
 3251|   137k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|   137k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 128k, False: 9.58k]
  |  |  |  Branch (190:48): [Folded, False: 137k]
  |  |  |  Branch (190:57): [True: 128k, False: 9.58k]
  |  |  ------------------
  ------------------
 3252|   128k|          size_t target_group_offset = seq.offset();
 3253|   128k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 128k]
  ------------------
 3254|   128k|                      ? 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|   128k|                      : PrepareInsertLarge(
 3259|   128k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|   128k|                            FindInfo{target_group_offset, seq.index()});
 3261|   128k|          inserted = true;
 3262|   128k|          return;
 3263|   128k|        }
 3264|  9.58k|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|  9.58k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|  9.58k|      }
 3267|   128k|    }();
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE10emplace_atIJRKNSt3__121piecewise_construct_tENSA_5tupleIJRKjEEENSE_IJEEEEEEvNS8_8iteratorEDpOT_:
 3373|   127k|  void emplace_at(iterator iter, Args&&... args) {
 3374|   127k|    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|   127k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|   127k|           "constructed value does not match the lookup key");
 3381|   127k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSA_5tupleIJRKjEEENSE_IJEEEEEEvPNS1_13map_slot_typeIjS6_EEDpOT_:
 2929|   127k|  inline void construct(slot_type* slot, Args&&... args) {
 2930|   127k|    common().RunWithReentrancyGuard([&] {
 2931|   127k|      allocator_type alloc(char_alloc_ref());
 2932|   127k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   127k|    });
 2934|   127k|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSC_5tupleIJRKjEEENSG_IJEEEEEEvPNS1_13map_slot_typeIjS8_EEDpOT_EUlvE_EEvT_:
 1099|   127k|  void RunWithReentrancyGuard(F f) {
 1100|   127k|#ifdef NDEBUG
 1101|   127k|    f();
 1102|   127k|    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_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSA_5tupleIJRKjEEENSE_IJEEEEEEvPNS1_13map_slot_typeIjS6_EEDpOT_ENKUlvE_clEv:
 2930|   127k|    common().RunWithReentrancyGuard([&] {
 2931|   127k|      allocator_type alloc(char_alloc_ref());
 2932|   127k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|   127k|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iterator4slotEv:
 2042|   128k|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE10emplace_atIJRKNSt3__121piecewise_construct_tENSA_5tupleIJOjEEENSE_IJEEEEEEvNS8_8iteratorEDpOT_:
 3373|    697|  void emplace_at(iterator iter, Args&&... args) {
 3374|    697|    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|    697|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|    697|           "constructed value does not match the lookup key");
 3381|    697|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSA_5tupleIJOjEEENSE_IJEEEEEEvPNS1_13map_slot_typeIjS6_EEDpOT_:
 2929|    697|  inline void construct(slot_type* slot, Args&&... args) {
 2930|    697|    common().RunWithReentrancyGuard([&] {
 2931|    697|      allocator_type alloc(char_alloc_ref());
 2932|    697|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|    697|    });
 2934|    697|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSC_5tupleIJOjEEENSG_IJEEEEEEvPNS1_13map_slot_typeIjS8_EEDpOT_EUlvE_EEvT_:
 1099|    697|  void RunWithReentrancyGuard(F f) {
 1100|    697|#ifdef NDEBUG
 1101|    697|    f();
 1102|    697|    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_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSA_5tupleIJOjEEENSE_IJEEEEEEvPNS1_13map_slot_typeIjS6_EEDpOT_ENKUlvE_clEv:
 2930|    697|    common().RunWithReentrancyGuard([&] {
 2931|    697|      allocator_type alloc(char_alloc_ref());
 2932|    697|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|    697|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEED2Ev:
 2294|      1|  ~raw_hash_set() {
 2295|      1|    destructor_impl();
 2296|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2297|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 2298|       |    }
 2299|      1|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE15destructor_implEv:
 3019|      1|  void destructor_impl() {
 3020|      1|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3020:9): [Folded, False: 1]
  ------------------
 3021|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (3021:9): [True: 0, False: 0]
  ------------------
 3022|      0|      return;
 3023|      0|    }
 3024|      1|    if (capacity() == 0) return;
  ------------------
  |  Branch (3024:9): [True: 0, False: 1]
  ------------------
 3025|      1|    if (is_small()) {
  ------------------
  |  Branch (3025:9): [True: 0, False: 1]
  ------------------
 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|      1|    } else {
 3031|      1|      destroy_slots();
 3032|      1|    }
 3033|      0|    dealloc();
 3034|      1|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8capacityEv:
 2331|      3|  size_t capacity() const {
 2332|      3|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|      3|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|      3|        DefaultCapacity();
 2336|      3|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|      3|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|      3|    return cap;
 2338|      3|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE13destroy_slotsEv:
 2992|      1|  void destroy_slots() {
 2993|      1|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2994|      1|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (2994:9): [True: 1, 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_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE7deallocEv:
 3008|      1|  void dealloc() {
 3009|      1|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3010|       |    // Unpoison before returning the memory to the allocator.
 3011|      1|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3012|      1|    infoz().Unregister();
 3013|      1|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3014|      1|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3015|      1|                                      sizeof(slot_type), alignof(slot_type),
 3016|      1|                                      common().has_infoz());
 3017|      1|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE5infozEv:
 3470|      1|  HashtablezInfoHandle infoz() {
 3471|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3472|      1|    return common().infoz();
 3473|      1|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE4findIjEENS8_14const_iteratorERKj:
 2803|  32.6M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2804|  32.6M|    return const_cast<raw_hash_set*>(this)->find(key);
 2805|  32.6M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE4findIjEENS8_8iteratorERKj:
 2788|  32.6M|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2789|  32.6M|    AssertOnFind(key);
 2790|  32.6M|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (2790:9): [True: 0, False: 32.6M]
  ------------------
 2791|  32.6M|    prefetch_heap_block();
 2792|  32.6M|    return find_large(key, hash_of(key));
 2793|  32.6M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE3endEv:
 2310|  34.0M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|  34.0M|    AssertNotDebugCapacity();
 2312|  34.0M|    return iterator(common().generation_ptr());
 2313|  34.0M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iteratorC2EPKh:
 2014|  34.0M|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE10find_largeIjEENS8_8iteratorERKjm:
 2957|  32.6M|  iterator find_large(const key_arg<K>& key, size_t hash) {
 2958|  32.6M|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|  32.6M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2959|  32.6M|    auto seq = probe(common(), hash);
 2960|  32.6M|    const h2_t h2 = H2(hash);
 2961|  32.6M|    const ctrl_t* ctrl = control();
 2962|  32.6M|    while (true) {
  ------------------
  |  Branch (2962:12): [True: 32.6M, Folded]
  ------------------
 2963|  32.6M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 2964|  32.6M|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 2965|  32.6M|#endif
 2966|  32.6M|      Group g{ctrl + seq.offset()};
 2967|  32.6M|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (2967:23): [True: 31.3M, False: 1.40M]
  ------------------
 2968|  31.3M|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  190|  31.3M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 31.2M, False: 129k]
  |  |  |  Branch (190:48): [Folded, False: 31.3M]
  |  |  |  Branch (190:57): [True: 31.2M, False: 129k]
  |  |  ------------------
  ------------------
 2969|  31.2M|          return iterator_at(seq.offset(i));
 2970|  31.3M|      }
 2971|  1.40M|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  190|  1.40M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 1.40M, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 1.40M]
  |  |  |  Branch (190:57): [True: 1.40M, 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|  32.6M|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE14const_iteratorC2ENS8_8iteratorE:
 2069|  65.3M|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE14const_iteratorESB_:
 2083|  32.6M|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2084|  32.6M|      return !(a == b);
 2085|  32.6M|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE14const_iteratorESB_:
 2080|  32.6M|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2081|  32.6M|      return a.inner_ == b.inner_;
 2082|  32.6M|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iteratorESB_:
 1979|  32.6M|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|  32.6M|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|  32.6M|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|  32.6M|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|  32.6M|                          a.generation_ptr(), b.generation_ptr());
 1984|  32.6M|      return a.ctrl_ == b.ctrl_;
 1985|  32.6M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE3endEv:
 2318|  32.6M|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2319|  32.6M|    return const_cast<raw_hash_set*>(this)->end();
 2320|  32.6M|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE14const_iteratorptEv:
 2072|  31.2M|    pointer operator->() const { return inner_.operator->(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iteratorptEv:
 1958|  31.2M|    pointer operator->() const {
 1959|  31.2M|      assert_is_full("operator->");
 1960|  31.2M|      return &operator*();
 1961|  31.2M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iterator14assert_is_fullEPKc:
 2016|  62.4M|    void assert_is_full(const char* operation) const {
 2017|  62.4M|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|  62.4M|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyIjN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iteratordeEv:
 1952|  31.2M|    reference operator*() const {
 1953|  31.2M|      assert_is_full("operator*()");
 1954|  31.2M|      return unchecked_deref();
 1955|  31.2M|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5clearEv:
 2341|  52.3k|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2342|  52.3k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (2342:9): [Folded, False: 52.3k]
  ------------------
 2343|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (2343:9): [True: 0, False: 0]
  ------------------
 2344|      0|      common().set_capacity(DefaultCapacity());
 2345|      0|    }
 2346|  52.3k|    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|  52.3k|    const size_t cap = capacity();
 2355|  52.3k|    if (cap == 0) {
  ------------------
  |  Branch (2355:9): [True: 52.3k, False: 0]
  ------------------
 2356|       |      // Already guaranteed to be empty; so nothing to do.
 2357|  52.3k|    } else if (is_small()) {
  ------------------
  |  Branch (2357:16): [True: 0, False: 0]
  ------------------
 2358|      0|      if (!empty()) {
  ------------------
  |  Branch (2358:11): [True: 0, False: 0]
  ------------------
 2359|      0|        destroy(single_slot());
 2360|      0|        decrement_small_size();
 2361|      0|      }
 2362|      0|    } else {
 2363|      0|      destroy_slots();
 2364|      0|      clear_backing_array(/*reuse=*/cap < 128);
 2365|      0|    }
 2366|  52.3k|    common().set_reserved_growth(0);
 2367|  52.3k|    common().set_reservation_size(0);
 2368|  52.3k|  }

_ZN4absl12lts_20260107eqERKNS0_12AnyInvocableIFvvEEEDn:
  303|   111k|  friend bool operator==(const AnyInvocable& f, std::nullptr_t) noexcept {
  304|   111k|    return !f.HasValue();
  305|   111k|  }
_ZN4absl12lts_2026010712AnyInvocableIFvvEEC2EOS3_:
  187|   111k|  AnyInvocable(AnyInvocable&& /*f*/) noexcept = default;
_ZN4absl12lts_2026010712AnyInvocableIFvvEEC2Ev:
  181|   111k|  AnyInvocable() noexcept = default;
_ZN4absl12lts_2026010712AnyInvocableIFvvEEaSEOS3_:
  237|   111k|  AnyInvocable& operator=(AnyInvocable&& /*f*/) noexcept = default;
_ZN4absl12lts_2026010712AnyInvocableIFvvEEC2EDn:
  182|  55.6k|  AnyInvocable(std::nullptr_t) noexcept {}  // NOLINT
trainer_interface.cc:_ZN4absl12lts_2026010712AnyInvocableIFvvEEC2IZN13sentencepiece16TrainerInterface13LoadSentencesEvE3$_0vEEOT_:
  197|  10.1k|      : Impl(internal_any_invocable::ConversionConstruct(),
  198|  10.1k|             std::forward<F>(f)) {}
unigram_model_trainer.cc:_ZN4absl12lts_2026010712AnyInvocableIFvvEEC2IZNK13sentencepiece7unigram7Trainer8RunEStepERKNS6_12TrainerModelEPfPlE3$_0vEEOT_:
  197|  34.9k|      : Impl(internal_any_invocable::ConversionConstruct(),
  198|  34.9k|             std::forward<F>(f)) {}
unigram_model_trainer.cc:_ZN4absl12lts_2026010712AnyInvocableIFvvEEC2IZNK13sentencepiece7unigram7Trainer19PruneSentencePiecesERKNS6_12TrainerModelEE3$_0vEEOT_:
  197|  10.6k|      : Impl(internal_any_invocable::ConversionConstruct(),
  198|  10.6k|             std::forward<F>(f)) {}

_ZN4absl12lts_2026010711FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEElEEJEE13destroy_slotsEvEUlS5_S6_E_vEEOT_:
  112|  21.7k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026010711FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEElEEJEE13destroy_slotsEvEUlS5_S6_E_EENSC_10in_place_tEOT_:
  100|  21.7k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  21.7k|    absl::functional_internal::AssertNonNull(f);
  102|  21.7k|    ptr_.obj = &f;
  103|  21.7k|  }
_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS0_13hash_internal4HashIjEEjLb1EEEvEEOT_:
  112|  30.1k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS0_13hash_internal4HashIjEEjLb1EEEEENSt3__110in_place_tEOT_:
  100|  30.1k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  30.1k|    absl::functional_internal::AssertNonNull(f);
  102|  30.1k|    ptr_.obj = &f;
  103|  30.1k|  }
_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEELb1EEEvEEOT_:
  112|  15.3k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEELb1EEEEENS8_10in_place_tEOT_:
  100|  15.3k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  15.3k|    absl::functional_internal::AssertNonNull(f);
  102|  15.3k|    ptr_.obj = &f;
  103|  15.3k|  }
_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEELb1EEEvEEOT_:
  112|  42.7k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEELb1EEEEENS8_10in_place_tEOT_:
  100|  42.7k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  42.7k|    absl::functional_internal::AssertNonNull(f);
  102|  42.7k|    ptr_.obj = &f;
  103|  42.7k|  }
_ZN4absl12lts_2026010711FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEfEEJEE13destroy_slotsEvEUlS5_S6_E_vEEOT_:
  112|  13.4k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026010711FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEfEEJEE13destroy_slotsEvEUlS5_S6_E_EENSC_10in_place_tEOT_:
  100|  13.4k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  13.4k|    absl::functional_internal::AssertNonNull(f);
  102|  13.4k|    ptr_.obj = &f;
  103|  13.4k|  }
_ZN4absl12lts_2026010711FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEmEEJEE13destroy_slotsEvEUlS5_S6_E_vEEOT_:
  112|  1.11k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026010711FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEmEEJEE13destroy_slotsEvEUlS5_S6_E_EENSC_10in_place_tEOT_:
  100|  1.11k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  1.11k|    absl::functional_internal::AssertNonNull(f);
  102|  1.11k|    ptr_.obj = &f;
  103|  1.11k|  }
_ZN4absl12lts_2026010711FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashSetPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJEE13destroy_slotsEvEUlS5_S6_E_vEEOT_:
  112|  1.68k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026010711FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashSetPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJEE13destroy_slotsEvEUlS5_S6_E_EENSC_10in_place_tEOT_:
  100|  1.68k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  1.68k|    absl::functional_internal::AssertNonNull(f);
  102|  1.68k|    ptr_.obj = &f;
  103|  1.68k|  }
_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEEvEEOT_:
  112|  1.79k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026010711FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEEEENSt3__110in_place_tEOT_:
  100|  1.79k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  1.79k|    absl::functional_internal::AssertNonNull(f);
  102|  1.79k|    ptr_.obj = &f;
  103|  1.79k|  }

_ZN4absl12lts_2026010722internal_any_invocable14TrivialDeleterC2Em:
  376|  55.6k|  explicit TrivialDeleter(std::size_t size) : size_(size) {}
_ZN4absl12lts_2026010722internal_any_invocable12EmptyManagerENS1_14FunctionToCallEPNS1_15TypeErasedStateES4_:
  213|   501k|                         TypeErasedState* /*to*/) noexcept {}
_ZN4absl12lts_2026010722internal_any_invocable20RemoteManagerTrivialENS1_14FunctionToCallEPNS1_15TypeErasedStateES4_:
  286|   167k|                                 TypeErasedState* const to) noexcept {
  287|   167k|  switch (operation) {
  ------------------
  |  Branch (287:11): [True: 167k, False: 0]
  ------------------
  288|   111k|    case FunctionToCall::relocate_from_to:
  ------------------
  |  Branch (288:5): [True: 111k, False: 55.6k]
  ------------------
  289|   111k|    case FunctionToCall::relocate_from_to_and_query_rust:
  ------------------
  |  Branch (289:5): [True: 0, False: 167k]
  ------------------
  290|       |      // NOTE: Requires that the left-hand operand is already empty.
  291|   111k|      to->remote = from->remote;
  292|   111k|      return;
  293|  55.6k|    case FunctionToCall::dispose:
  ------------------
  |  Branch (293:5): [True: 55.6k, False: 111k]
  ------------------
  294|  55.6k|#if defined(__cpp_sized_deallocation)
  295|  55.6k|      ::operator delete(from->remote.target, from->remote.size);
  296|       |#else   // __cpp_sized_deallocation
  297|       |      ::operator delete(from->remote.target);
  298|       |#endif  // __cpp_sized_deallocation
  299|  55.6k|      return;
  300|   167k|  }
  301|      0|  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]
  |  |  ------------------
  ------------------
  302|      0|}
_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEEaSEOS3_:
  479|   111k|  CoreImpl& operator=(CoreImpl&& other) noexcept {
  480|       |    // Put the left-hand operand in an empty state.
  481|       |    //
  482|       |    // Note: A full reset that leaves us with an object that has its invariants
  483|       |    // intact is necessary in order to handle self-move. This is required by
  484|       |    // types that are used with certain operations of the standard library, such
  485|       |    // as the default definition of std::swap when both operands target the same
  486|       |    // object.
  487|   111k|    Clear();
  488|       |
  489|       |    // Perform the actual move/destroy operation on the target function.
  490|   111k|    other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
  491|   111k|    manager_ = other.manager_;
  492|   111k|    invoker_ = other.invoker_;
  493|   111k|    other.manager_ = EmptyManager;
  494|   111k|    other.invoker_ = nullptr;
  495|       |
  496|   111k|    return *this;
  497|   111k|  }
_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEE5ClearEv:
  505|   111k|  void Clear() {
  506|   111k|    manager_(FunctionToCall::dispose, &state_, &state_);
  507|   111k|    manager_ = EmptyManager;
  508|   111k|    invoker_ = nullptr;
  509|   111k|  }
_ZNK4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEE8HasValueEv:
  502|   111k|  bool HasValue() const { return invoker_ != nullptr; }
_ZN4absl12lts_2026010722internal_any_invocable4ImplIFvvEE14ExtractInvokerEv:
  736|  55.6k|    InvokerType<noex, ReturnType, P...>* ExtractInvoker() cv {                 \
  737|  55.6k|      using QualifiedTestType = int cv ref;                                    \
  738|  55.6k|      auto* invoker = this->invoker_;                                          \
  739|  55.6k|      if (!std::is_const<QualifiedTestType>::value &&                          \
  ------------------
  |  Branch (739:11): [True: 0, Folded]
  ------------------
  740|  55.6k|          std::is_rvalue_reference<QualifiedTestType>::value) {                \
  ------------------
  |  Branch (740:11): [Folded, False: 0]
  ------------------
  741|      0|        ABSL_ASSERT([this]() {                                                 \
  ------------------
  |  |  106|      0|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  ------------------
  |  |  |  Branch (106:28): [Folded, False: 0]
  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  742|      0|          /* We checked that this isn't const above, so const_cast is safe */  \
  743|      0|          const_cast<Impl*>(this)->invoker_ = InvokedAfterMove;                \
  744|      0|          return this->HasValue();                                             \
  745|      0|        }());                                                                  \
  746|      0|      }                                                                        \
  747|  55.6k|      return invoker;                                                          \
  748|  55.6k|    }                                                                          \
_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEEC2EOS3_:
  471|   111k|  CoreImpl(CoreImpl&& other) noexcept {
  472|   111k|    other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
  473|   111k|    manager_ = other.manager_;
  474|   111k|    invoker_ = other.invoker_;
  475|   111k|    other.manager_ = EmptyManager;
  476|   111k|    other.invoker_ = nullptr;
  477|   111k|  }
_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEED2Ev:
  499|   334k|  ~CoreImpl() { manager_(FunctionToCall::dispose, &state_, &state_); }
_ZN4absl12lts_2026010722internal_any_invocable4ImplIFvvEEC2Ev:
  712|   167k|    Impl() = default;                                                          \
_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEEC2Ev:
  411|   167k|  CoreImpl() noexcept : manager_(EmptyManager), invoker_(nullptr) {}
trainer_interface.cc:_ZN4absl12lts_2026010722internal_any_invocable4ImplIFvvEEC2IZN13sentencepiece16TrainerInterface13LoadSentencesEvE3$_0EENS1_19ConversionConstructEOT_:
  719|  10.1k|        : Core(TypedConversionConstruct<                                       \
  720|  10.1k|                   typename std::decay<F>::type inv_quals>(),                  \
  721|  10.1k|               std::forward<F>(f)) {}                                          \
trainer_interface.cc:_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEEC2IRZN13sentencepiece16TrainerInterface13LoadSentencesEvE3$_0S7_EENS1_24TypedConversionConstructIT_EEOT0_:
  417|  10.1k|  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
  418|  10.1k|    using DecayedT = RemoveCVRef<QualDecayedTRef>;
  419|       |
  420|       |    if constexpr (std::is_pointer<DecayedT>::value ||
  421|       |                  std::is_member_pointer<DecayedT>::value) {
  422|       |      // This condition handles types that decay into pointers. This includes
  423|       |      // function references, which cannot be null. GCC warns against comparing
  424|       |      // their decayed form with nullptr (https://godbolt.org/z/9r9TMTcPK).
  425|       |      // We could work around this warning with constexpr programming, using
  426|       |      // std::is_function_v<std::remove_reference_t<F>>, but we choose to ignore
  427|       |      // it instead of writing more code.
  428|       |#if !defined(__clang__) && defined(__GNUC__)
  429|       |#pragma GCC diagnostic push
  430|       |#pragma GCC diagnostic ignored "-Wpragmas"
  431|       |#pragma GCC diagnostic ignored "-Waddress"
  432|       |#pragma GCC diagnostic ignored "-Wnonnull-compare"
  433|       |#endif
  434|       |      if (static_cast<DecayedT>(f) == nullptr) {
  435|       |#if !defined(__clang__) && defined(__GNUC__)
  436|       |#pragma GCC diagnostic pop
  437|       |#endif
  438|       |        manager_ = EmptyManager;
  439|       |        invoker_ = nullptr;
  440|       |      } else {
  441|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  442|       |      }
  443|       |    } else if constexpr (IsCompatibleAnyInvocable<DecayedT>::value) {
  444|       |      // In this case we can "steal the guts" of the other AnyInvocable.
  445|       |      f.manager_(FunctionToCall::relocate_from_to, &f.state_, &state_);
  446|       |      manager_ = f.manager_;
  447|       |      invoker_ = f.invoker_;
  448|       |
  449|       |      f.manager_ = EmptyManager;
  450|       |      f.invoker_ = nullptr;
  451|       |    } else if constexpr (IsAnyInvocable<DecayedT>::value) {
  452|       |      if (f.HasValue()) {
  453|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  454|       |      } else {
  455|       |        manager_ = EmptyManager;
  456|       |        invoker_ = nullptr;
  457|       |      }
  458|  10.1k|    } else {
  459|  10.1k|      InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  460|  10.1k|    }
  461|  10.1k|  }
trainer_interface.cc:_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEE17InitializeStorageIRZN13sentencepiece16TrainerInterface13LoadSentencesEvE3$_0JS7_EEEvDpOT0_:
  513|  10.1k|  void InitializeStorage(Args&&... args) {
  514|  10.1k|    using RawT = RemoveCVRef<QualTRef>;
  515|       |    if constexpr (IsStoredLocally<RawT>()) {
  516|       |      ::new (static_cast<void*>(&state_.storage))
  517|       |          RawT(std::forward<Args>(args)...);
  518|       |      invoker_ = LocalInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  519|       |      // We can simplify our manager if we know the type is trivially copyable.
  520|       |      if constexpr (std::is_trivially_copyable_v<RawT>) {
  521|       |        manager_ = LocalManagerTrivial;
  522|       |      } else {
  523|       |        manager_ = LocalManagerNontrivial<RawT>;
  524|       |      }
  525|  10.1k|    } else {
  526|  10.1k|      InitializeRemoteManager<RawT>(std::forward<Args>(args)...);
  527|       |      // This is set after everything else in case an exception is thrown in an
  528|       |      // earlier step of the initialization.
  529|  10.1k|      invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  530|  10.1k|    }
  531|  10.1k|  }
trainer_interface.cc:_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEE23InitializeRemoteManagerIZN13sentencepiece16TrainerInterface13LoadSentencesEvE3$_0JS7_EEEvDpOT0_:
  534|  10.1k|  void InitializeRemoteManager(Args&&... args) {
  535|       |    if constexpr (std::is_trivially_destructible_v<T> &&
  536|  10.1k|                  alignof(T) <= ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT) {
  537|       |      // unique_ptr is used for exception-safety in case construction throws.
  538|  10.1k|      std::unique_ptr<void, TrivialDeleter> uninitialized_target(
  539|  10.1k|          ::operator new(sizeof(T)), TrivialDeleter(sizeof(T)));
  540|  10.1k|      ::new (uninitialized_target.get()) T(std::forward<Args>(args)...);
  541|  10.1k|      state_.remote.target = uninitialized_target.release();
  542|  10.1k|      state_.remote.size = sizeof(T);
  543|  10.1k|      manager_ = RemoteManagerTrivial;
  544|       |    } else {
  545|       |      state_.remote.target = ::new T(std::forward<Args>(args)...);
  546|       |      manager_ = RemoteManagerNontrivial<T>;
  547|       |    }
  548|  10.1k|  }
trainer_interface.cc:_ZN4absl12lts_2026010722internal_any_invocable13RemoteInvokerILb0EvRZN13sentencepiece16TrainerInterface13LoadSentencesEvE3$_0JEEET0_PNS1_15TypeErasedStateEDpNS1_18ForwardedParameterIT2_E4typeE:
  331|  10.1k|    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
  332|  10.1k|  using RawT = RemoveCVRef<QualTRef>;
  333|  10.1k|  static_assert(!IsStoredLocally<RawT>(),
  334|  10.1k|                "Target object must be in remote storage in order to be "
  335|  10.1k|                "invoked from it.");
  336|       |
  337|  10.1k|  auto& f = *static_cast<RawT*>(state->remote.target);
  338|  10.1k|  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
  339|  10.1k|                               static_cast<ForwardedParameterType<P>>(args)...);
  340|  10.1k|}
trainer_interface.cc:_ZN4absl12lts_2026010722internal_any_invocable7InvokeRIvRZN13sentencepiece16TrainerInterface13LoadSentencesEvE3$_0JEEET_OT0_DpOT1_:
  119|  10.1k|ReturnType InvokeR(F&& f, P&&... args) {
  120|  10.1k|  if constexpr (std::is_void_v<ReturnType>) {
  121|  10.1k|    std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  122|       |  } else {
  123|       |    return std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  124|       |  }
  125|  10.1k|}
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable4ImplIFvvEEC2IZNK13sentencepiece7unigram7Trainer8RunEStepERKNS7_12TrainerModelEPfPlE3$_0EENS1_19ConversionConstructEOT_:
  719|  34.9k|        : Core(TypedConversionConstruct<                                       \
  720|  34.9k|                   typename std::decay<F>::type inv_quals>(),                  \
  721|  34.9k|               std::forward<F>(f)) {}                                          \
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEEC2IRZNK13sentencepiece7unigram7Trainer8RunEStepERKNS6_12TrainerModelEPfPlE3$_0SD_EENS1_24TypedConversionConstructIT_EEOT0_:
  417|  34.9k|  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
  418|  34.9k|    using DecayedT = RemoveCVRef<QualDecayedTRef>;
  419|       |
  420|       |    if constexpr (std::is_pointer<DecayedT>::value ||
  421|       |                  std::is_member_pointer<DecayedT>::value) {
  422|       |      // This condition handles types that decay into pointers. This includes
  423|       |      // function references, which cannot be null. GCC warns against comparing
  424|       |      // their decayed form with nullptr (https://godbolt.org/z/9r9TMTcPK).
  425|       |      // We could work around this warning with constexpr programming, using
  426|       |      // std::is_function_v<std::remove_reference_t<F>>, but we choose to ignore
  427|       |      // it instead of writing more code.
  428|       |#if !defined(__clang__) && defined(__GNUC__)
  429|       |#pragma GCC diagnostic push
  430|       |#pragma GCC diagnostic ignored "-Wpragmas"
  431|       |#pragma GCC diagnostic ignored "-Waddress"
  432|       |#pragma GCC diagnostic ignored "-Wnonnull-compare"
  433|       |#endif
  434|       |      if (static_cast<DecayedT>(f) == nullptr) {
  435|       |#if !defined(__clang__) && defined(__GNUC__)
  436|       |#pragma GCC diagnostic pop
  437|       |#endif
  438|       |        manager_ = EmptyManager;
  439|       |        invoker_ = nullptr;
  440|       |      } else {
  441|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  442|       |      }
  443|       |    } else if constexpr (IsCompatibleAnyInvocable<DecayedT>::value) {
  444|       |      // In this case we can "steal the guts" of the other AnyInvocable.
  445|       |      f.manager_(FunctionToCall::relocate_from_to, &f.state_, &state_);
  446|       |      manager_ = f.manager_;
  447|       |      invoker_ = f.invoker_;
  448|       |
  449|       |      f.manager_ = EmptyManager;
  450|       |      f.invoker_ = nullptr;
  451|       |    } else if constexpr (IsAnyInvocable<DecayedT>::value) {
  452|       |      if (f.HasValue()) {
  453|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  454|       |      } else {
  455|       |        manager_ = EmptyManager;
  456|       |        invoker_ = nullptr;
  457|       |      }
  458|  34.9k|    } else {
  459|  34.9k|      InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  460|  34.9k|    }
  461|  34.9k|  }
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEE17InitializeStorageIRZNK13sentencepiece7unigram7Trainer8RunEStepERKNS6_12TrainerModelEPfPlE3$_0JSD_EEEvDpOT0_:
  513|  34.9k|  void InitializeStorage(Args&&... args) {
  514|  34.9k|    using RawT = RemoveCVRef<QualTRef>;
  515|       |    if constexpr (IsStoredLocally<RawT>()) {
  516|       |      ::new (static_cast<void*>(&state_.storage))
  517|       |          RawT(std::forward<Args>(args)...);
  518|       |      invoker_ = LocalInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  519|       |      // We can simplify our manager if we know the type is trivially copyable.
  520|       |      if constexpr (std::is_trivially_copyable_v<RawT>) {
  521|       |        manager_ = LocalManagerTrivial;
  522|       |      } else {
  523|       |        manager_ = LocalManagerNontrivial<RawT>;
  524|       |      }
  525|  34.9k|    } else {
  526|  34.9k|      InitializeRemoteManager<RawT>(std::forward<Args>(args)...);
  527|       |      // This is set after everything else in case an exception is thrown in an
  528|       |      // earlier step of the initialization.
  529|  34.9k|      invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  530|  34.9k|    }
  531|  34.9k|  }
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEE23InitializeRemoteManagerIZNK13sentencepiece7unigram7Trainer8RunEStepERKNS6_12TrainerModelEPfPlE3$_0JSD_EEEvDpOT0_:
  534|  34.9k|  void InitializeRemoteManager(Args&&... args) {
  535|       |    if constexpr (std::is_trivially_destructible_v<T> &&
  536|  34.9k|                  alignof(T) <= ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT) {
  537|       |      // unique_ptr is used for exception-safety in case construction throws.
  538|  34.9k|      std::unique_ptr<void, TrivialDeleter> uninitialized_target(
  539|  34.9k|          ::operator new(sizeof(T)), TrivialDeleter(sizeof(T)));
  540|  34.9k|      ::new (uninitialized_target.get()) T(std::forward<Args>(args)...);
  541|  34.9k|      state_.remote.target = uninitialized_target.release();
  542|  34.9k|      state_.remote.size = sizeof(T);
  543|  34.9k|      manager_ = RemoteManagerTrivial;
  544|       |    } else {
  545|       |      state_.remote.target = ::new T(std::forward<Args>(args)...);
  546|       |      manager_ = RemoteManagerNontrivial<T>;
  547|       |    }
  548|  34.9k|  }
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable13RemoteInvokerILb0EvRZNK13sentencepiece7unigram7Trainer8RunEStepERKNS4_12TrainerModelEPfPlE3$_0JEEET0_PNS1_15TypeErasedStateEDpNS1_18ForwardedParameterIT2_E4typeE:
  331|  34.9k|    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
  332|  34.9k|  using RawT = RemoveCVRef<QualTRef>;
  333|  34.9k|  static_assert(!IsStoredLocally<RawT>(),
  334|  34.9k|                "Target object must be in remote storage in order to be "
  335|  34.9k|                "invoked from it.");
  336|       |
  337|  34.9k|  auto& f = *static_cast<RawT*>(state->remote.target);
  338|  34.9k|  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
  339|  34.9k|                               static_cast<ForwardedParameterType<P>>(args)...);
  340|  34.9k|}
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable7InvokeRIvRZNK13sentencepiece7unigram7Trainer8RunEStepERKNS4_12TrainerModelEPfPlE3$_0JEEET_OT0_DpOT1_:
  119|  34.9k|ReturnType InvokeR(F&& f, P&&... args) {
  120|  34.9k|  if constexpr (std::is_void_v<ReturnType>) {
  121|  34.9k|    std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  122|       |  } else {
  123|       |    return std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  124|       |  }
  125|  34.9k|}
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable4ImplIFvvEEC2IZNK13sentencepiece7unigram7Trainer19PruneSentencePiecesERKNS7_12TrainerModelEE3$_0EENS1_19ConversionConstructEOT_:
  719|  10.6k|        : Core(TypedConversionConstruct<                                       \
  720|  10.6k|                   typename std::decay<F>::type inv_quals>(),                  \
  721|  10.6k|               std::forward<F>(f)) {}                                          \
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEEC2IRZNK13sentencepiece7unigram7Trainer19PruneSentencePiecesERKNS6_12TrainerModelEE3$_0SB_EENS1_24TypedConversionConstructIT_EEOT0_:
  417|  10.6k|  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
  418|  10.6k|    using DecayedT = RemoveCVRef<QualDecayedTRef>;
  419|       |
  420|       |    if constexpr (std::is_pointer<DecayedT>::value ||
  421|       |                  std::is_member_pointer<DecayedT>::value) {
  422|       |      // This condition handles types that decay into pointers. This includes
  423|       |      // function references, which cannot be null. GCC warns against comparing
  424|       |      // their decayed form with nullptr (https://godbolt.org/z/9r9TMTcPK).
  425|       |      // We could work around this warning with constexpr programming, using
  426|       |      // std::is_function_v<std::remove_reference_t<F>>, but we choose to ignore
  427|       |      // it instead of writing more code.
  428|       |#if !defined(__clang__) && defined(__GNUC__)
  429|       |#pragma GCC diagnostic push
  430|       |#pragma GCC diagnostic ignored "-Wpragmas"
  431|       |#pragma GCC diagnostic ignored "-Waddress"
  432|       |#pragma GCC diagnostic ignored "-Wnonnull-compare"
  433|       |#endif
  434|       |      if (static_cast<DecayedT>(f) == nullptr) {
  435|       |#if !defined(__clang__) && defined(__GNUC__)
  436|       |#pragma GCC diagnostic pop
  437|       |#endif
  438|       |        manager_ = EmptyManager;
  439|       |        invoker_ = nullptr;
  440|       |      } else {
  441|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  442|       |      }
  443|       |    } else if constexpr (IsCompatibleAnyInvocable<DecayedT>::value) {
  444|       |      // In this case we can "steal the guts" of the other AnyInvocable.
  445|       |      f.manager_(FunctionToCall::relocate_from_to, &f.state_, &state_);
  446|       |      manager_ = f.manager_;
  447|       |      invoker_ = f.invoker_;
  448|       |
  449|       |      f.manager_ = EmptyManager;
  450|       |      f.invoker_ = nullptr;
  451|       |    } else if constexpr (IsAnyInvocable<DecayedT>::value) {
  452|       |      if (f.HasValue()) {
  453|       |        InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  454|       |      } else {
  455|       |        manager_ = EmptyManager;
  456|       |        invoker_ = nullptr;
  457|       |      }
  458|  10.6k|    } else {
  459|  10.6k|      InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  460|  10.6k|    }
  461|  10.6k|  }
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEE17InitializeStorageIRZNK13sentencepiece7unigram7Trainer19PruneSentencePiecesERKNS6_12TrainerModelEE3$_0JSB_EEEvDpOT0_:
  513|  10.6k|  void InitializeStorage(Args&&... args) {
  514|  10.6k|    using RawT = RemoveCVRef<QualTRef>;
  515|       |    if constexpr (IsStoredLocally<RawT>()) {
  516|       |      ::new (static_cast<void*>(&state_.storage))
  517|       |          RawT(std::forward<Args>(args)...);
  518|       |      invoker_ = LocalInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  519|       |      // We can simplify our manager if we know the type is trivially copyable.
  520|       |      if constexpr (std::is_trivially_copyable_v<RawT>) {
  521|       |        manager_ = LocalManagerTrivial;
  522|       |      } else {
  523|       |        manager_ = LocalManagerNontrivial<RawT>;
  524|       |      }
  525|  10.6k|    } else {
  526|  10.6k|      InitializeRemoteManager<RawT>(std::forward<Args>(args)...);
  527|       |      // This is set after everything else in case an exception is thrown in an
  528|       |      // earlier step of the initialization.
  529|  10.6k|      invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  530|  10.6k|    }
  531|  10.6k|  }
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable8CoreImplILb0EvJEE23InitializeRemoteManagerIZNK13sentencepiece7unigram7Trainer19PruneSentencePiecesERKNS6_12TrainerModelEE3$_0JSB_EEEvDpOT0_:
  534|  10.6k|  void InitializeRemoteManager(Args&&... args) {
  535|       |    if constexpr (std::is_trivially_destructible_v<T> &&
  536|  10.6k|                  alignof(T) <= ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT) {
  537|       |      // unique_ptr is used for exception-safety in case construction throws.
  538|  10.6k|      std::unique_ptr<void, TrivialDeleter> uninitialized_target(
  539|  10.6k|          ::operator new(sizeof(T)), TrivialDeleter(sizeof(T)));
  540|  10.6k|      ::new (uninitialized_target.get()) T(std::forward<Args>(args)...);
  541|  10.6k|      state_.remote.target = uninitialized_target.release();
  542|  10.6k|      state_.remote.size = sizeof(T);
  543|  10.6k|      manager_ = RemoteManagerTrivial;
  544|       |    } else {
  545|       |      state_.remote.target = ::new T(std::forward<Args>(args)...);
  546|       |      manager_ = RemoteManagerNontrivial<T>;
  547|       |    }
  548|  10.6k|  }
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable13RemoteInvokerILb0EvRZNK13sentencepiece7unigram7Trainer19PruneSentencePiecesERKNS4_12TrainerModelEE3$_0JEEET0_PNS1_15TypeErasedStateEDpNS1_18ForwardedParameterIT2_E4typeE:
  331|  10.6k|    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
  332|  10.6k|  using RawT = RemoveCVRef<QualTRef>;
  333|  10.6k|  static_assert(!IsStoredLocally<RawT>(),
  334|  10.6k|                "Target object must be in remote storage in order to be "
  335|  10.6k|                "invoked from it.");
  336|       |
  337|  10.6k|  auto& f = *static_cast<RawT*>(state->remote.target);
  338|  10.6k|  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
  339|  10.6k|                               static_cast<ForwardedParameterType<P>>(args)...);
  340|  10.6k|}
unigram_model_trainer.cc:_ZN4absl12lts_2026010722internal_any_invocable7InvokeRIvRZNK13sentencepiece7unigram7Trainer19PruneSentencePiecesERKNS4_12TrainerModelEE3$_0JEEET_OT0_DpOT1_:
  119|  10.6k|ReturnType InvokeR(F&& f, P&&... args) {
  120|  10.6k|  if constexpr (std::is_void_v<ReturnType>) {
  121|  10.6k|    std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  122|       |  } else {
  123|       |    return std::invoke(std::forward<F>(f), std::forward<P>(args)...);
  124|       |  }
  125|  10.6k|}

_ZN4absl12lts_2026010719functional_internal12InvokeObjectIRZNS0_18container_internal12raw_hash_setINS3_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_vJSH_SI_EEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|  2.13M|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|  2.13M|  using T = std::remove_reference_t<Obj>;
   76|  2.13M|  return static_cast<R>(std::invoke(
   77|  2.13M|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|  2.13M|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|  2.13M|}
_ZN4absl12lts_2026010719functional_internal13AssertNonNullIZNS0_18container_internal12raw_hash_setINS3_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_EEvRKT_:
  136|  21.7k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026010719functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS0_13hash_internal4HashIjEEjLb1EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|  20.0k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|  20.0k|  using T = std::remove_reference_t<Obj>;
   76|  20.0k|  return static_cast<R>(std::invoke(
   77|  20.0k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|  20.0k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|  20.0k|}
_ZN4absl12lts_2026010719functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS0_13hash_internal4HashIjEEjLb1EEEEEvRKT_:
  136|  30.1k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026010719functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS3_10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEELb1EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|  6.57k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|  6.57k|  using T = std::remove_reference_t<Obj>;
   76|  6.57k|  return static_cast<R>(std::invoke(
   77|  6.57k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|  6.57k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|  6.57k|}
_ZN4absl12lts_2026010719functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS3_10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEELb1EEEEEvRKT_:
  136|  15.3k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026010719functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS3_10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEELb1EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|  21.0k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|  21.0k|  using T = std::remove_reference_t<Obj>;
   76|  21.0k|  return static_cast<R>(std::invoke(
   77|  21.0k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|  21.0k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|  21.0k|}
_ZN4absl12lts_2026010719functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS3_10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEELb1EEEEEvRKT_:
  136|  42.7k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026010719functional_internal12InvokeObjectIRZNS0_18container_internal12raw_hash_setINS3_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_vJSH_SI_EEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|   505k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|   505k|  using T = std::remove_reference_t<Obj>;
   76|   505k|  return static_cast<R>(std::invoke(
   77|   505k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|   505k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|   505k|}
_ZN4absl12lts_2026010719functional_internal13AssertNonNullIZNS0_18container_internal12raw_hash_setINS3_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_EEvRKT_:
  136|  13.4k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026010719functional_internal12InvokeObjectIRZNS0_18container_internal12raw_hash_setINS3_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEmEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_vJSH_SI_EEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|   103k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|   103k|  using T = std::remove_reference_t<Obj>;
   76|   103k|  return static_cast<R>(std::invoke(
   77|   103k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|   103k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|   103k|}
_ZN4absl12lts_2026010719functional_internal13AssertNonNullIZNS0_18container_internal12raw_hash_setINS3_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEmEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_EEvRKT_:
  136|  1.11k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026010719functional_internal12InvokeObjectIRZNS0_18container_internal12raw_hash_setINS3_17FlatHashSetPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_vJSH_SI_EEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|  56.7k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|  56.7k|  using T = std::remove_reference_t<Obj>;
   76|  56.7k|  return static_cast<R>(std::invoke(
   77|  56.7k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|  56.7k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|  56.7k|}
_ZN4absl12lts_2026010719functional_internal13AssertNonNullIZNS0_18container_internal12raw_hash_setINS3_17FlatHashSetPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_EEvRKT_:
  136|  1.68k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026010719functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|  1.79k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|  1.79k|  using T = std::remove_reference_t<Obj>;
   76|  1.79k|  return static_cast<R>(std::invoke(
   77|  1.79k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|  1.79k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|  1.79k|}
_ZN4absl12lts_2026010719functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEEEEvRKT_:
  136|  1.79k|void AssertNonNull(const F&) {}

_ZN4absl12lts_202601076HashOfITpTnRiJEJmmEEEmDpRKT0_:
  273|  4.00M|size_t HashOf(const Types&... values) {
  274|  4.00M|  auto tuple = std::tie(values...);
  275|  4.00M|  return absl::Hash<decltype(tuple)>{}(tuple);
  276|  4.00M|}

_ZN4absl12lts_2026010713hash_internal15MixingHashState18combine_contiguousES2_PKhm:
 1343|  19.3M|                                            size_t size) {
 1344|  19.3M|    return MixingHashState(
 1345|  19.3M|        CombineContiguousImpl(hash_state.state_, first, size,
 1346|  19.3M|                              std::integral_constant<int, sizeof(size_t)>{}));
 1347|  19.3M|  }
_ZN4absl12lts_2026010713hash_internal15MixingHashStateC2Em:
 1394|  50.6M|  explicit MixingHashState(uint64_t state) : state_(state) {}
_ZN4absl12lts_2026010713hash_internal15MixingHashState11combine_rawES2_m:
 1400|  8.01M|                                     uint64_t value) {
 1401|  8.01M|    return MixingHashState(CombineRawImpl(hash_state.state_, value));
 1402|  8.01M|  }
_ZN4absl12lts_2026010713hash_internal15MixingHashState4SeedEv:
 1446|  4.00M|  ABSL_ATTRIBUTE_ALWAYS_INLINE static size_t Seed() {
 1447|  4.00M|#if (!defined(__clang__) || __clang_major__ > 11) && \
 1448|  4.00M|    (!defined(__apple_build_version__) ||            \
 1449|  4.00M|     __apple_build_version__ >= 19558921)  // Xcode 12
 1450|  4.00M|    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|  4.00M|  }
_ZN4absl12lts_2026010713hash_internal19PrecombineLengthMixEmm:
  989|  18.9M|inline uint64_t PrecombineLengthMix(uint64_t state, size_t len) {
  990|  18.9M|  ABSL_ASSUME(len + sizeof(uint64_t) <= sizeof(kStaticRandomData));
  ------------------
  |  |  270|  18.9M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  991|  18.9M|  uint64_t data = absl::base_internal::UnalignedLoad64(
  992|  18.9M|      reinterpret_cast<const unsigned char*>(&kStaticRandomData[0]) + len);
  993|  18.9M|  return state ^ data;
  994|  18.9M|}
_ZN4absl12lts_2026010713hash_internal3MixEmm:
  996|  91.0M|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|  91.0M|  absl::uint128 m = lhs;
 1000|  91.0M|  m *= rhs;
 1001|  91.0M|  return Uint128High64(m) ^ Uint128Low64(m);
 1002|  91.0M|}
_ZN4absl12lts_2026010713hash_internal5Read8EPKh:
 1012|  11.1M|inline uint64_t Read8(const unsigned char* p) {
 1013|  11.1M|  return absl::base_internal::UnalignedLoad64(p);
 1014|  11.1M|}
_ZN4absl12lts_2026010713hash_internal9Read9To16EPKhm:
 1023|  2.79M|                                               size_t len) {
 1024|  2.79M|  return {Read8(p), Read8(p + len - 8)};
 1025|  2.79M|}
_ZN4absl12lts_2026010713hash_internal8Read4To8EPKhm:
 1029|  5.46M|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|  5.46M|  uint64_t most_significant =
 1042|  5.46M|      static_cast<uint64_t>(absl::base_internal::UnalignedLoad32(p)) << 32;
 1043|  5.46M|  uint64_t least_significant =
 1044|  5.46M|      absl::base_internal::UnalignedLoad32(p + len - 4);
 1045|  5.46M|  return most_significant | least_significant;
 1046|  5.46M|}
_ZN4absl12lts_2026010713hash_internal8Read1To3EPKhm:
 1049|  9.29M|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|  9.29M|  uint32_t mem0 = (static_cast<uint32_t>(p[0]) << 16) | p[len - 1];
 1059|  9.29M|  uint32_t mem1 = static_cast<uint32_t>(p[len / 2]) << 8;
 1060|  9.29M|  return mem0 | mem1;
 1061|  9.29M|}
_ZN4absl12lts_2026010713hash_internal14CombineRawImplEmm:
 1064|  83.2M|                                                            uint64_t value) {
 1065|  83.2M|  return Mix(state ^ value, kMul);
 1066|  83.2M|}
_ZN4absl12lts_2026010713hash_internal26CombineSmallContiguousImplEmPKhm:
 1079|  14.7M|    uint64_t state, const unsigned char* first, size_t len) {
 1080|  14.7M|  ABSL_ASSUME(len <= 8);
  ------------------
  |  |  270|  14.7M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1081|  14.7M|  uint64_t v;
 1082|  14.7M|  if (len >= 4) {
  ------------------
  |  Branch (1082:7): [True: 5.46M, False: 9.29M]
  ------------------
 1083|  5.46M|    v = Read4To8(first, len);
 1084|  9.29M|  } else if (len > 0) {
  ------------------
  |  Branch (1084:14): [True: 9.29M, False: 0]
  ------------------
 1085|  9.29M|    v = Read1To3(first, len);
 1086|  9.29M|  } else {
 1087|       |    // Empty string must modify the state.
 1088|      0|    v = 0x57;
 1089|      0|  }
 1090|  14.7M|  return CombineRawImpl(state, v);
 1091|  14.7M|}
_ZN4absl12lts_2026010713hash_internal26CombineContiguousImpl9to16EmPKhm:
 1094|  2.79M|    uint64_t state, const unsigned char* first, size_t len) {
 1095|  2.79M|  ABSL_ASSUME(len >= 9);
  ------------------
  |  |  270|  2.79M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1096|  2.79M|  ABSL_ASSUME(len <= 16);
  ------------------
  |  |  270|  2.79M|#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|  2.79M|  auto p = Read9To16(first, len);
 1103|  2.79M|  return Mix(state ^ p.first, kMul ^ p.second);
 1104|  2.79M|}
_ZN4absl12lts_2026010713hash_internal27CombineContiguousImpl17to32EmPKhm:
 1107|  1.38M|    uint64_t state, const unsigned char* first, size_t len) {
 1108|  1.38M|  ABSL_ASSUME(len >= 17);
  ------------------
  |  |  270|  1.38M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1109|  1.38M|  ABSL_ASSUME(len <= 32);
  ------------------
  |  |  270|  1.38M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1110|       |  // Do two mixes of overlapping 16-byte ranges in parallel to minimize
 1111|       |  // latency.
 1112|  1.38M|  const uint64_t m0 =
 1113|  1.38M|      Mix(Read8(first) ^ kStaticRandomData[1], Read8(first + 8) ^ state);
 1114|       |
 1115|  1.38M|  const unsigned char* tail_16b_ptr = first + (len - 16);
 1116|  1.38M|  const uint64_t m1 = Mix(Read8(tail_16b_ptr) ^ kStaticRandomData[3],
 1117|  1.38M|                          Read8(tail_16b_ptr + 8) ^ state);
 1118|  1.38M|  return m0 ^ m1;
 1119|  1.38M|}
_ZN4absl12lts_2026010713hash_internal21CombineContiguousImplEmPKhmNSt3__117integral_constantIiLi8EEE:
 1203|  19.3M|    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|  19.3M|  if (len <= 8) {
  ------------------
  |  Branch (1206:7): [True: 14.7M, False: 4.54M]
  ------------------
 1207|  14.7M|    return CombineSmallContiguousImpl(PrecombineLengthMix(state, len), first,
 1208|  14.7M|                                      len);
 1209|  14.7M|  }
 1210|  4.54M|  if (len <= 16) {
  ------------------
  |  Branch (1210:7): [True: 2.79M, False: 1.74M]
  ------------------
 1211|  2.79M|    return CombineContiguousImpl9to16(PrecombineLengthMix(state, len), first,
 1212|  2.79M|                                      len);
 1213|  2.79M|  }
 1214|  1.74M|  if (len <= 32) {
  ------------------
  |  Branch (1214:7): [True: 1.38M, False: 361k]
  ------------------
 1215|  1.38M|    return CombineContiguousImpl17to32(PrecombineLengthMix(state, len), first,
 1216|  1.38M|                                       len);
 1217|  1.38M|  }
 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|   361k|  return CombineLargeContiguousImplOn64BitLengthGt32(state, first, len);
 1222|  1.74M|}
_ZN4absl12lts_2026010713hash_internal15MixingHashState14hash_with_seedINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETnNS4_9enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSA_m:
 1367|  19.3M|  static size_t hash_with_seed(const T& value, size_t seed) {
 1368|  19.3M|    return static_cast<size_t>(combine(MixingHashState{seed}, value).state_);
 1369|  19.3M|  }
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEES3_S3_RKT_DpRKT0_:
 1492|  19.3M|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1493|  19.3M|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1494|  19.3M|                        std::move(state), value),
 1495|  19.3M|                    values...);
 1496|  19.3M|}
_ZN4absl12lts_2026010713hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEENS6_9enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESC_E4typeESC_RKT0_:
 1270|  19.3M|        H> {
 1271|  19.3M|      return AbslHashValue(std::move(state), value);
 1272|  19.3M|    }
_ZN4absl12lts_2026010713hash_internal13AbslHashValueINS1_15MixingHashStateEEET_S4_NSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  645|  19.3M|H AbslHashValue(H hash_state, absl::string_view str) {
  646|  19.3M|  return H::combine_contiguous(std::move(hash_state), str.data(), str.size());
  647|  19.3M|}
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE18combine_contiguousIcEES3_S3_PKT_m:
 1500|  19.3M|H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
 1501|  19.3M|  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
 1502|  19.3M|}
_ZN4absl12lts_2026010713hash_internal19hash_range_or_bytesINS1_15MixingHashStateEcEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES7_PKS6_m:
  962|  19.3M|hash_range_or_bytes(H hash_state, const T* data, size_t size) {
  963|  19.3M|  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
  964|  19.3M|  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
  965|  19.3M|}
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineES3_:
  283|  27.3M|  static H combine(H state) { return state; }
_ZNK4absl12lts_2026010713hash_internal12HashWithSeed4hashINS1_4HashINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEES9_EEmRKT_RKT0_m:
  396|  19.3M|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  397|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  398|  19.3M|    return hasher.hash_with_seed(value, seed);
  399|  19.3M|  }
_ZNK4absl12lts_2026010713hash_internal8HashImplINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE14hash_with_seedERKS7_m:
 1481|  19.3M|  size_t hash_with_seed(const T& value, size_t seed) const {
 1482|  19.3M|    return MixingHashState::hash_with_seed(value, seed);
 1483|  19.3M|  }
_ZNK4absl12lts_2026010713hash_internal12HashWithSeed4hashINS1_4HashIjEEjEEmRKT_RKT0_m:
  396|  54.1M|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  397|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  398|  54.1M|    return hasher.hash_with_seed(value, seed);
  399|  54.1M|  }
_ZNK4absl12lts_2026010713hash_internal8HashImplIjE14hash_with_seedERKjm:
 1481|  54.1M|  size_t hash_with_seed(const T& value, size_t seed) const {
 1482|  54.1M|    return MixingHashState::hash_with_seed(value, seed);
 1483|  54.1M|  }
_ZN4absl12lts_2026010713hash_internal15MixingHashState14hash_with_seedIjTnNSt3__19enable_ifIXsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmS6_m:
 1361|  54.1M|  static size_t hash_with_seed(T value, size_t seed) {
 1362|  54.1M|    return static_cast<size_t>(
 1363|  54.1M|        CombineRawImpl(seed, static_cast<std::make_unsigned_t<T>>(value)));
 1364|  54.1M|  }
_ZNK4absl12lts_2026010713hash_internal12HashWithSeed4hashINS0_18container_internal10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEmRKT_RKT0_m:
  396|  18.8M|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  397|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  398|  18.8M|    return hasher.hash_with_seed(value, seed);
  399|  18.8M|  }
_ZNK4absl12lts_2026010713hash_internal12HashWithSeed4hashINS0_18container_internal10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEmRKT_RKT0_m:
  396|   430k|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  397|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  398|   430k|    return hasher.hash_with_seed(value, seed);
  399|   430k|  }
_ZNK4absl12lts_2026010713hash_internal12HashWithSeed4hashINS1_4HashImEEmEEmRKT_RKT0_m:
  396|  6.27M|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  397|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  398|  6.27M|    return hasher.hash_with_seed(value, seed);
  399|  6.27M|  }
_ZNK4absl12lts_2026010713hash_internal8HashImplImE14hash_with_seedERKmm:
 1481|  6.27M|  size_t hash_with_seed(const T& value, size_t seed) const {
 1482|  6.27M|    return MixingHashState::hash_with_seed(value, seed);
 1483|  6.27M|  }
_ZN4absl12lts_2026010713hash_internal15MixingHashState14hash_with_seedImTnNSt3__19enable_ifIXsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmS6_m:
 1361|  6.27M|  static size_t hash_with_seed(T value, size_t seed) {
 1362|  6.27M|    return static_cast<size_t>(
 1363|  6.27M|        CombineRawImpl(seed, static_cast<std::make_unsigned_t<T>>(value)));
 1364|  6.27M|  }
_ZNK4absl12lts_2026010713hash_internal8HashImplINSt3__15tupleIJRKmS6_EEEEclERKS7_:
 1474|  4.00M|  size_t operator()(const T& value) const {
 1475|  4.00M|    return MixingHashState::hash(value);
 1476|  4.00M|  }
_ZN4absl12lts_2026010713hash_internal15MixingHashState4hashINSt3__15tupleIJRKmS7_EEEEEmRKT_:
 1351|  4.00M|  static size_t hash(const T& value) {
 1352|  4.00M|    return hash_with_seed(value, Seed());
 1353|  4.00M|  }
_ZN4absl12lts_2026010713hash_internal15MixingHashState14hash_with_seedINSt3__15tupleIJRKmS7_EEETnNS4_9enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSA_m:
 1367|  4.00M|  static size_t hash_with_seed(const T& value, size_t seed) {
 1368|  4.00M|    return static_cast<size_t>(combine(MixingHashState{seed}, value).state_);
 1369|  4.00M|  }
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__15tupleIJRKmS9_EEEJEEES3_S3_RKT_DpRKT0_:
 1492|  4.00M|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1493|  4.00M|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1494|  4.00M|                        std::move(state), value),
 1495|  4.00M|                    values...);
 1496|  4.00M|}
_ZN4absl12lts_2026010713hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__15tupleIJRKmS9_EEEEENS6_9enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESC_E4typeESC_RKT0_:
 1270|  4.00M|        H> {
 1271|  4.00M|      return AbslHashValue(std::move(state), value);
 1272|  4.00M|    }
_ZN4absl12lts_2026010713hash_internal13AbslHashValueINS1_15MixingHashStateEJRKmS5_EEENSt3__19enable_ifIXsr4absl11conjunctionIDpNS1_11is_hashableIT0_EEEE5valueET_E4typeESC_RKNS6_5tupleIJDpS9_EEE:
  604|  4.00M|AbslHashValue(H hash_state, const std::tuple<Ts...>& t) {
  605|  4.00M|  return hash_internal::hash_tuple(std::move(hash_state), t,
  606|  4.00M|                                   absl::make_index_sequence<sizeof...(Ts)>());
  607|  4.00M|}
_ZN4absl12lts_2026010713hash_internal10hash_tupleINS1_15MixingHashStateENSt3__15tupleIJRKmS7_EEEJLm0ELm1EEEET_S9_RKT0_NS4_16integer_sequenceImJXspT1_EEEE:
  591|  4.00M|H hash_tuple(H hash_state, const Tuple& t, absl::index_sequence<Is...>) {
  592|  4.00M|  return H::combine(std::move(hash_state), std::get<Is>(t)...);
  593|  4.00M|}
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineImJmEEES3_S3_RKT_DpRKT0_:
 1492|  4.00M|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1493|  4.00M|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1494|  4.00M|                        std::move(state), value),
 1495|  4.00M|                    values...);
 1496|  4.00M|}
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineImJEEES3_S3_RKT_DpRKT0_:
 1492|  4.00M|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1493|  4.00M|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1494|  4.00M|                        std::move(state), value),
 1495|  4.00M|                    values...);
 1496|  4.00M|}
_ZN4absl12lts_2026010713hash_internal10HashSelect24UniquelyRepresentedProbe6InvokeINS1_15MixingHashStateEmEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES9_RKS8_:
 1260|  8.01M|        -> absl::enable_if_t<is_uniquely_represented<T>::value, H> {
 1261|  8.01M|      return hash_internal::hash_bytes(std::move(state), value);
 1262|  8.01M|    }
_ZN4absl12lts_2026010713hash_internal10hash_bytesINS1_15MixingHashStateEmTnNSt3__19enable_ifIXsr12FitsIn64BitsIT0_EE5valueEiE4typeELi0EEET_S9_RKS6_:
  406|  8.01M|H hash_bytes(H hash_state, const T& value) {
  407|  8.01M|  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
  408|  8.01M|  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|  8.01M|  } else {
  416|  8.01M|    static_assert(sizeof(T) == 8);
  417|  8.01M|    v = absl::base_internal::UnalignedLoad64(start);
  418|  8.01M|  }
  419|  8.01M|  return CombineRaw()(std::move(hash_state), v);
  420|  8.01M|}
_ZNK4absl12lts_2026010713hash_internal10CombineRawclINS1_15MixingHashStateEEET_S5_m:
  388|  8.01M|  H operator()(H state, uint64_t value) const {
  389|  8.01M|    return H::combine_raw(std::move(state), value);
  390|  8.01M|  }

_ZN4absl12lts_2026010712log_internal12Check_EQImplIiiEEPKcRKT_RKT0_S4_:
  489|  6.80k|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  6.80k|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  6.80k|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  6.80k|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  190|  6.80k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 6.80k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 6.80k]
  |  |  |  Branch (190:57): [True: 6.80k, False: 0]
  |  |  ------------------
  ------------------
  493|  6.80k|               ? nullptr                                                   \
  494|  6.80k|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  6.80k|                                                        U2(v2), exprtext); \
  496|  6.80k|  }                                                                        \
_ZN4absl12lts_2026010712log_internal12Check_GEImplIiiEEPKcRKT_RKT0_S4_:
  489|  4.93M|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  4.93M|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  4.93M|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  4.93M|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  190|  4.93M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 4.93M, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 4.93M]
  |  |  |  Branch (190:57): [True: 4.93M, False: 0]
  |  |  ------------------
  ------------------
  493|  4.93M|               ? nullptr                                                   \
  494|  4.93M|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  4.93M|                                                        U2(v2), exprtext); \
  496|  4.93M|  }                                                                        \
_ZN4absl12lts_2026010712log_internal12Check_GTImplIiiEEPKcRKT_RKT0_S4_:
  489|  6.79k|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  6.79k|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  6.79k|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  6.79k|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  190|  6.79k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 6.79k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 6.79k]
  |  |  |  Branch (190:57): [True: 6.79k, False: 0]
  |  |  ------------------
  ------------------
  493|  6.79k|               ? nullptr                                                   \
  494|  6.79k|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  6.79k|                                                        U2(v2), exprtext); \
  496|  6.79k|  }                                                                        \
_ZN4absl12lts_2026010712log_internal12Check_EQImplEiiPKc:
  498|  6.80k|      int v1, int v2, const char* absl_nonnull exprtext) {                 \
  499|  6.80k|    return name##Impl<int, int>(v1, v2, exprtext);                         \
  500|  6.80k|  }
_ZN4absl12lts_2026010712log_internal12Check_GEImplEiiPKc:
  498|  4.93M|      int v1, int v2, const char* absl_nonnull exprtext) {                 \
  499|  4.93M|    return name##Impl<int, int>(v1, v2, exprtext);                         \
  500|  4.93M|  }
_ZN4absl12lts_2026010712log_internal12Check_GTImplEiiPKc:
  498|  6.79k|      int v1, int v2, const char* absl_nonnull exprtext) {                 \
  499|  6.79k|    return name##Impl<int, int>(v1, v2, exprtext);                         \
  500|  6.79k|  }
_ZN4absl12lts_2026010712log_internal21GetReferenceableValueEt:
  542|  4.93M|inline constexpr unsigned short GetReferenceableValue(unsigned short t) {
  543|  4.93M|  return t;
  544|  4.93M|}
_ZN4absl12lts_2026010712log_internal21GetReferenceableValueEi:
  545|  18.8M|inline constexpr int GetReferenceableValue(int t) { return t; }
_ZN4absl12lts_2026010712log_internal21GetReferenceableValueEm:
  550|   231M|inline constexpr unsigned long GetReferenceableValue(unsigned long t) {
  551|   231M|  return t;
  552|   231M|}
_ZN4absl12lts_2026010712log_internal12Check_LEImplIitEEPKcRKT_RKT0_S4_:
  489|  4.93M|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  4.93M|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  4.93M|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  4.93M|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  190|  4.93M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 4.93M, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 4.93M]
  |  |  |  Branch (190:57): [True: 4.93M, False: 0]
  |  |  ------------------
  ------------------
  493|  4.93M|               ? nullptr                                                   \
  494|  4.93M|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  4.93M|                                                        U2(v2), exprtext); \
  496|  4.93M|  }                                                                        \
_ZN4absl12lts_2026010712log_internal12Check_EQImplImmEEPKcRKT_RKT0_S4_:
  489|  34.9k|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  34.9k|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  34.9k|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  34.9k|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  190|  34.9k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 34.9k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 34.9k]
  |  |  |  Branch (190:57): [True: 34.9k, False: 0]
  |  |  ------------------
  ------------------
  493|  34.9k|               ? nullptr                                                   \
  494|  34.9k|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  34.9k|                                                        U2(v2), exprtext); \
  496|  34.9k|  }                                                                        \
_ZN4absl12lts_2026010712log_internal12Check_LEImplImmEEPKcRKT_RKT0_S4_:
  489|  6.80k|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  6.80k|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  6.80k|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  6.80k|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  190|  6.80k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 6.80k, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 6.80k]
  |  |  |  Branch (190:57): [True: 6.80k, False: 0]
  |  |  ------------------
  ------------------
  493|  6.80k|               ? nullptr                                                   \
  494|  6.80k|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  6.80k|                                                        U2(v2), exprtext); \
  496|  6.80k|  }                                                                        \
_ZN4absl12lts_2026010712log_internal12Check_GTImplImiEEPKcRKT_RKT0_S4_:
  489|  1.38M|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  1.38M|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  1.38M|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  1.38M|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  190|  1.38M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 1.38M, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 1.38M]
  |  |  |  Branch (190:57): [True: 1.38M, False: 0]
  |  |  ------------------
  ------------------
  493|  1.38M|               ? nullptr                                                   \
  494|  1.38M|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  1.38M|                                                        U2(v2), exprtext); \
  496|  1.38M|  }                                                                        \
_ZN4absl12lts_2026010712log_internal12Check_EQImplIimEEPKcRKT_RKT0_S4_:
  489|  2.63M|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  2.63M|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  2.63M|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  2.63M|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  190|  2.63M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 2.63M, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 2.63M]
  |  |  |  Branch (190:57): [True: 2.63M, False: 0]
  |  |  ------------------
  ------------------
  493|  2.63M|               ? nullptr                                                   \
  494|  2.63M|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  2.63M|                                                        U2(v2), exprtext); \
  496|  2.63M|  }                                                                        \
_ZN4absl12lts_2026010712log_internal12Check_LTImplImmEEPKcRKT_RKT0_S4_:
  489|   113M|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|   113M|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|   113M|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|   113M|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  190|   113M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 113M, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 113M]
  |  |  |  Branch (190:57): [True: 113M, False: 0]
  |  |  ------------------
  ------------------
  493|   113M|               ? nullptr                                                   \
  494|   113M|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|   113M|                                                        U2(v2), exprtext); \
  496|   113M|  }                                                                        \

_ZN4absl12lts_2026010712log_internal10LogMessage14InternalStreamEv:
  117|   619k|  LogMessage& InternalStream() { return *this; }
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi25EEERS2_RAT__Kc:
  350|  20.2k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  20.2k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  20.2k|  return *this;
  353|  20.2k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi18EEERS2_RAT__Kc:
  350|  10.1k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  10.1k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  10.1k|  return *this;
  353|  10.1k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsIPKcEERS2_RKT_:
  337|  10.1k|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|  10.1k|  } else {
  343|  10.1k|    OstreamView view(*data_);
  344|  10.1k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  345|  10.1k|  }
  346|  10.1k|  return *this;
  347|  10.1k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsEi:
  132|  76.6k|  LogMessage& operator<<(signed int v) { return operator<< <signed int>(v); }
_ZN4absl12lts_2026010712log_internal10LogMessagelsEl:
  133|  45.0k|  LogMessage& operator<<(signed long v) {
  134|  45.0k|    return operator<< <signed long>(v);
  135|  45.0k|  }
_ZN4absl12lts_2026010712log_internal10LogMessagelsEm:
  145|  71.6k|  LogMessage& operator<<(unsigned long v) {
  146|  71.6k|    return operator<< <unsigned long>(v);
  147|  71.6k|  }
_ZN4absl12lts_2026010712log_internal10LogMessagelsEf:
  157|  34.9k|  LogMessage& operator<<(float v) { return operator<< <float>(v); }
_ZN4absl12lts_2026010712log_internal10LogMessagelsEd:
  158|  47.5k|  LogMessage& operator<<(double v) { return operator<< <double>(v); }
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi26EEERS2_RAT__Kc:
  350|  12.6k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  12.6k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  12.6k|  return *this;
  353|  12.6k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi23EEERS2_RAT__Kc:
  350|  6.80k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  6.80k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  6.80k|  return *this;
  353|  6.80k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi21EEERS2_RAT__Kc:
  350|  6.80k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  6.80k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  6.80k|  return *this;
  353|  6.80k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi17EEERS2_RAT__Kc:
  350|  10.1k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  10.1k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  10.1k|  return *this;
  353|  10.1k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi60EEERS2_RAT__Kc:
  350|    580|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|    580|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|    580|  return *this;
  353|    580|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi7EEERS2_RAT__Kc:
  350|  54.5k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  54.5k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  54.5k|  return *this;
  353|  54.5k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi8EEERS2_RAT__Kc:
  350|  2.10k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  2.10k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  2.10k|  return *this;
  353|  2.10k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi22EEERS2_RAT__Kc:
  350|    685|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|    685|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|    685|  return *this;
  353|    685|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi36EEERS2_RAT__Kc:
  350|    242|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|    242|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|    242|  return *this;
  353|    242|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi12EEERS2_RAT__Kc:
  350|  20.1k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  20.1k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  20.1k|  return *this;
  353|  20.1k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi11EEERS2_RAT__Kc:
  350|  11.8k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  11.8k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  11.8k|  return *this;
  353|  11.8k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi9EEERS2_RAT__Kc:
  350|  2.10k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  2.10k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  2.10k|  return *this;
  353|  2.10k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi20EEERS2_RAT__Kc:
  350|  62.4k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  62.4k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  62.4k|  return *this;
  353|  62.4k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi59EEERS2_RAT__Kc:
  350|   401k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|   401k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|   401k|  return *this;
  353|   401k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi15EEERS2_RAT__Kc:
  350|  10.1k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  10.1k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  10.1k|  return *this;
  353|  10.1k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi45EEERS2_RAT__Kc:
  350|  14.4k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  14.4k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  14.4k|  return *this;
  353|  14.4k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi27EEERS2_RAT__Kc:
  350|  6.80k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  6.80k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  6.80k|  return *this;
  353|  6.80k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi13EEERS2_RAT__Kc:
  350|  78.7k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  78.7k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  78.7k|  return *this;
  353|  78.7k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi6EEERS2_RAT__Kc:
  350|  37.0k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  37.0k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  37.0k|  return *this;
  353|  37.0k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi19EEERS2_RAT__Kc:
  350|  34.9k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  34.9k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  34.9k|  return *this;
  353|  34.9k|}
_ZN4absl12lts_2026010712log_internal10LogMessagelsILi35EEERS2_RAT__Kc:
  350|  1.75k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  351|  1.75k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  352|  1.75k|  return *this;
  353|  1.75k|}

_ZN4absl12lts_2026010712log_internal9NullGuardIPKcE5GuardES4_:
   53|  10.1k|  static const char* Guard(const char* v) { return v ? v : kCharNull.data(); }
  ------------------
  |  Branch (53:52): [True: 10.1k, False: 0]
  ------------------
_ZN4absl12lts_2026010712log_internal9NullGuardImE5GuardERKm:
   45|  71.6k|  static const T& Guard(const T& v) { return v; }
_ZN4absl12lts_2026010712log_internal9NullGuardIlE5GuardERKl:
   45|  45.0k|  static const T& Guard(const T& v) { return v; }

_ZNKO4absl12lts_2026010712log_internal7VoidifyaaIRNS1_10LogMessageEEEvOT_:
   39|   619k|  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|   619k|    message.Flush();
   43|   619k|  }

_ZN4absl12lts_2026010711countl_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  108|  16.1k|    countl_zero(T x) noexcept {
  109|  16.1k|  return numeric_internal::CountLeadingZeroes(x);
  110|  16.1k|}
_ZN4absl12lts_2026010711countr_zeroItEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  123|  79.2M|    countr_zero(T x) noexcept {
  124|  79.2M|  return numeric_internal::CountTrailingZeroes(x);
  125|  79.2M|}

_ZN4absl12lts_202601077uint128mLES1_:
  646|  91.0M|inline uint128& uint128::operator*=(uint128 other) {
  647|  91.0M|  *this = *this * other;
  648|  91.0M|  return *this;
  649|  91.0M|}
_ZN4absl12lts_2026010712Uint128Low64ENS0_7uint128E:
  661|  91.0M|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl12lts_2026010713Uint128High64ENS0_7uint128E:
  663|  91.0M|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZNK4absl12lts_202601077uint128cvmEv:
  777|     27|constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int)
  778|     27|  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int)
  779|     27|}
_ZNK4absl12lts_202601077uint128cvoEv:
  794|   182M|constexpr uint128::operator unsigned __int128() const {
  795|   182M|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  796|   182M|}
_ZN4absl12lts_20260107rsENS0_7uint128Ei:
  974|     54|constexpr uint128 operator>>(uint128 lhs, int amount) {
  975|     54|#ifdef ABSL_HAVE_INTRINSIC_INT128
  976|     54|  return static_cast<unsigned __int128>(lhs) >> amount;
  977|       |#else
  978|       |  // uint64_t shifts of >= 64 are undefined, so we will need some
  979|       |  // special-casing.
  980|       |  return amount >= 64  ? MakeUint128(0, Uint128High64(lhs) >> (amount - 64))
  981|       |         : amount == 0 ? lhs
  982|       |                       : MakeUint128(Uint128High64(lhs) >> amount,
  983|       |                                     (Uint128Low64(lhs) >> amount) |
  984|       |                                         (Uint128High64(lhs) << (64 - amount)));
  985|       |#endif
  986|     54|}
_ZN4absl12lts_20260107mlENS0_7uint128ES1_:
 1059|  91.0M|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|  91.0M|  return static_cast<unsigned __int128>(lhs) *
 1063|  91.0M|         static_cast<unsigned __int128>(rhs);
 1064|  91.0M|}
_ZN4absl12lts_202601077uint128C2Eo:
  692|  91.0M|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  693|  91.0M|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl12lts_202601077uint128C2Em:
  683|   182M|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}

_ZN4absl12lts_2026010716numeric_internal20CountLeadingZeroes64Em:
  214|  16.1k|CountLeadingZeroes64(uint64_t x) {
  215|  16.1k|#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|  16.1k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  221|  16.1k|                "__builtin_clzll does not take 64-bit arg");
  222|       |
  223|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  224|  16.1k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (224:10): [True: 0, False: 16.1k]
  ------------------
  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|  16.1k|}
_ZN4absl12lts_2026010716numeric_internal28CountTrailingZeroesNonzero16Et:
  339|  79.2M|CountTrailingZeroesNonzero16(uint16_t x) {
  340|  79.2M|#if ABSL_HAVE_BUILTIN(__builtin_ctzg)
  341|  79.2M|  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|  79.2M|}
_ZN4absl12lts_2026010716numeric_internal18CountLeadingZeroesImEEiT_:
  268|  16.1k|CountLeadingZeroes(T x) {
  269|  16.1k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  270|  16.1k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  271|  16.1k|                "T must have a power-of-2 size");
  272|  16.1k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  273|  16.1k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (273:10): [Folded, False: 16.1k]
  ------------------
  274|  16.1k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  275|      0|                   (std::numeric_limits<uint16_t>::digits -
  276|      0|                    std::numeric_limits<T>::digits)
  277|  16.1k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (277:17): [Folded, False: 16.1k]
  ------------------
  278|  16.1k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  279|      0|                          (std::numeric_limits<uint32_t>::digits -
  280|      0|                           std::numeric_limits<T>::digits)
  281|  16.1k|                    : CountLeadingZeroes64(x));
  282|  16.1k|}
_ZN4absl12lts_2026010716numeric_internal19CountTrailingZeroesItEEiT_:
  353|  79.2M|CountTrailingZeroes(T x) noexcept {
  354|  79.2M|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  355|  79.2M|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  356|  79.2M|                "T must have a power-of-2 size");
  357|  79.2M|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  358|  79.2M|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (358:10): [True: 0, False: 79.2M]
  ------------------
  359|  79.2M|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (359:20): [True: 79.2M, Folded]
  ------------------
  360|  79.2M|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  361|  79.2M|                       : (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|  79.2M|}

_ZN4absl12lts_2026010715random_internal17RandenPoolSeedSeq4sizeEv:
   66|  10.1k|  size_t size() { return 0; }
_ZN4absl12lts_2026010715random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEC2INSt3__18seed_seqEvEEOT_:
  112|  1.46k|      : urbg_(ConstructURBG(std::forward<SSeq>(seq))) {}
_ZN4absl12lts_2026010715random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEE13ConstructURBGINSt3__18seed_seqEEES4_OT_:
  147|  1.46k|  static URBG ConstructURBG(SSeq&& seq) {  // NOLINT(runtime/references)
  148|  1.46k|    auto salted_seq =
  149|  1.46k|        random_internal::MakeSaltedSeedSeq(std::forward<SSeq>(seq));
  150|  1.46k|    return URBG(salted_seq);
  151|  1.46k|  }
_ZN4absl12lts_2026010715random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEC2Ev:
  100|  10.1k|  NonsecureURBGBase() : urbg_(ConstructURBG()) {}
_ZN4absl12lts_2026010715random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEE13ConstructURBGEv:
  141|  10.1k|  static URBG ConstructURBG() {
  142|  10.1k|    Seeder seeder;
  143|  10.1k|    return URBG(seeder);
  144|  10.1k|  }
_ZN4absl12lts_2026010715random_internal17RandenPoolSeedSeq8generateIPjEEvT_S5_:
   72|  10.1k|  void generate(RandomAccessIterator begin, RandomAccessIterator end) {
   73|       |    // RandomAccessIterator must be assignable from uint32_t
   74|  10.1k|    if (begin != end) {
  ------------------
  |  Branch (74:9): [True: 10.1k, False: 0]
  ------------------
   75|  10.1k|      using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
   76|       |      // ContiguousTag indicates the common case of a known contiguous buffer,
   77|       |      // which allows directly filling the buffer. In C++20,
   78|       |      // std::contiguous_iterator_tag provides a mechanism for testing this
   79|       |      // capability, however until Abseil's support requirements allow us to
   80|       |      // assume C++20, limit checks to a few common cases.
   81|  10.1k|      using TagType = absl::conditional_t<
   82|  10.1k|          (std::is_pointer<RandomAccessIterator>::value ||
   83|  10.1k|           std::is_same<RandomAccessIterator,
   84|  10.1k|                        typename std::vector<U>::iterator>::value),
   85|  10.1k|          ContiguousTag, BufferTag>;
   86|       |
   87|  10.1k|      generate_impl(TagType{}, begin, end);
   88|  10.1k|    }
   89|  10.1k|  }
_ZN4absl12lts_2026010715random_internal17RandenPoolSeedSeq13generate_implIPjEEvNS2_13ContiguousTagET_S6_:
   46|  10.1k|  void generate_impl(ContiguousTag, Contiguous begin, Contiguous end) {
   47|  10.1k|    const size_t n = static_cast<size_t>(std::distance(begin, end));
   48|  10.1k|    auto* a = &(*begin);
   49|  10.1k|    GetEntropyFromRandenPool(a, sizeof(*a) * n);
   50|  10.1k|  }

_ZNK4absl12lts_2026010715random_internal6Randen8GenerateEPv:
   47|  1.35k|  inline void Generate(void* state) const {
   48|  1.35k|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   49|       |    // HW AES Dispatch.
   50|  1.35k|    if (has_crypto_) {
  ------------------
  |  Branch (50:9): [True: 0, False: 1.35k]
  ------------------
   51|      0|      RandenHwAes::Generate(keys_, state);
   52|  1.35k|    } else {
   53|  1.35k|      RandenSlow::Generate(keys_, state);
   54|  1.35k|    }
   55|       |#elif ABSL_HAVE_ACCELERATED_AES
   56|       |    // HW AES is enabled.
   57|       |    RandenHwAes::Generate(keys_, state);
   58|       |#else
   59|       |    // HW AES is disabled.
   60|       |    RandenSlow::Generate(keys_, state);
   61|       |#endif
   62|  1.35k|  }
_ZNK4absl12lts_2026010715random_internal6Randen6AbsorbEPKvPv:
   68|  11.5k|  inline void Absorb(const void* seed, void* state) const {
   69|  11.5k|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   70|       |    // HW AES Dispatch.
   71|  11.5k|    if (has_crypto_) {
  ------------------
  |  Branch (71:9): [True: 0, False: 11.5k]
  ------------------
   72|      0|      RandenHwAes::Absorb(seed, state);
   73|  11.5k|    } else {
   74|  11.5k|      RandenSlow::Absorb(seed, state);
   75|  11.5k|    }
   76|       |#elif ABSL_HAVE_ACCELERATED_AES
   77|       |    // HW AES is enabled.
   78|       |    RandenHwAes::Absorb(seed, state);
   79|       |#else
   80|       |    // HW AES is disabled.
   81|       |    RandenSlow::Absorb(seed, state);
   82|       |#endif
   83|  11.5k|  }

_ZN4absl12lts_2026010715random_internal13randen_engineImEC2IRNS1_13SaltedSeedSeqINSt3__18seed_seqEEEvEEOT_:
   68|  1.46k|  explicit randen_engine(SeedSequence&& seq) {
   69|  1.46k|    seed(seq);
   70|  1.46k|  }
_ZN4absl12lts_2026010715random_internal13randen_engineImE4seedIRNS1_13SaltedSeedSeqINSt3__18seed_seqEEEEENS6_9enable_ifIXntsr3std14is_convertibleIT_mEE5valueEvE4typeEOSB_:
   98|  1.46k|  seed(SeedSequence&& seq) {
   99|       |    // Zeroes the state.
  100|  1.46k|    seed();
  101|  1.46k|    reseed(seq);
  102|  1.46k|  }
_ZN4absl12lts_2026010715random_internal13randen_engineImE4seedEm:
  104|  11.5k|  void seed(result_type seed_value = 0) {
  105|  11.5k|    next_ = kStateSizeT;
  106|       |    // Zeroes the inner state and fills the outer state with seed_value to
  107|       |    // mimic the behaviour of reseed
  108|  11.5k|    auto* begin = state();
  109|  11.5k|    std::fill(begin, begin + kCapacityT, 0);
  110|  11.5k|    std::fill(begin + kCapacityT, begin + kStateSizeT, seed_value);
  111|  11.5k|  }
_ZN4absl12lts_2026010715random_internal13randen_engineImE5stateEv:
  245|  23.1k|  result_type* state() {
  246|  23.1k|    return reinterpret_cast<result_type*>(
  247|  23.1k|        (reinterpret_cast<uintptr_t>(&raw_state_) & 0xf) ? (raw_state_ + 8)
  ------------------
  |  Branch (247:9): [True: 20.2k, False: 2.92k]
  ------------------
  248|  23.1k|                                                         : raw_state_);
  249|  23.1k|  }
_ZN4absl12lts_2026010715random_internal13randen_engineImE6reseedINS1_13SaltedSeedSeqINSt3__18seed_seqEEEEEvRT_:
  117|  1.46k|  void reseed(SeedSequence& seq) {
  118|  1.46k|    using sequence_result_type = typename SeedSequence::result_type;
  119|  1.46k|    static_assert(sizeof(sequence_result_type) == 4,
  120|  1.46k|                  "SeedSequence::result_type must be 32-bit");
  121|  1.46k|    constexpr size_t kBufferSize =
  122|  1.46k|        Randen::kSeedBytes / sizeof(sequence_result_type);
  123|  1.46k|    alignas(16) sequence_result_type buffer[kBufferSize];
  124|       |
  125|       |    // Randen::Absorb XORs the seed into state, which is then mixed by a call
  126|       |    // to Randen::Generate. Seeding with only the provided entropy is preferred
  127|       |    // to using an arbitrary generate() call, so use [rand.req.seed_seq]
  128|       |    // size as a proxy for the number of entropy units that can be generated
  129|       |    // without relying on seed sequence mixing...
  130|  1.46k|    const size_t entropy_size = seq.size();
  131|  1.46k|    if (entropy_size < kBufferSize) {
  ------------------
  |  Branch (131:9): [True: 1.46k, False: 0]
  ------------------
  132|       |      // ... and only request that many values, or 256-bits, when unspecified.
  133|  1.46k|      const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
  ------------------
  |  Branch (133:40): [True: 0, False: 1.46k]
  ------------------
  134|  1.46k|      std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
  135|  1.46k|      seq.generate(buffer, buffer + requested_entropy);
  136|       |#ifdef ABSL_IS_BIG_ENDIAN
  137|       |      // Randen expects the seed buffer to be in Little Endian; reverse it on
  138|       |      // Big Endian platforms.
  139|       |      for (sequence_result_type& e : buffer) {
  140|       |        e = absl::little_endian::FromHost(e);
  141|       |      }
  142|       |#endif
  143|       |      // The Randen paper suggests preferentially initializing even-numbered
  144|       |      // 128-bit vectors of the randen state (there are 16 such vectors).
  145|       |      // The seed data is merged into the state offset by 128-bits, which
  146|       |      // implies preferring seed bytes [16..31, ..., 208..223]. Since the
  147|       |      // buffer is 32-bit values, we swap the corresponding buffer positions in
  148|       |      // 128-bit chunks.
  149|  1.46k|      size_t dst = kBufferSize;
  150|  11.6k|      while (dst > 7) {
  ------------------
  |  Branch (150:14): [True: 10.2k, False: 1.46k]
  ------------------
  151|       |        // leave the odd bucket as-is.
  152|  10.2k|        dst -= 4;
  153|  10.2k|        size_t src = dst >> 1;
  154|       |        // swap 128-bits into the even bucket
  155|  10.2k|        std::swap(buffer[--dst], buffer[--src]);
  156|  10.2k|        std::swap(buffer[--dst], buffer[--src]);
  157|  10.2k|        std::swap(buffer[--dst], buffer[--src]);
  158|  10.2k|        std::swap(buffer[--dst], buffer[--src]);
  159|  10.2k|      }
  160|  1.46k|    } else {
  161|      0|      seq.generate(buffer, buffer + kBufferSize);
  162|      0|    }
  163|  1.46k|    impl_.Absorb(buffer, state());
  164|       |
  165|       |    // Generate will be called when operator() is called
  166|  1.46k|    next_ = kStateSizeT;
  167|  1.46k|  }
_ZN4absl12lts_2026010715random_internal13randen_engineImEC2IRNS1_17RandenPoolSeedSeqEvEEOT_:
   68|  10.1k|  explicit randen_engine(SeedSequence&& seq) {
   69|  10.1k|    seed(seq);
   70|  10.1k|  }
_ZN4absl12lts_2026010715random_internal13randen_engineImE4seedIRNS1_17RandenPoolSeedSeqEEENSt3__19enable_ifIXntsr3std14is_convertibleIT_mEE5valueEvE4typeEOS9_:
   98|  10.1k|  seed(SeedSequence&& seq) {
   99|       |    // Zeroes the state.
  100|  10.1k|    seed();
  101|  10.1k|    reseed(seq);
  102|  10.1k|  }
_ZN4absl12lts_2026010715random_internal13randen_engineImE6reseedINS1_17RandenPoolSeedSeqEEEvRT_:
  117|  10.1k|  void reseed(SeedSequence& seq) {
  118|  10.1k|    using sequence_result_type = typename SeedSequence::result_type;
  119|  10.1k|    static_assert(sizeof(sequence_result_type) == 4,
  120|  10.1k|                  "SeedSequence::result_type must be 32-bit");
  121|  10.1k|    constexpr size_t kBufferSize =
  122|  10.1k|        Randen::kSeedBytes / sizeof(sequence_result_type);
  123|  10.1k|    alignas(16) sequence_result_type buffer[kBufferSize];
  124|       |
  125|       |    // Randen::Absorb XORs the seed into state, which is then mixed by a call
  126|       |    // to Randen::Generate. Seeding with only the provided entropy is preferred
  127|       |    // to using an arbitrary generate() call, so use [rand.req.seed_seq]
  128|       |    // size as a proxy for the number of entropy units that can be generated
  129|       |    // without relying on seed sequence mixing...
  130|  10.1k|    const size_t entropy_size = seq.size();
  131|  10.1k|    if (entropy_size < kBufferSize) {
  ------------------
  |  Branch (131:9): [True: 10.1k, False: 0]
  ------------------
  132|       |      // ... and only request that many values, or 256-bits, when unspecified.
  133|  10.1k|      const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
  ------------------
  |  Branch (133:40): [True: 10.1k, False: 0]
  ------------------
  134|  10.1k|      std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
  135|  10.1k|      seq.generate(buffer, buffer + requested_entropy);
  136|       |#ifdef ABSL_IS_BIG_ENDIAN
  137|       |      // Randen expects the seed buffer to be in Little Endian; reverse it on
  138|       |      // Big Endian platforms.
  139|       |      for (sequence_result_type& e : buffer) {
  140|       |        e = absl::little_endian::FromHost(e);
  141|       |      }
  142|       |#endif
  143|       |      // The Randen paper suggests preferentially initializing even-numbered
  144|       |      // 128-bit vectors of the randen state (there are 16 such vectors).
  145|       |      // The seed data is merged into the state offset by 128-bits, which
  146|       |      // implies preferring seed bytes [16..31, ..., 208..223]. Since the
  147|       |      // buffer is 32-bit values, we swap the corresponding buffer positions in
  148|       |      // 128-bit chunks.
  149|  10.1k|      size_t dst = kBufferSize;
  150|  81.0k|      while (dst > 7) {
  ------------------
  |  Branch (150:14): [True: 70.8k, False: 10.1k]
  ------------------
  151|       |        // leave the odd bucket as-is.
  152|  70.8k|        dst -= 4;
  153|  70.8k|        size_t src = dst >> 1;
  154|       |        // swap 128-bits into the even bucket
  155|  70.8k|        std::swap(buffer[--dst], buffer[--src]);
  156|  70.8k|        std::swap(buffer[--dst], buffer[--src]);
  157|  70.8k|        std::swap(buffer[--dst], buffer[--src]);
  158|  70.8k|        std::swap(buffer[--dst], buffer[--src]);
  159|  70.8k|      }
  160|  10.1k|    } else {
  161|      0|      seq.generate(buffer, buffer + kBufferSize);
  162|      0|    }
  163|  10.1k|    impl_.Absorb(buffer, state());
  164|       |
  165|       |    // Generate will be called when operator() is called
  166|  10.1k|    next_ = kStateSizeT;
  167|  10.1k|  }

_ZN4absl12lts_2026010715random_internal17MakeSaltedSeedSeqINSt3__18seed_seqEvEENS1_13SaltedSeedSeqINS3_5decayIT_E4typeEEEOS7_:
  152|  1.46k|SaltedSeedSeq<typename std::decay<SSeq>::type> MakeSaltedSeedSeq(SSeq&& seq) {
  153|  1.46k|  using sseq_type = typename std::decay<SSeq>::type;
  154|  1.46k|  using result_type = typename sseq_type::result_type;
  155|       |
  156|  1.46k|  absl::InlinedVector<result_type, 8> data;
  157|  1.46k|  seq.param(std::back_inserter(data));
  158|  1.46k|  return SaltedSeedSeq<sseq_type>(data.begin(), data.end());
  159|  1.46k|}
_ZN4absl12lts_2026010715random_internal13SaltedSeedSeqINSt3__18seed_seqEEC2IPjEET_S8_:
   55|  1.46k|      : seq_(absl::make_unique<SSeq>(begin, end)) {}
_ZNK4absl12lts_2026010715random_internal13SaltedSeedSeqINSt3__18seed_seqEE4sizeEv:
   90|  1.46k|  size_t size() const { return seq_->size(); }
_ZN4absl12lts_2026010715random_internal13SaltedSeedSeqINSt3__18seed_seqEE8generateIPjEEvT_S8_:
   68|  1.46k|  void generate(RandomAccessIterator begin, RandomAccessIterator end) {
   69|  1.46k|    using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
   70|       |
   71|       |    // The common case is that generate is called with ContiguousIterators
   72|       |    // to uint arrays. Such contiguous memory regions may be optimized,
   73|       |    // which we detect here.
   74|  1.46k|    using TagType = absl::conditional_t<
   75|  1.46k|        (std::is_same<U, uint32_t>::value &&
   76|  1.46k|         (std::is_pointer<RandomAccessIterator>::value ||
   77|  1.46k|          std::is_same<RandomAccessIterator,
   78|  1.46k|                       typename std::vector<U>::iterator>::value)),
   79|  1.46k|        ContiguousAndUint32Tag, DefaultTag>;
   80|  1.46k|    if (begin != end) {
  ------------------
  |  Branch (80:9): [True: 1.46k, False: 0]
  ------------------
   81|  1.46k|      generate_impl(TagType{}, begin, end, std::distance(begin, end));
   82|  1.46k|    }
   83|  1.46k|  }
_ZN4absl12lts_2026010715random_internal13SaltedSeedSeqINSt3__18seed_seqEE13generate_implIPjEEvNS5_22ContiguousAndUint32TagET_S9_m:
  101|  1.46k|                     size_t n) {
  102|  1.46k|    seq_->generate(begin, end);
  103|  1.46k|    const uint32_t salt = absl::random_internal::GetSaltMaterial().value_or(0);
  104|  1.46k|    auto span = absl::Span<uint32_t>(&*begin, n);
  105|  1.46k|    MixIntoSeedMaterial(absl::MakeConstSpan(&salt, 1), span);
  106|  1.46k|  }

_ZN4absl12lts_2026010715AsciiStrToUpperENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  223|  10.1k|[[nodiscard]] inline std::string AsciiStrToUpper(absl::string_view s) {
  224|  10.1k|  std::string result;
  225|  10.1k|  StringResizeAndOverwrite(result, s.size(), [s](char* buf, size_t buf_size) {
  226|  10.1k|    ascii_internal::AsciiStrToUpper(buf, s.data(), s.size());
  227|  10.1k|    return buf_size;
  228|  10.1k|  });
  229|  10.1k|  return result;
  230|  10.1k|}
_ZZN4absl12lts_2026010715AsciiStrToUpperENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEENKUlPcmE_clES6_m:
  225|  10.1k|  StringResizeAndOverwrite(result, s.size(), [s](char* buf, size_t buf_size) {
  226|  10.1k|    ascii_internal::AsciiStrToUpper(buf, s.data(), s.size());
  227|  10.1k|    return buf_size;
  228|  10.1k|  });

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

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

_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl15conversion_charEv:
  290|  16.9M|  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|  16.9M|    static_assert(offsetof(FormatConversionSpecImpl, conv_) == 0, "");
  294|  16.9M|    return conv_;
  295|  16.9M|  }
_ZN4absl12lts_2026010719str_format_internal29FormatConversionCharToConvIntENS0_20FormatConversionCharE:
  360|  2.51M|constexpr uint64_t FormatConversionCharToConvInt(FormatConversionChar c) {
  361|  2.51M|  return uint64_t{1} << (1 + static_cast<uint8_t>(c));
  362|  2.51M|}
_ZN4absl12lts_2026010719str_format_internal8ContainsENS0_23FormatConversionCharSetENS0_20FormatConversionCharE:
  442|  2.51M|constexpr bool Contains(FormatConversionCharSet set, FormatConversionChar c) {
  443|  2.51M|  return (static_cast<uint64_t>(set) & FormatConversionCharToConvInt(c)) != 0;
  444|  2.51M|}

_ZN4absl12lts_2026010716strings_internal23ConvertibleToStringViewC2ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   69|  10.1k|      : value_(s) {}
_ZNK4absl12lts_2026010716strings_internal23ConvertibleToStringView5valueEv:
   77|  10.1k|  absl::string_view value() const { return value_; }
_ZN4absl12lts_2026010716strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEC2ES9_S3_S4_:
  296|  10.1k|      : text_(std::move(input_text)),
  297|  10.1k|        delimiter_(std::move(d)),
  298|  10.1k|        predicate_(std::move(p)) {}
_ZNK4absl12lts_2026010716strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE5beginEv:
  307|  10.1k|  const_iterator begin() const { return {const_iterator::kInitState, this}; }
_ZN4absl12lts_2026010716strings_internal13SplitIteratorINS1_8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEC2ENSC_5StateEPKSB_:
  100|  20.2k|      : pos_(0),
  101|  20.2k|        state_(state),
  102|  20.2k|        splitter_(splitter),
  103|  20.2k|        delimiter_(splitter->delimiter()),
  104|  20.2k|        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|  20.2k|    if (splitter_->text().data() == nullptr) {
  ------------------
  |  Branch (114:9): [True: 0, False: 20.2k]
  ------------------
  115|      0|      state_ = kEndState;
  116|      0|      pos_ = splitter_->text().size();
  117|      0|      return;
  118|      0|    }
  119|       |
  120|  20.2k|    if (state_ == kEndState) {
  ------------------
  |  Branch (120:9): [True: 10.1k, False: 10.1k]
  ------------------
  121|  10.1k|      pos_ = splitter_->text().size();
  122|  10.1k|    } else {
  123|  10.1k|      ++(*this);
  124|  10.1k|    }
  125|  20.2k|  }
_ZNK4absl12lts_2026010716strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE9delimiterEv:
  301|  20.2k|  const Delimiter& delimiter() const { return delimiter_; }
_ZNK4absl12lts_2026010716strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE9predicateEv:
  302|  20.2k|  const Predicate& predicate() const { return predicate_; }
_ZNK4absl12lts_2026010716strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE4textEv:
  300|  78.5k|  absl::string_view text() const { return text_; }
_ZNK4absl12lts_2026010716strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE3endEv:
  308|  10.1k|  const_iterator end() const { return {const_iterator::kEndState, this}; }
_ZN4absl12lts_2026010716strings_internalneERKNS1_13SplitIteratorINS1_8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEESE_:
  158|  58.2k|  friend bool operator!=(const SplitIterator& a, const SplitIterator& b) {
  159|  58.2k|    return !(a == b);
  160|  58.2k|  }
_ZN4absl12lts_2026010716strings_internaleqERKNS1_13SplitIteratorINS1_8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEESE_:
  154|  58.2k|  friend bool operator==(const SplitIterator& a, const SplitIterator& b) {
  155|  58.2k|    return a.state_ == b.state_ && a.pos_ == b.pos_;
  ------------------
  |  Branch (155:12): [True: 10.1k, False: 48.1k]
  |  Branch (155:36): [True: 10.1k, False: 0]
  ------------------
  156|  58.2k|  }
_ZN4absl12lts_2026010716strings_internal13SplitIteratorINS1_8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEppEv:
  132|  58.2k|  SplitIterator& operator++() {
  133|  58.2k|    do {
  134|  58.2k|      if (state_ == kLastState) {
  ------------------
  |  Branch (134:11): [True: 10.1k, False: 48.1k]
  ------------------
  135|  10.1k|        state_ = kEndState;
  136|  10.1k|        return *this;
  137|  10.1k|      }
  138|  48.1k|      const absl::string_view text = splitter_->text();
  139|  48.1k|      const absl::string_view d = delimiter_.Find(text, pos_);
  140|  48.1k|      if (d.data() == text.data() + text.size()) state_ = kLastState;
  ------------------
  |  Branch (140:11): [True: 10.1k, False: 38.0k]
  ------------------
  141|  48.1k|      curr_ = text.substr(pos_,
  142|  48.1k|                          static_cast<size_t>(d.data() - (text.data() + pos_)));
  143|  48.1k|      pos_ += curr_.size() + d.size();
  144|  48.1k|    } while (!predicate_(curr_));
  ------------------
  |  Branch (144:14): [True: 0, False: 48.1k]
  ------------------
  145|  48.1k|    return *this;
  146|  58.2k|  }
_ZNK4absl12lts_2026010716strings_internal13SplitIteratorINS1_8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEdeEv:
  129|  48.1k|  reference operator*() const { return curr_; }

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

_ZN4absl12lts_2026010710SimpleAtoiIiEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_:
  326|  20.2k|                              int_type* absl_nonnull out) {
  327|  20.2k|  return numbers_internal::safe_strtoi_base(str, out, 10);
  328|  20.2k|}
_ZN4absl12lts_2026010716numbers_internal16safe_strtoi_baseIiEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
  243|  20.2k|                                    int_type* absl_nonnull out, int base) {
  244|  20.2k|  static_assert(sizeof(*out) == 1 || sizeof(*out) == 2 || sizeof(*out) == 4 ||
  245|  20.2k|                    sizeof(*out) == 8,
  246|  20.2k|                "SimpleAtoi works only with 8, 16, 32, or 64-bit integers.");
  247|  20.2k|  static_assert(!std::is_floating_point<int_type>::value,
  248|  20.2k|                "Use SimpleAtof or SimpleAtod instead.");
  249|  20.2k|  bool parsed;
  250|       |  // These conditions are constexpr bools to suppress MSVC warning C4127.
  251|  20.2k|  constexpr bool kIsSigned = is_signed<int_type>();
  252|  20.2k|  constexpr int kIntTypeSize = sizeof(*out) * 8;
  253|  20.2k|  if (kIsSigned) {
  ------------------
  |  Branch (253:7): [True: 20.2k, Folded]
  ------------------
  254|  20.2k|    if (kIntTypeSize == 64) {
  ------------------
  |  Branch (254:9): [Folded, False: 20.2k]
  ------------------
  255|      0|      int64_t val;
  256|      0|      parsed = numbers_internal::safe_strto64_base(s, &val, base);
  257|      0|      *out = static_cast<int_type>(val);
  258|  20.2k|    } else if (kIntTypeSize == 32) {
  ------------------
  |  Branch (258:16): [True: 20.2k, Folded]
  ------------------
  259|  20.2k|      int32_t val;
  260|  20.2k|      parsed = numbers_internal::safe_strto32_base(s, &val, base);
  261|  20.2k|      *out = static_cast<int_type>(val);
  262|  20.2k|    } else if (kIntTypeSize == 16) {
  ------------------
  |  Branch (262:16): [Folded, False: 0]
  ------------------
  263|      0|      int16_t val;
  264|      0|      parsed = numbers_internal::safe_strto16_base(s, &val, base);
  265|      0|      *out = static_cast<int_type>(val);
  266|      0|    } else if (kIntTypeSize == 8) {
  ------------------
  |  Branch (266:16): [Folded, False: 0]
  ------------------
  267|      0|      int8_t val;
  268|      0|      parsed = numbers_internal::safe_strto8_base(s, &val, base);
  269|      0|      *out = static_cast<int_type>(val);
  270|      0|    }
  271|  20.2k|  } else {
  272|      0|    if (kIntTypeSize == 64) {
  ------------------
  |  Branch (272:9): [Folded, False: 0]
  ------------------
  273|      0|      uint64_t val;
  274|      0|      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
  275|      0|      *out = static_cast<int_type>(val);
  276|      0|    } else if (kIntTypeSize == 32) {
  ------------------
  |  Branch (276:16): [True: 0, Folded]
  ------------------
  277|      0|      uint32_t val;
  278|      0|      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
  279|      0|      *out = static_cast<int_type>(val);
  280|      0|    } else if (kIntTypeSize == 16) {
  ------------------
  |  Branch (280:16): [Folded, False: 0]
  ------------------
  281|      0|      uint16_t val;
  282|      0|      parsed = numbers_internal::safe_strtou16_base(s, &val, base);
  283|      0|      *out = static_cast<int_type>(val);
  284|      0|    } else if (kIntTypeSize == 8) {
  ------------------
  |  Branch (284:16): [Folded, False: 0]
  ------------------
  285|      0|      uint8_t val;
  286|      0|      parsed = numbers_internal::safe_strtou8_base(s, &val, base);
  287|      0|      *out = static_cast<int_type>(val);
  288|      0|    }
  289|      0|  }
  290|  20.2k|  return parsed;
  291|  20.2k|}
_ZN4absl12lts_2026010710SimpleAtoiImEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_:
  326|  2.04k|                              int_type* absl_nonnull out) {
  327|  2.04k|  return numbers_internal::safe_strtoi_base(str, out, 10);
  328|  2.04k|}
_ZN4absl12lts_2026010716numbers_internal16safe_strtoi_baseImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
  243|  2.04k|                                    int_type* absl_nonnull out, int base) {
  244|  2.04k|  static_assert(sizeof(*out) == 1 || sizeof(*out) == 2 || sizeof(*out) == 4 ||
  245|  2.04k|                    sizeof(*out) == 8,
  246|  2.04k|                "SimpleAtoi works only with 8, 16, 32, or 64-bit integers.");
  247|  2.04k|  static_assert(!std::is_floating_point<int_type>::value,
  248|  2.04k|                "Use SimpleAtof or SimpleAtod instead.");
  249|  2.04k|  bool parsed;
  250|       |  // These conditions are constexpr bools to suppress MSVC warning C4127.
  251|  2.04k|  constexpr bool kIsSigned = is_signed<int_type>();
  252|  2.04k|  constexpr int kIntTypeSize = sizeof(*out) * 8;
  253|  2.04k|  if (kIsSigned) {
  ------------------
  |  Branch (253:7): [Folded, False: 2.04k]
  ------------------
  254|      0|    if (kIntTypeSize == 64) {
  ------------------
  |  Branch (254:9): [True: 0, Folded]
  ------------------
  255|      0|      int64_t val;
  256|      0|      parsed = numbers_internal::safe_strto64_base(s, &val, base);
  257|      0|      *out = static_cast<int_type>(val);
  258|      0|    } else if (kIntTypeSize == 32) {
  ------------------
  |  Branch (258:16): [Folded, False: 0]
  ------------------
  259|      0|      int32_t val;
  260|      0|      parsed = numbers_internal::safe_strto32_base(s, &val, base);
  261|      0|      *out = static_cast<int_type>(val);
  262|      0|    } else if (kIntTypeSize == 16) {
  ------------------
  |  Branch (262:16): [Folded, False: 0]
  ------------------
  263|      0|      int16_t val;
  264|      0|      parsed = numbers_internal::safe_strto16_base(s, &val, base);
  265|      0|      *out = static_cast<int_type>(val);
  266|      0|    } else if (kIntTypeSize == 8) {
  ------------------
  |  Branch (266:16): [Folded, False: 0]
  ------------------
  267|      0|      int8_t val;
  268|      0|      parsed = numbers_internal::safe_strto8_base(s, &val, base);
  269|      0|      *out = static_cast<int_type>(val);
  270|      0|    }
  271|  2.04k|  } else {
  272|  2.04k|    if (kIntTypeSize == 64) {
  ------------------
  |  Branch (272:9): [True: 2.04k, Folded]
  ------------------
  273|  2.04k|      uint64_t val;
  274|  2.04k|      parsed = numbers_internal::safe_strtou64_base(s, &val, base);
  275|  2.04k|      *out = static_cast<int_type>(val);
  276|  2.04k|    } else if (kIntTypeSize == 32) {
  ------------------
  |  Branch (276:16): [Folded, False: 0]
  ------------------
  277|      0|      uint32_t val;
  278|      0|      parsed = numbers_internal::safe_strtou32_base(s, &val, base);
  279|      0|      *out = static_cast<int_type>(val);
  280|      0|    } else if (kIntTypeSize == 16) {
  ------------------
  |  Branch (280:16): [Folded, False: 0]
  ------------------
  281|      0|      uint16_t val;
  282|      0|      parsed = numbers_internal::safe_strtou16_base(s, &val, base);
  283|      0|      *out = static_cast<int_type>(val);
  284|      0|    } else if (kIntTypeSize == 8) {
  ------------------
  |  Branch (284:16): [Folded, False: 0]
  ------------------
  285|      0|      uint8_t val;
  286|      0|      parsed = numbers_internal::safe_strtou8_base(s, &val, base);
  287|      0|      *out = static_cast<int_type>(val);
  288|      0|    }
  289|  2.04k|  }
  290|  2.04k|  return parsed;
  291|  2.04k|}

_ZN4absl12lts_2026010724StringResizeAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_15AsciiStrToUpperENS2_17basic_string_viewIcS5_EEEUlPcmE_EEvRT_NSD_9size_typeET0_:
  182|  10.1k|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  183|  10.1k|  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|  10.1k|}
_ZN4absl12lts_2026010716strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS0_15AsciiStrToUpperENS3_17basic_string_viewIcS6_EEEUlPcmE_EEvRT_NSE_9size_typeET0_:
  145|  10.1k|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|  10.1k|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  156|  10.1k|    str.__resize_default_init(n);
  157|  10.1k|    str.__resize_default_init(
  158|  10.1k|        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|  10.1k|#endif
  165|  10.1k|}

_ZN4absl12lts_202601078AlphaNumC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE:
  387|  20.2k|      : piece_(str) {}

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

_ZN4absl12lts_202601078StrSplitIPKcEENS0_16strings_internal8SplitterINS4_15SelectDelimiterIT_E4typeENS0_10AllowEmptyENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEEENS4_23ConvertibleToStringViewES7_:
  534|  10.1k|StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
  535|  10.1k|  using DelimiterType =
  536|  10.1k|      typename strings_internal::SelectDelimiter<Delimiter>::type;
  537|  10.1k|  return strings_internal::Splitter<DelimiterType, AllowEmpty,
  538|  10.1k|                                    absl::string_view>(
  539|  10.1k|      text.value(), DelimiterType(d), AllowEmpty());
  540|  10.1k|}
_ZNK4absl12lts_2026010710AllowEmptyclENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  348|  48.1k|  bool operator()(absl::string_view) const { return true; }

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

_ZN4absl12lts_2026010724synchronization_internal13KernelTimeoutC2Ev:
   51|   111k|  constexpr KernelTimeout() : rep_(kNoTimeout) {}
_ZN4absl12lts_2026010724synchronization_internal13KernelTimeout5NeverEv:
   55|   111k|  static constexpr KernelTimeout Never() { return KernelTimeout(); }

_ZN4absl12lts_202601075Mutex5AwaitERKNS0_9ConditionE:
  351|   111k|  void Await(const Condition& cond) {
  352|   111k|    AwaitCommon(cond, synchronization_internal::KernelTimeout::Never());
  353|   111k|  }
_ZN4absl12lts_202601079MutexLockC2ERNS0_5MutexE:
  613|   222k|      : mu_(mu) {
  614|   222k|    this->mu_.lock();
  615|   222k|  }
_ZN4absl12lts_202601079MutexLockD2Ev:
  645|   222k|  ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_.unlock(); }
_ZN4absl12lts_202601075Mutex4DtorEv:
 1175|  55.6k|inline void Mutex::Dtor() {}
_ZN4absl12lts_202601079Condition17CastAndCallMethodIKN13sentencepiece10ThreadPoolEMS4_KFbvEEEbPKS1_:
 1182|   111k|bool Condition::CastAndCallMethod(const Condition* absl_nonnull c) {
 1183|   111k|  T* object = static_cast<T*>(c->arg_);
 1184|   111k|  ConditionMethodPtr condition_method_pointer;
 1185|   111k|  c->ReadCallback(&condition_method_pointer);
 1186|   111k|  return (object->*condition_method_pointer)();
 1187|   111k|}
_ZNK4absl12lts_202601079Condition12ReadCallbackIMN13sentencepiece10ThreadPoolEKFbvEEEvPT_:
  945|   111k|  inline void ReadCallback(T* absl_nonnull callback) const {
  946|   111k|    std::memcpy(callback, callback_, sizeof(*callback));
  947|   111k|  }
_ZN4absl12lts_202601079Condition13StoreCallbackIMN13sentencepiece10ThreadPoolEKFbvEEEvT_:
  937|   111k|  inline void StoreCallback(T callback) {
  938|   111k|    static_assert(
  939|   111k|        sizeof(callback) <= sizeof(callback_),
  940|   111k|        "An overlarge pointer was passed as a callback to Condition.");
  941|   111k|    std::memcpy(callback_, &callback, sizeof(callback));
  942|   111k|  }
_ZN4absl12lts_202601075MutexC2Ev:
 1156|  55.7k|inline Mutex::Mutex() : mu_(0) {
 1157|  55.7k|  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
 1158|  55.7k|}
_ZN4absl12lts_202601079ConditionC2IN13sentencepiece10ThreadPoolEEEPKT_MNS0_13type_identityIS5_E4typeEKFbvE:
 1232|   111k|    : eval_(&CastAndCallMethod<const T, decltype(method)>),
 1233|   111k|      arg_(reinterpret_cast<void*>(const_cast<T*>(object))) {
 1234|   111k|  StoreCallback(method);
 1235|   111k|}
_ZN4absl12lts_202601075MutexD2Ev:
 1164|  55.6k|inline Mutex::~Mutex() { Dtor(); }

_ZN4absl12lts_2026010716compare_internal27compare_result_as_less_thanIbTnNSt3__19enable_ifIXsr3std7is_sameIbT_EE5valueEiE4typeELi0EEEbS5_:
  453|  2.66M|constexpr bool compare_result_as_less_than(const BoolT r) {
  454|  2.66M|  return r;
  455|  2.66M|}

_ZN4absl12lts_2026010713MakeConstSpanITpTnRiJEKjEENS0_4SpanIKT0_EEPS5_m:
  798|  1.46k|    T* absl_nullable ptr ABSL_ATTRIBUTE_LIFETIME_BOUND, size_t size) noexcept {
  799|  1.46k|  return Span<const T>(ptr, size);
  800|  1.46k|}
_ZN4absl12lts_202601074SpanIKNS0_19str_format_internal13FormatArgImplEEC2IS4_S4_EESt16initializer_listIS3_E:
  310|   646k|      : Span(v.begin(), v.size()) {}
_ZN4absl12lts_202601074SpanIKNS0_19str_format_internal13FormatArgImplEEC2EPS4_m:
  230|   646k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202601074SpanIjEC2EPjm:
  230|  1.47k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202601074SpanIKjEC2EPS2_m:
  230|  1.47k|      : ptr_(array), len_(length) {}

_ZN5Darts7Details15DoubleArrayUnitC2Ev:
   52|  47.2M|  DoubleArrayUnit() : unit_() {}
_ZNK5Darts7Details15DoubleArrayUnit8has_leafEv:
   56|   631M|  bool has_leaf() const {
   57|   631M|    return ((unit_ >> 8) & 1) == 1;
   58|   631M|  }
_ZNK5Darts7Details15DoubleArrayUnit5valueEv:
   61|   236M|  value_type value() const {
   62|   236M|    return static_cast<value_type>(unit_ & ((1U << 31) - 1));
   63|   236M|  }
_ZNK5Darts7Details15DoubleArrayUnit5labelEv:
   68|  1.66G|  id_type label() const {
   69|  1.66G|    return unit_ & ((1U << 31) | 0xFF);
   70|  1.66G|  }
_ZNK5Darts7Details15DoubleArrayUnit6offsetEv:
   72|  1.37G|  id_type offset() const {
   73|  1.37G|    return (unit_ >> 10) << ((unit_ & (1U << 9)) >> 6);
   74|  1.37G|  }
_ZN5Darts7Details9BitVectorC2Ev:
  796|  52.3k|  BitVector() : units_(), ranks_(), num_ones_(0), size_(0) {}
_ZN5Darts7Details9BitVectorD2Ev:
  797|  52.3k|  ~BitVector() {
  798|  52.3k|    clear();
  799|  52.3k|  }
_ZNK5Darts7Details9BitVectorixEm:
  801|  51.1M|  bool operator[](std::size_t id) const {
  802|  51.1M|    return (units_[id / UNIT_SIZE] >> (id % UNIT_SIZE) & 1) == 1;
  803|  51.1M|  }
_ZNK5Darts7Details9BitVector8num_onesEv:
  822|   104k|  std::size_t num_ones() const {
  823|   104k|    return num_ones_;
  824|   104k|  }
_ZNK5Darts7Details9BitVector4sizeEv:
  825|  33.4M|  std::size_t size() const {
  826|  33.4M|    return size_;
  827|  33.4M|  }
_ZN5Darts7Details9BitVector6appendEv:
  829|  33.4M|  void append() {
  830|  33.4M|    if ((size_ % UNIT_SIZE) == 0) {
  ------------------
  |  Branch (830:9): [True: 1.06M, False: 32.3M]
  ------------------
  831|  1.06M|      units_.append(0);
  832|  1.06M|    }
  833|  33.4M|    ++size_;
  834|  33.4M|  }
_ZN5Darts7Details9BitVector5clearEv:
  837|   157k|  void clear() {
  838|   157k|    units_.clear();
  839|   157k|    ranks_.clear();
  840|   157k|  }
_ZN5Darts7Details9BitVector9pop_countEj:
  854|  1.06M|  static id_type pop_count(id_type unit) {
  855|  1.06M|    unit = ((unit & 0xAAAAAAAA) >> 1) + (unit & 0x55555555);
  856|  1.06M|    unit = ((unit & 0xCCCCCCCC) >> 2) + (unit & 0x33333333);
  857|  1.06M|    unit = ((unit >> 4) + unit) & 0x0F0F0F0F;
  858|  1.06M|    unit += unit >> 8;
  859|  1.06M|    unit += unit >> 16;
  860|  1.06M|    return unit & 0xFF;
  861|  1.06M|  }
_ZN5Darts7Details8DawgNodeC2Ev:
  942|  33.4M|  DawgNode() : child_(0), sibling_(0), label_('\0'),
  943|  33.4M|    is_state_(false), has_sibling_(false) {}
_ZN5Darts7Details8DawgNode9set_childEj:
  945|  58.9M|  void set_child(id_type child) {
  946|  58.9M|    child_ = child;
  947|  58.9M|  }
_ZN5Darts7Details8DawgNode11set_siblingEj:
  948|  33.3M|  void set_sibling(id_type sibling) {
  949|  33.3M|    sibling_ = sibling;
  950|  33.3M|  }
_ZN5Darts7Details8DawgNode9set_valueEi:
  951|  7.83M|  void set_value(value_type value) {
  952|  7.83M|    child_ = value;
  953|  7.83M|  }
_ZN5Darts7Details8DawgNode9set_labelEh:
  954|  33.4M|  void set_label(uchar_type label) {
  955|  33.4M|    label_ = label;
  956|  33.4M|  }
_ZN5Darts7Details8DawgNode12set_is_stateEb:
  957|  25.5M|  void set_is_state(bool is_state) {
  958|  25.5M|    is_state_ = is_state;
  959|  25.5M|  }
_ZN5Darts7Details8DawgNode15set_has_siblingEb:
  960|  7.78M|  void set_has_sibling(bool has_sibling) {
  961|  7.78M|    has_sibling_ = has_sibling;
  962|  7.78M|  }
_ZNK5Darts7Details8DawgNode5childEv:
  964|  96.6M|  id_type child() const {
  965|  96.6M|    return child_;
  966|  96.6M|  }
_ZNK5Darts7Details8DawgNode7siblingEv:
  967|   167M|  id_type sibling() const {
  968|   167M|    return sibling_;
  969|   167M|  }
_ZNK5Darts7Details8DawgNode5labelEv:
  973|  96.6M|  uchar_type label() const {
  974|  96.6M|    return label_;
  975|  96.6M|  }
_ZNK5Darts7Details8DawgNode4unitEv:
  983|  93.6M|  id_type unit() const {
  984|  93.6M|    if (label_ == '\0') {
  ------------------
  |  Branch (984:9): [True: 21.0M, False: 72.6M]
  ------------------
  985|  21.0M|      return (child_ << 1) | (has_sibling_ ? 1 : 0);
  ------------------
  |  Branch (985:31): [True: 4.50M, False: 16.5M]
  ------------------
  986|  21.0M|    }
  987|  72.6M|    return (child_ << 2) | (is_state_ ? 2 : 0) | (has_sibling_ ? 1 : 0);
  ------------------
  |  Branch (987:29): [True: 56.7M, False: 15.8M]
  |  Branch (987:51): [True: 11.0M, False: 61.5M]
  ------------------
  988|  93.6M|  }
_ZN5Darts7Details8DawgUnitC2Ej:
 1006|  33.4M|  explicit DawgUnit(id_type unit = 0) : unit_(unit) {}
_ZN5Darts7Details8DawgUnitC2ERKS1_:
 1007|  48.0M|  DawgUnit(const DawgUnit &unit) : unit_(unit.unit_) {}
_ZN5Darts7Details8DawgUnitaSEj:
 1009|  33.4M|  DawgUnit &operator=(id_type unit) {
 1010|  33.4M|    unit_ = unit;
 1011|  33.4M|    return *this;
 1012|  33.4M|  }
_ZNK5Darts7Details8DawgUnit4unitEv:
 1014|  47.4M|  id_type unit() const {
 1015|  47.4M|    return unit_;
 1016|  47.4M|  }
_ZNK5Darts7Details8DawgUnit5childEv:
 1018|  76.7M|  id_type child() const {
 1019|  76.7M|    return unit_ >> 2;
 1020|  76.7M|  }
_ZNK5Darts7Details8DawgUnit11has_siblingEv:
 1021|   154M|  bool has_sibling() const {
 1022|   154M|    return (unit_ & 1) == 1;
 1023|   154M|  }
_ZNK5Darts7Details8DawgUnit5valueEv:
 1024|  7.83M|  value_type value() const {
 1025|  7.83M|    return static_cast<value_type>(unit_ >> 1);
 1026|  7.83M|  }
_ZNK5Darts7Details8DawgUnit8is_stateEv:
 1027|  15.8M|  bool is_state() const {
 1028|  15.8M|    return (unit_ & 2) == 2;
 1029|  15.8M|  }
_ZN5Darts7Details11DawgBuilderC2Ev:
 1043|  52.3k|  DawgBuilder() : nodes_(), units_(), labels_(), is_intersections_(),
 1044|  52.3k|    table_(), node_stack_(), recycle_bin_(), num_states_(0) {}
_ZN5Darts7Details11DawgBuilderD2Ev:
 1045|  52.3k|  ~DawgBuilder() {
 1046|  52.3k|    clear();
 1047|  52.3k|  }
_ZNK5Darts7Details11DawgBuilder4rootEv:
 1049|   104k|  id_type root() const {
 1050|   104k|    return 0;
 1051|   104k|  }
_ZNK5Darts7Details11DawgBuilder5childEj:
 1053|  76.7M|  id_type child(id_type id) const {
 1054|  76.7M|    return units_[id].child();
 1055|  76.7M|  }
_ZNK5Darts7Details11DawgBuilder7siblingEj:
 1056|   100M|  id_type sibling(id_type id) const {
 1057|   100M|    return units_[id].has_sibling() ? (id + 1) : 0;
  ------------------
  |  Branch (1057:12): [True: 23.3M, False: 76.7M]
  ------------------
 1058|   100M|  }
_ZNK5Darts7Details11DawgBuilder5valueEj:
 1059|  7.83M|  int value(id_type id) const {
 1060|  7.83M|    return units_[id].value();
 1061|  7.83M|  }
_ZNK5Darts7Details11DawgBuilder7is_leafEj:
 1063|  33.3M|  bool is_leaf(id_type id) const {
 1064|  33.3M|    return label(id) == '\0';
 1065|  33.3M|  }
_ZNK5Darts7Details11DawgBuilder5labelEj:
 1066|   100M|  uchar_type label(id_type id) const {
 1067|   100M|    return labels_[id];
 1068|   100M|  }
_ZNK5Darts7Details11DawgBuilder15is_intersectionEj:
 1070|  51.1M|  bool is_intersection(id_type id) const {
 1071|  51.1M|    return is_intersections_[id];
 1072|  51.1M|  }
_ZNK5Darts7Details11DawgBuilder17num_intersectionsEv:
 1077|   104k|  std::size_t num_intersections() const {
 1078|   104k|    return is_intersections_.num_ones();
 1079|   104k|  }
_ZNK5Darts7Details11DawgBuilder4sizeEv:
 1081|   502k|  std::size_t size() const {
 1082|   502k|    return units_.size();
 1083|   502k|  }
_ZN5Darts7Details11DawgBuilder9free_nodeEj:
 1123|  33.3M|  void free_node(id_type id) {
 1124|  33.3M|    recycle_bin_.push(id);
 1125|  33.3M|  }
_ZN5Darts7Details11DawgBuilder4hashEj:
 1127|  53.9M|  static id_type hash(id_type key) {
 1128|  53.9M|    key = ~key + (key << 15);  // key = (key << 15) - key - 1;
 1129|  53.9M|    key = key ^ (key >> 12);
 1130|  53.9M|    key = key + (key << 2);
 1131|  53.9M|    key = key ^ (key >> 4);
 1132|  53.9M|    key = key * 2057;  // key = (key + (key << 3)) + (key << 11);
 1133|  53.9M|    key = key ^ (key >> 16);
 1134|  53.9M|    return key;
 1135|  53.9M|  }
_ZN5Darts7Details22DoubleArrayBuilderUnitC2Ev:
 1389|  47.2M|  DoubleArrayBuilderUnit() : unit_(0) {}
_ZN5Darts7Details22DoubleArrayBuilderUnit12set_has_leafEb:
 1391|  7.89M|  void set_has_leaf(bool has_leaf) {
 1392|  7.89M|    if (has_leaf) {
  ------------------
  |  Branch (1392:9): [True: 7.89M, False: 0]
  ------------------
 1393|  7.89M|      unit_ |= 1U << 8;
 1394|  7.89M|    } else {
 1395|      0|      unit_ &= ~(1U << 8);
 1396|      0|    }
 1397|  7.89M|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit9set_valueEi:
 1398|  7.89M|  void set_value(value_type value) {
 1399|  7.89M|    unit_ = value | (1U << 31);
 1400|  7.89M|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit9set_labelEh:
 1401|  39.3M|  void set_label(uchar_type label) {
 1402|  39.3M|    unit_ = (unit_ & ~0xFFU) | label;
 1403|  39.3M|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit10set_offsetEj:
 1404|  25.7M|  void set_offset(id_type offset) {
 1405|  25.7M|    if (offset >= 1U << 29) {
  ------------------
  |  Branch (1405:9): [True: 0, False: 25.7M]
  ------------------
 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|  25.7M|    unit_ &= (1U << 31) | (1U << 8) | 0xFF;
 1409|  25.7M|    if (offset < 1U << 21) {
  ------------------
  |  Branch (1409:9): [True: 25.7M, False: 0]
  ------------------
 1410|  25.7M|      unit_ |= (offset << 10);
 1411|  25.7M|    } else {
 1412|      0|      unit_ |= (offset << 2) | (1U << 9);
 1413|      0|    }
 1414|  25.7M|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnitC2Ev:
 1428|   256M|  DoubleArrayBuilderExtraUnit() : prev_(0), next_(0),
 1429|   256M|      is_fixed_(false), is_used_(false) {}
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit8set_prevEj:
 1431|  94.8M|  void set_prev(id_type prev) {
 1432|  94.8M|    prev_ = prev;
 1433|  94.8M|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit8set_nextEj:
 1434|  94.8M|  void set_next(id_type next) {
 1435|  94.8M|    next_ = next;
 1436|  94.8M|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit12set_is_fixedEb:
 1437|  49.3M|  void set_is_fixed(bool is_fixed) {
 1438|  49.3M|    is_fixed_ = is_fixed;
 1439|  49.3M|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit11set_is_usedEb:
 1440|  27.8M|  void set_is_used(bool is_used) {
 1441|  27.8M|    is_used_ = is_used;
 1442|  27.8M|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit4prevEv:
 1444|  94.8M|  id_type prev() const {
 1445|  94.8M|    return prev_;
 1446|  94.8M|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit4nextEv:
 1447|   317M|  id_type next() const {
 1448|   317M|    return next_;
 1449|   317M|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit8is_fixedEv:
 1450|  94.6M|  bool is_fixed() const {
 1451|  94.6M|    return is_fixed_;
 1452|  94.6M|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit7is_usedEv:
 1453|   231M|  bool is_used() const {
 1454|   231M|    return is_used_;
 1455|   231M|  }
_ZN5Darts7Details18DoubleArrayBuilderC2EPFimmE:
 1473|  62.5k|      : progress_func_(progress_func), units_(), extras_(), labels_(),
 1474|  62.5k|        table_(), extras_head_(0) {}
_ZN5Darts7Details18DoubleArrayBuilderD2Ev:
 1475|  62.5k|  ~DoubleArrayBuilder() {
 1476|  62.5k|    clear();
 1477|  62.5k|  }
_ZNK5Darts7Details18DoubleArrayBuilder10num_blocksEv:
 1507|   310k|  std::size_t num_blocks() const {
 1508|   310k|    return units_.size() / BLOCK_SIZE;
 1509|   310k|  }
_ZNK5Darts7Details18DoubleArrayBuilder6extrasEj:
 1511|   480M|  const extra_type &extras(id_type id) const {
 1512|   480M|    return extras_[id % NUM_EXTRAS];
 1513|   480M|  }
_ZN5Darts7Details18DoubleArrayBuilder6extrasEj:
 1514|   524M|  extra_type &extras(id_type id) {
 1515|   524M|    return extras_[id % NUM_EXTRAS];
 1516|   524M|  }
_ZN5Darts7Details9BitVector5buildEv:
  864|  52.3k|inline void BitVector::build() {
  865|  52.3k|  try {
  866|  52.3k|    ranks_.reset(new id_type[units_.size()]);
  867|  52.3k|  } 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|  52.3k|  num_ones_ = 0;
  872|  1.12M|  for (std::size_t i = 0; i < units_.size(); ++i) {
  ------------------
  |  Branch (872:27): [True: 1.06M, False: 52.3k]
  ------------------
  873|  1.06M|    ranks_[i] = num_ones_;
  874|  1.06M|    num_ones_ += pop_count(units_[i]);
  875|  1.06M|  }
  876|  52.3k|}
_ZN5Darts7Details11DawgBuilder4initEv:
 1138|  52.3k|inline void DawgBuilder::init() {
 1139|  52.3k|  table_.resize(INITIAL_TABLE_SIZE, 0);
 1140|       |
 1141|  52.3k|  append_node();
 1142|  52.3k|  append_unit();
 1143|       |
 1144|  52.3k|  num_states_ = 1;
 1145|       |
 1146|  52.3k|  nodes_[0].set_label(0xFF);
 1147|  52.3k|  node_stack_.push(0);
 1148|  52.3k|}
_ZN5Darts7Details11DawgBuilder6finishEv:
 1150|  52.3k|inline void DawgBuilder::finish() {
 1151|  52.3k|  flush(0);
 1152|       |
 1153|  52.3k|  units_[0] = nodes_[0].unit();
 1154|  52.3k|  labels_[0] = nodes_[0].label();
 1155|       |
 1156|  52.3k|  nodes_.clear();
 1157|  52.3k|  table_.clear();
 1158|  52.3k|  node_stack_.clear();
 1159|  52.3k|  recycle_bin_.clear();
 1160|       |
 1161|  52.3k|  is_intersections_.build();
 1162|  52.3k|}
_ZN5Darts7Details11DawgBuilder6insertEPKcmi:
 1165|  7.83M|    value_type value) {
 1166|  7.83M|  if (value < 0) {
  ------------------
  |  Branch (1166:7): [True: 0, False: 7.83M]
  ------------------
 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|  7.83M|  } else if (length == 0) {
  ------------------
  |  Branch (1168:14): [True: 0, False: 7.83M]
  ------------------
 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|  7.83M|  id_type id = 0;
 1173|  7.83M|  std::size_t key_pos = 0;
 1174|       |
 1175|  29.9M|  for ( ; key_pos <= length; ++key_pos) {
  ------------------
  |  Branch (1175:11): [True: 29.9M, False: 0]
  ------------------
 1176|  29.9M|    id_type child_id = nodes_[id].child();
 1177|  29.9M|    if (child_id == 0) {
  ------------------
  |  Branch (1177:9): [True: 52.3k, False: 29.8M]
  ------------------
 1178|  52.3k|      break;
 1179|  52.3k|    }
 1180|       |
 1181|  29.8M|    uchar_type key_label = static_cast<uchar_type>(key[key_pos]);
 1182|  29.8M|    if (key_pos < length && key_label == '\0') {
  ------------------
  |  Branch (1182:9): [True: 29.8M, False: 0]
  |  Branch (1182:29): [True: 0, False: 29.8M]
  ------------------
 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|  29.8M|    uchar_type unit_label = nodes_[child_id].label();
 1187|  29.8M|    if (key_label < unit_label) {
  ------------------
  |  Branch (1187:9): [True: 0, False: 29.8M]
  ------------------
 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|  29.8M|    } else if (key_label > unit_label) {
  ------------------
  |  Branch (1189:16): [True: 7.78M, False: 22.0M]
  ------------------
 1190|  7.78M|      nodes_[child_id].set_has_sibling(true);
 1191|  7.78M|      flush(child_id);
 1192|  7.78M|      break;
 1193|  7.78M|    }
 1194|  22.0M|    id = child_id;
 1195|  22.0M|  }
 1196|       |
 1197|  7.83M|  if (key_pos > length) {
  ------------------
  |  Branch (1197:7): [True: 0, False: 7.83M]
  ------------------
 1198|      0|    return;
 1199|      0|  }
 1200|       |
 1201|  41.1M|  for ( ; key_pos <= length; ++key_pos) {
  ------------------
  |  Branch (1201:11): [True: 33.3M, False: 7.83M]
  ------------------
 1202|  33.3M|    uchar_type key_label = static_cast<uchar_type>(
 1203|  33.3M|        (key_pos < length) ? key[key_pos] : '\0');
  ------------------
  |  Branch (1203:9): [True: 25.5M, False: 7.83M]
  ------------------
 1204|  33.3M|    id_type child_id = append_node();
 1205|       |
 1206|  33.3M|    if (nodes_[id].child() == 0) {
  ------------------
  |  Branch (1206:9): [True: 25.5M, False: 7.78M]
  ------------------
 1207|  25.5M|      nodes_[child_id].set_is_state(true);
 1208|  25.5M|    }
 1209|  33.3M|    nodes_[child_id].set_sibling(nodes_[id].child());
 1210|  33.3M|    nodes_[child_id].set_label(key_label);
 1211|  33.3M|    nodes_[id].set_child(child_id);
 1212|  33.3M|    node_stack_.push(child_id);
 1213|       |
 1214|  33.3M|    id = child_id;
 1215|  33.3M|  }
 1216|  7.83M|  nodes_[id].set_value(value);
 1217|  7.83M|}
_ZN5Darts7Details11DawgBuilder5clearEv:
 1219|   104k|inline void DawgBuilder::clear() {
 1220|   104k|  nodes_.clear();
 1221|   104k|  units_.clear();
 1222|   104k|  labels_.clear();
 1223|   104k|  is_intersections_.clear();
 1224|   104k|  table_.clear();
 1225|   104k|  node_stack_.clear();
 1226|   104k|  recycle_bin_.clear();
 1227|   104k|  num_states_ = 0;
 1228|   104k|}
_ZN5Darts7Details11DawgBuilder5flushEj:
 1230|  7.83M|inline void DawgBuilder::flush(id_type id) {
 1231|  33.4M|  while (node_stack_.top() != id) {
  ------------------
  |  Branch (1231:10): [True: 25.5M, False: 7.83M]
  ------------------
 1232|  25.5M|    id_type node_id = node_stack_.top();
 1233|  25.5M|    node_stack_.pop();
 1234|       |
 1235|  25.5M|    if (num_states_ >= table_.size() - (table_.size() >> 2)) {
  ------------------
  |  Branch (1235:9): [True: 14.4k, False: 25.5M]
  ------------------
 1236|  14.4k|      expand_table();
 1237|  14.4k|    }
 1238|       |
 1239|  25.5M|    id_type num_siblings = 0;
 1240|  58.9M|    for (id_type i = node_id; i != 0; i = nodes_[i].sibling()) {
  ------------------
  |  Branch (1240:31): [True: 33.3M, False: 25.5M]
  ------------------
 1241|  33.3M|      ++num_siblings;
 1242|  33.3M|    }
 1243|       |
 1244|  25.5M|    id_type hash_id;
 1245|  25.5M|    id_type match_id = find_node(node_id, &hash_id);
 1246|  25.5M|    if (match_id != 0) {
  ------------------
  |  Branch (1246:9): [True: 0, False: 25.5M]
  ------------------
 1247|      0|      is_intersections_.set(match_id, true);
 1248|  25.5M|    } else {
 1249|  25.5M|      id_type unit_id = 0;
 1250|  58.9M|      for (id_type i = 0; i < num_siblings; ++i) {
  ------------------
  |  Branch (1250:27): [True: 33.3M, False: 25.5M]
  ------------------
 1251|  33.3M|        unit_id = append_unit();
 1252|  33.3M|      }
 1253|  58.9M|      for (id_type i = node_id; i != 0; i = nodes_[i].sibling()) {
  ------------------
  |  Branch (1253:33): [True: 33.3M, False: 25.5M]
  ------------------
 1254|  33.3M|        units_[unit_id] = nodes_[i].unit();
 1255|  33.3M|        labels_[unit_id] = nodes_[i].label();
 1256|  33.3M|        --unit_id;
 1257|  33.3M|      }
 1258|  25.5M|      match_id = unit_id + 1;
 1259|  25.5M|      table_[hash_id] = match_id;
 1260|  25.5M|      ++num_states_;
 1261|  25.5M|    }
 1262|       |
 1263|  58.9M|    for (id_type i = node_id, next; i != 0; i = next) {
  ------------------
  |  Branch (1263:37): [True: 33.3M, False: 25.5M]
  ------------------
 1264|  33.3M|      next = nodes_[i].sibling();
 1265|  33.3M|      free_node(i);
 1266|  33.3M|    }
 1267|       |
 1268|  25.5M|    nodes_[node_stack_.top()].set_child(match_id);
 1269|  25.5M|  }
 1270|  7.83M|  node_stack_.pop();
 1271|  7.83M|}
_ZN5Darts7Details11DawgBuilder12expand_tableEv:
 1273|  14.4k|inline void DawgBuilder::expand_table() {
 1274|  14.4k|  std::size_t table_size = table_.size() << 1;
 1275|  14.4k|  table_.clear();
 1276|  14.4k|  table_.resize(table_size, 0);
 1277|       |
 1278|  20.5M|  for (std::size_t i = 1; i < units_.size(); ++i) {
  ------------------
  |  Branch (1278:27): [True: 20.5M, False: 14.4k]
  ------------------
 1279|  20.5M|    id_type id = static_cast<id_type>(i);
 1280|  20.5M|    if (labels_[id] == '\0' || units_[id].is_state()) {
  ------------------
  |  Branch (1280:9): [True: 4.70M, False: 15.8M]
  |  Branch (1280:32): [True: 11.7M, False: 4.10M]
  ------------------
 1281|  16.4M|      id_type hash_id;
 1282|  16.4M|      find_unit(id, &hash_id);
 1283|  16.4M|      table_[hash_id] = id;
 1284|  16.4M|    }
 1285|  20.5M|  }
 1286|  14.4k|}
_ZNK5Darts7Details11DawgBuilder9find_unitEjPj:
 1288|  16.4M|inline id_type DawgBuilder::find_unit(id_type id, id_type *hash_id) const {
 1289|  16.4M|  *hash_id = hash_unit(id) % table_.size();
 1290|  21.4M|  for ( ; ; *hash_id = (*hash_id + 1) % table_.size()) {
 1291|  21.4M|    id_type unit_id = table_[*hash_id];
 1292|  21.4M|    if (unit_id == 0) {
  ------------------
  |  Branch (1292:9): [True: 16.4M, False: 4.94M]
  ------------------
 1293|  16.4M|      break;
 1294|  16.4M|    }
 1295|       |
 1296|       |    // There must not be the same unit.
 1297|  21.4M|  }
 1298|  16.4M|  return 0;
 1299|  16.4M|}
_ZNK5Darts7Details11DawgBuilder9find_nodeEjPj:
 1302|  25.5M|    id_type *hash_id) const {
 1303|  25.5M|  *hash_id = hash_node(node_id) % table_.size();
 1304|  59.1M|  for ( ; ; *hash_id = (*hash_id + 1) % table_.size()) {
 1305|  59.1M|    id_type unit_id = table_[*hash_id];
 1306|  59.1M|    if (unit_id == 0) {
  ------------------
  |  Branch (1306:9): [True: 25.5M, False: 33.5M]
  ------------------
 1307|  25.5M|      break;
 1308|  25.5M|    }
 1309|       |
 1310|  33.5M|    if (are_equal(node_id, unit_id)) {
  ------------------
  |  Branch (1310:9): [True: 0, False: 33.5M]
  ------------------
 1311|      0|      return unit_id;
 1312|      0|    }
 1313|  33.5M|  }
 1314|  25.5M|  return 0;
 1315|  25.5M|}
_ZNK5Darts7Details11DawgBuilder9are_equalEjj:
 1317|  33.5M|inline bool DawgBuilder::are_equal(id_type node_id, id_type unit_id) const {
 1318|  34.3M|  for (id_type i = nodes_[node_id].sibling(); i != 0;
  ------------------
  |  Branch (1318:47): [True: 4.05M, False: 30.2M]
  ------------------
 1319|  33.5M|      i = nodes_[i].sibling()) {
 1320|  4.05M|    if (units_[unit_id].has_sibling() == false) {
  ------------------
  |  Branch (1320:9): [True: 3.30M, False: 750k]
  ------------------
 1321|  3.30M|      return false;
 1322|  3.30M|    }
 1323|   750k|    ++unit_id;
 1324|   750k|  }
 1325|  30.2M|  if (units_[unit_id].has_sibling() == true) {
  ------------------
  |  Branch (1325:7): [True: 3.39M, False: 26.8M]
  ------------------
 1326|  3.39M|    return false;
 1327|  3.39M|  }
 1328|       |
 1329|  26.8M|  for (id_type i = node_id; i != 0; i = nodes_[i].sibling(), --unit_id) {
  ------------------
  |  Branch (1329:29): [True: 26.8M, False: 0]
  ------------------
 1330|  26.8M|    if (nodes_[i].unit() != units_[unit_id].unit() ||
  ------------------
  |  Branch (1330:9): [True: 26.8M, False: 1.61k]
  ------------------
 1331|  26.8M|        nodes_[i].label() != labels_[unit_id]) {
  ------------------
  |  Branch (1331:9): [True: 1.61k, False: 0]
  ------------------
 1332|  26.8M|      return false;
 1333|  26.8M|    }
 1334|  26.8M|  }
 1335|      0|  return true;
 1336|  26.8M|}
_ZNK5Darts7Details11DawgBuilder9hash_unitEj:
 1338|  16.4M|inline id_type DawgBuilder::hash_unit(id_type id) const {
 1339|  16.4M|  id_type hash_value = 0;
 1340|  20.5M|  for ( ; id != 0; ++id) {
  ------------------
  |  Branch (1340:11): [True: 20.5M, False: 0]
  ------------------
 1341|  20.5M|    id_type unit = units_[id].unit();
 1342|  20.5M|    uchar_type label = labels_[id];
 1343|  20.5M|    hash_value ^= hash((label << 24) ^ unit);
 1344|       |
 1345|  20.5M|    if (units_[id].has_sibling() == false) {
  ------------------
  |  Branch (1345:9): [True: 16.4M, False: 4.10M]
  ------------------
 1346|  16.4M|      break;
 1347|  16.4M|    }
 1348|  20.5M|  }
 1349|  16.4M|  return hash_value;
 1350|  16.4M|}
_ZNK5Darts7Details11DawgBuilder9hash_nodeEj:
 1352|  25.5M|inline id_type DawgBuilder::hash_node(id_type id) const {
 1353|  25.5M|  id_type hash_value = 0;
 1354|  58.9M|  for ( ; id != 0; id = nodes_[id].sibling()) {
  ------------------
  |  Branch (1354:11): [True: 33.3M, False: 25.5M]
  ------------------
 1355|  33.3M|    id_type unit = nodes_[id].unit();
 1356|  33.3M|    uchar_type label = nodes_[id].label();
 1357|  33.3M|    hash_value ^= hash((label << 24) ^ unit);
 1358|  33.3M|  }
 1359|  25.5M|  return hash_value;
 1360|  25.5M|}
_ZN5Darts7Details11DawgBuilder11append_unitEv:
 1362|  33.4M|inline id_type DawgBuilder::append_unit() {
 1363|  33.4M|  is_intersections_.append();
 1364|  33.4M|  units_.append();
 1365|  33.4M|  labels_.append();
 1366|       |
 1367|  33.4M|  return static_cast<id_type>(is_intersections_.size() - 1);
 1368|  33.4M|}
_ZN5Darts7Details11DawgBuilder11append_nodeEv:
 1370|  33.4M|inline id_type DawgBuilder::append_node() {
 1371|  33.4M|  id_type id;
 1372|  33.4M|  if (recycle_bin_.empty()) {
  ------------------
  |  Branch (1372:7): [True: 3.40M, False: 30.0M]
  ------------------
 1373|  3.40M|    id = static_cast<id_type>(nodes_.size());
 1374|  3.40M|    nodes_.append();
 1375|  30.0M|  } else {
 1376|  30.0M|    id = recycle_bin_.top();
 1377|  30.0M|    nodes_[id] = DawgNode();
 1378|  30.0M|    recycle_bin_.pop();
 1379|  30.0M|  }
 1380|  33.4M|  return id;
 1381|  33.4M|}
_ZNK5Darts7Details18DoubleArrayBuilder4copyEPmPPNS0_15DoubleArrayUnitE:
 1558|  62.5k|    DoubleArrayUnit **buf_ptr) const {
 1559|  62.5k|  if (size_ptr != NULL) {
  ------------------
  |  Branch (1559:7): [True: 62.5k, False: 0]
  ------------------
 1560|  62.5k|    *size_ptr = units_.size();
 1561|  62.5k|  }
 1562|  62.5k|  if (buf_ptr != NULL) {
  ------------------
  |  Branch (1562:7): [True: 62.5k, False: 0]
  ------------------
 1563|  62.5k|    *buf_ptr = new DoubleArrayUnit[units_.size()];
 1564|  62.5k|    unit_type *units = reinterpret_cast<unit_type *>(*buf_ptr);
 1565|  47.3M|    for (std::size_t i = 0; i < units_.size(); ++i) {
  ------------------
  |  Branch (1565:29): [True: 47.2M, False: 62.5k]
  ------------------
 1566|  47.2M|      units[i] = units_[i];
 1567|  47.2M|    }
 1568|  62.5k|  }
 1569|  62.5k|}
_ZN5Darts7Details18DoubleArrayBuilder5clearEv:
 1571|  62.5k|inline void DoubleArrayBuilder::clear() {
 1572|  62.5k|  units_.clear();
 1573|  62.5k|  extras_.clear();
 1574|  62.5k|  labels_.clear();
 1575|  62.5k|  table_.clear();
 1576|  62.5k|  extras_head_ = 0;
 1577|  62.5k|}
_ZN5Darts7Details18DoubleArrayBuilder15build_from_dawgERKNS0_11DawgBuilderE:
 1592|  52.3k|inline void DoubleArrayBuilder::build_from_dawg(const DawgBuilder &dawg) {
 1593|  52.3k|  std::size_t num_units = 1;
 1594|   502k|  while (num_units < dawg.size()) {
  ------------------
  |  Branch (1594:10): [True: 450k, False: 52.3k]
  ------------------
 1595|   450k|    num_units <<= 1;
 1596|   450k|  }
 1597|  52.3k|  units_.reserve(num_units);
 1598|       |
 1599|  52.3k|  table_.reset(new id_type[dawg.num_intersections()]);
 1600|  52.3k|  for (std::size_t i = 0; i < dawg.num_intersections(); ++i) {
  ------------------
  |  Branch (1600:27): [True: 0, False: 52.3k]
  ------------------
 1601|      0|    table_[i] = 0;
 1602|      0|  }
 1603|       |
 1604|  52.3k|  extras_.reset(new extra_type[NUM_EXTRAS]);
 1605|       |
 1606|  52.3k|  reserve_id(0);
 1607|  52.3k|  extras(0).set_is_used(true);
 1608|  52.3k|  units_[0].set_offset(1);
 1609|  52.3k|  units_[0].set_label('\0');
 1610|       |
 1611|  52.3k|  if (dawg.child(dawg.root()) != 0) {
  ------------------
  |  Branch (1611:7): [True: 52.3k, False: 0]
  ------------------
 1612|  52.3k|    build_from_dawg(dawg, dawg.root(), 0);
 1613|  52.3k|  }
 1614|       |
 1615|  52.3k|  fix_all_blocks();
 1616|       |
 1617|  52.3k|  extras_.clear();
 1618|  52.3k|  labels_.clear();
 1619|  52.3k|  table_.clear();
 1620|  52.3k|}
_ZN5Darts7Details18DoubleArrayBuilder15build_from_dawgERKNS0_11DawgBuilderEjj:
 1623|  25.5M|    id_type dawg_id, id_type dic_id) {
 1624|  25.5M|  id_type dawg_child_id = dawg.child(dawg_id);
 1625|  25.5M|  if (dawg.is_intersection(dawg_child_id)) {
  ------------------
  |  Branch (1625:7): [True: 0, False: 25.5M]
  ------------------
 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|  25.5M|  id_type offset = arrange_from_dawg(dawg, dawg_id, dic_id);
 1641|  25.5M|  if (dawg.is_intersection(dawg_child_id)) {
  ------------------
  |  Branch (1641:7): [True: 0, False: 25.5M]
  ------------------
 1642|      0|    table_[dawg.intersection_id(dawg_child_id)] = offset;
 1643|      0|  }
 1644|       |
 1645|  33.3M|  do {
 1646|  33.3M|    uchar_type child_label = dawg.label(dawg_child_id);
 1647|  33.3M|    id_type dic_child_id = offset ^ child_label;
 1648|  33.3M|    if (child_label != '\0') {
  ------------------
  |  Branch (1648:9): [True: 25.5M, False: 7.83M]
  ------------------
 1649|  25.5M|      build_from_dawg(dawg, dawg_child_id, dic_child_id);
 1650|  25.5M|    }
 1651|  33.3M|    dawg_child_id = dawg.sibling(dawg_child_id);
 1652|  33.3M|  } while (dawg_child_id != 0);
  ------------------
  |  Branch (1652:12): [True: 7.78M, False: 25.5M]
  ------------------
 1653|  25.5M|}
_ZN5Darts7Details18DoubleArrayBuilder17arrange_from_dawgERKNS0_11DawgBuilderEjj:
 1656|  25.5M|    id_type dawg_id, id_type dic_id) {
 1657|  25.5M|  labels_.resize(0);
 1658|       |
 1659|  25.5M|  id_type dawg_child_id = dawg.child(dawg_id);
 1660|  58.9M|  while (dawg_child_id != 0) {
  ------------------
  |  Branch (1660:10): [True: 33.3M, False: 25.5M]
  ------------------
 1661|  33.3M|    labels_.append(dawg.label(dawg_child_id));
 1662|  33.3M|    dawg_child_id = dawg.sibling(dawg_child_id);
 1663|  33.3M|  }
 1664|       |
 1665|  25.5M|  id_type offset = find_valid_offset(dic_id);
 1666|  25.5M|  units_[dic_id].set_offset(dic_id ^ offset);
 1667|       |
 1668|  25.5M|  dawg_child_id = dawg.child(dawg_id);
 1669|  58.9M|  for (std::size_t i = 0; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1669:27): [True: 33.3M, False: 25.5M]
  ------------------
 1670|  33.3M|    id_type dic_child_id = offset ^ labels_[i];
 1671|  33.3M|    reserve_id(dic_child_id);
 1672|       |
 1673|  33.3M|    if (dawg.is_leaf(dawg_child_id)) {
  ------------------
  |  Branch (1673:9): [True: 7.83M, False: 25.5M]
  ------------------
 1674|  7.83M|      units_[dic_id].set_has_leaf(true);
 1675|  7.83M|      units_[dic_child_id].set_value(dawg.value(dawg_child_id));
 1676|  25.5M|    } else {
 1677|  25.5M|      units_[dic_child_id].set_label(labels_[i]);
 1678|  25.5M|    }
 1679|       |
 1680|  33.3M|    dawg_child_id = dawg.sibling(dawg_child_id);
 1681|  33.3M|  }
 1682|  25.5M|  extras(offset).set_is_used(true);
 1683|       |
 1684|  25.5M|  return offset;
 1685|  25.5M|}
_ZNK5Darts7Details18DoubleArrayBuilder17find_valid_offsetEj:
 1793|  25.7M|inline id_type DoubleArrayBuilder::find_valid_offset(id_type id) const {
 1794|  25.7M|  if (extras_head_ >= units_.size()) {
  ------------------
  |  Branch (1794:7): [True: 79, False: 25.7M]
  ------------------
 1795|     79|    return units_.size() | (id & LOWER_MASK);
 1796|     79|  }
 1797|       |
 1798|  25.7M|  id_type unfixed_id = extras_head_;
 1799|   229M|  do {
 1800|   229M|    id_type offset = unfixed_id ^ labels_[0];
 1801|   229M|    if (is_valid_offset(id, offset)) {
  ------------------
  |  Branch (1801:9): [True: 25.6M, False: 203M]
  ------------------
 1802|  25.6M|      return offset;
 1803|  25.6M|    }
 1804|   203M|    unfixed_id = extras(unfixed_id).next();
 1805|   203M|  } while (unfixed_id != extras_head_);
  ------------------
  |  Branch (1805:12): [True: 203M, False: 121k]
  ------------------
 1806|       |
 1807|   121k|  return units_.size() | (id & LOWER_MASK);
 1808|  25.7M|}
_ZNK5Darts7Details18DoubleArrayBuilder15is_valid_offsetEjj:
 1811|   229M|    id_type offset) const {
 1812|   229M|  if (extras(offset).is_used()) {
  ------------------
  |  Branch (1812:7): [True: 178M, False: 50.4M]
  ------------------
 1813|   178M|    return false;
 1814|   178M|  }
 1815|       |
 1816|  50.4M|  id_type rel_offset = id ^ offset;
 1817|  50.4M|  if ((rel_offset & LOWER_MASK) && (rel_offset & UPPER_MASK)) {
  ------------------
  |  Branch (1817:7): [True: 50.3M, False: 101k]
  |  Branch (1817:36): [True: 0, False: 50.3M]
  ------------------
 1818|      0|    return false;
 1819|      0|  }
 1820|       |
 1821|  73.0M|  for (std::size_t i = 1; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1821:27): [True: 47.4M, False: 25.6M]
  ------------------
 1822|  47.4M|    if (extras(offset ^ labels_[i]).is_fixed()) {
  ------------------
  |  Branch (1822:9): [True: 24.8M, False: 22.5M]
  ------------------
 1823|  24.8M|      return false;
 1824|  24.8M|    }
 1825|  47.4M|  }
 1826|       |
 1827|  25.6M|  return true;
 1828|  50.4M|}
_ZN5Darts7Details18DoubleArrayBuilder10reserve_idEj:
 1830|  47.2M|inline void DoubleArrayBuilder::reserve_id(id_type id) {
 1831|  47.2M|  if (id >= units_.size()) {
  ------------------
  |  Branch (1831:7): [True: 184k, False: 47.0M]
  ------------------
 1832|   184k|    expand_units();
 1833|   184k|  }
 1834|       |
 1835|  47.2M|  if (id == extras_head_) {
  ------------------
  |  Branch (1835:7): [True: 19.0M, False: 28.2M]
  ------------------
 1836|  19.0M|    extras_head_ = extras(id).next();
 1837|  19.0M|    if (extras_head_ == id) {
  ------------------
  |  Branch (1837:9): [True: 62.5k, False: 18.9M]
  ------------------
 1838|  62.5k|      extras_head_ = units_.size();
 1839|  62.5k|    }
 1840|  19.0M|  }
 1841|  47.2M|  extras(extras(id).prev()).set_next(extras(id).next());
 1842|  47.2M|  extras(extras(id).next()).set_prev(extras(id).prev());
 1843|  47.2M|  extras(id).set_is_fixed(true);
 1844|  47.2M|}
_ZN5Darts7Details18DoubleArrayBuilder12expand_unitsEv:
 1846|   184k|inline void DoubleArrayBuilder::expand_units() {
 1847|   184k|  id_type src_num_units = units_.size();
 1848|   184k|  id_type src_num_blocks = num_blocks();
 1849|       |
 1850|   184k|  id_type dest_num_units = src_num_units + BLOCK_SIZE;
 1851|   184k|  id_type dest_num_blocks = src_num_blocks + 1;
 1852|       |
 1853|   184k|  if (dest_num_blocks > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1853:7): [True: 8.19k, False: 176k]
  ------------------
 1854|  8.19k|    fix_block(src_num_blocks - NUM_EXTRA_BLOCKS);
 1855|  8.19k|  }
 1856|       |
 1857|   184k|  units_.resize(dest_num_units);
 1858|       |
 1859|   184k|  if (dest_num_blocks > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1859:7): [True: 8.19k, False: 176k]
  ------------------
 1860|  2.10M|    for (std::size_t id = src_num_units; id < dest_num_units; ++id) {
  ------------------
  |  Branch (1860:42): [True: 2.09M, False: 8.19k]
  ------------------
 1861|  2.09M|      extras(id).set_is_used(false);
 1862|  2.09M|      extras(id).set_is_fixed(false);
 1863|  2.09M|    }
 1864|  8.19k|  }
 1865|       |
 1866|  47.2M|  for (id_type i = src_num_units + 1; i < dest_num_units; ++i) {
  ------------------
  |  Branch (1866:39): [True: 47.0M, False: 184k]
  ------------------
 1867|  47.0M|    extras(i - 1).set_next(i);
 1868|  47.0M|    extras(i).set_prev(i - 1);
 1869|  47.0M|  }
 1870|       |
 1871|   184k|  extras(src_num_units).set_prev(dest_num_units - 1);
 1872|   184k|  extras(dest_num_units - 1).set_next(src_num_units);
 1873|       |
 1874|   184k|  extras(src_num_units).set_prev(extras(extras_head_).prev());
 1875|   184k|  extras(dest_num_units - 1).set_next(extras_head_);
 1876|       |
 1877|   184k|  extras(extras(extras_head_).prev()).set_next(src_num_units);
 1878|   184k|  extras(extras_head_).set_prev(dest_num_units - 1);
 1879|   184k|}
_ZN5Darts7Details18DoubleArrayBuilder14fix_all_blocksEv:
 1881|  62.5k|inline void DoubleArrayBuilder::fix_all_blocks() {
 1882|  62.5k|  id_type begin = 0;
 1883|  62.5k|  if (num_blocks() > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1883:7): [True: 696, False: 61.8k]
  ------------------
 1884|    696|    begin = num_blocks() - NUM_EXTRA_BLOCKS;
 1885|    696|  }
 1886|  62.5k|  id_type end = num_blocks();
 1887|       |
 1888|   238k|  for (id_type block_id = begin; block_id != end; ++block_id) {
  ------------------
  |  Branch (1888:34): [True: 176k, False: 62.5k]
  ------------------
 1889|   176k|    fix_block(block_id);
 1890|   176k|  }
 1891|  62.5k|}
_ZN5Darts7Details18DoubleArrayBuilder9fix_blockEj:
 1893|   184k|inline void DoubleArrayBuilder::fix_block(id_type block_id) {
 1894|   184k|  id_type begin = block_id * BLOCK_SIZE;
 1895|   184k|  id_type end = begin + BLOCK_SIZE;
 1896|       |
 1897|   184k|  id_type unused_offset = 0;
 1898|  2.26M|  for (id_type offset = begin; offset != end; ++offset) {
  ------------------
  |  Branch (1898:32): [True: 2.26M, False: 3]
  ------------------
 1899|  2.26M|    if (!extras(offset).is_used()) {
  ------------------
  |  Branch (1899:9): [True: 184k, False: 2.07M]
  ------------------
 1900|   184k|      unused_offset = offset;
 1901|   184k|      break;
 1902|   184k|    }
 1903|  2.26M|  }
 1904|       |
 1905|  47.4M|  for (id_type id = begin; id != end; ++id) {
  ------------------
  |  Branch (1905:28): [True: 47.2M, False: 184k]
  ------------------
 1906|  47.2M|    if (!extras(id).is_fixed()) {
  ------------------
  |  Branch (1906:9): [True: 13.6M, False: 33.6M]
  ------------------
 1907|  13.6M|      reserve_id(id);
 1908|  13.6M|      units_[id].set_label(static_cast<uchar_type>(id ^ unused_offset));
 1909|  13.6M|    }
 1910|  47.2M|  }
 1911|   184k|}
_ZN5Darts7Details9AutoArrayIcE5clearEv:
  600|  7.90M|  void clear() {
  601|  7.90M|    if (array_ != NULL) {
  ------------------
  |  Branch (601:9): [True: 2.80M, False: 5.09M]
  ------------------
  602|  2.80M|      delete[] array_;
  603|       |      array_ = NULL;
  604|  2.80M|    }
  605|  7.90M|  }
_ZNK5Darts7Details8AutoPoolIjEixEm:
  633|   131M|  const T &operator[](std::size_t id) const {
  634|   131M|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|   131M|  }
_ZNK5Darts7Details9AutoArrayIcEixEm:
  589|  1.02G|  const T &operator[](std::size_t id) const {
  590|  1.02G|    return array_[id];
  591|  1.02G|  }
_ZN5Darts7Details8AutoPoolIjEixEm:
  636|   488M|  T &operator[](std::size_t id) {
  637|   488M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|   488M|  }
_ZN5Darts7Details9AutoArrayIcEixEm:
  592|  1.52G|  T &operator[](std::size_t id) {
  593|  1.52G|    return array_[id];
  594|  1.52G|  }
_ZNK5Darts7Details8AutoPoolIjE5emptyEv:
  640|  33.4M|  bool empty() const {
  641|  33.4M|    return size_ == 0;
  642|  33.4M|  }
_ZN5Darts7Details8AutoPoolIjE6appendERKj:
  666|  67.8M|  void append(const T &value) {
  667|  67.8M|    if (size_ == capacity_)
  ------------------
  |  Branch (667:9): [True: 931k, False: 66.9M]
  ------------------
  668|   931k|      resize_buf(size_ + 1);
  669|  67.8M|    new(&(*this)[size_++]) T(value);
  670|  67.8M|  }
_ZN5Darts7Details8AutoPoolIjE10resize_bufEm:
  714|   997k|void AutoPool<T>::resize_buf(std::size_t size) {
  715|   997k|  std::size_t capacity;
  716|   997k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 377k, False: 620k]
  ------------------
  717|   377k|    capacity = size;
  718|   620k|  } else {
  719|   620k|    capacity = 1;
  720|  3.00M|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 2.38M, False: 620k]
  ------------------
  721|  2.38M|      capacity <<= 1;
  722|  2.38M|    }
  723|   620k|  }
  724|       |
  725|   997k|  AutoArray<char> buf;
  726|   997k|  try {
  727|   997k|    buf.reset(new char[sizeof(T) * capacity]);
  728|   997k|  } 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|   997k|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 773k, False: 223k]
  ------------------
  733|   773k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|   773k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|  9.05M|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 8.27M, False: 773k]
  ------------------
  736|  8.27M|      new(&dest[i]) T(src[i]);
  737|  8.27M|      src[i].~T();
  738|  8.27M|    }
  739|   773k|  }
  740|       |
  741|   997k|  buf_.swap(&buf);
  742|   997k|  capacity_ = capacity;
  743|   997k|}
_ZN5Darts7Details9AutoArrayIcE5resetEPc:
  611|  2.80M|  void reset(T *array = NULL) {
  612|  2.80M|    AutoArray(array).swap(this);
  613|  2.80M|  }
_ZN5Darts7Details9AutoArrayIcE4swapEPS2_:
  606|  5.61M|  void swap(AutoArray *array) {
  607|  5.61M|    T *temp = array_;
  608|  5.61M|    array_ = array->array_;
  609|  5.61M|    array->array_ = temp;
  610|  5.61M|  }
_ZN5Darts7Details8AutoPoolIjE5clearEv:
  647|   957k|  void clear() {
  648|   957k|    resize(0);
  649|   957k|    buf_.clear();
  650|   957k|    size_ = 0;
  651|   957k|    capacity_ = 0;
  652|   957k|  }
_ZN5Darts7Details8AutoPoolIjE6resizeEm:
  672|   957k|  void resize(std::size_t size) {
  673|   103M|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 102M, False: 957k]
  ------------------
  674|   102M|      (*this)[--size_].~T();
  675|   102M|    }
  676|   957k|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 957k]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|   957k|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 957k]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|   957k|  }
_ZN5Darts7Details9AutoArrayIjE5clearEv:
  600|   491k|  void clear() {
  601|   491k|    if (array_ != NULL) {
  ------------------
  |  Branch (601:9): [True: 104k, False: 386k]
  ------------------
  602|   104k|      delete[] array_;
  603|       |      array_ = NULL;
  604|   104k|    }
  605|   491k|  }
_ZN5Darts7Details9AutoArrayIjE5resetEPj:
  611|   104k|  void reset(T *array = NULL) {
  612|   104k|    AutoArray(array).swap(this);
  613|   104k|  }
_ZN5Darts7Details9AutoArrayIjE4swapEPS2_:
  606|   104k|  void swap(AutoArray *array) {
  607|   104k|    T *temp = array_;
  608|   104k|    array_ = array->array_;
  609|   104k|    array->array_ = temp;
  610|   104k|  }
_ZNK5Darts7Details8AutoPoolIjE4sizeEv:
  643|   247M|  std::size_t size() const {
  644|   247M|    return size_;
  645|   247M|  }
_ZN5Darts7Details9AutoArrayIjEixEm:
  592|  1.06M|  T &operator[](std::size_t id) {
  593|  1.06M|    return array_[id];
  594|  1.06M|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgUnitEEixEm:
  633|   287M|  const T &operator[](std::size_t id) const {
  634|   287M|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|   287M|  }
_ZNK5Darts7Details8AutoPoolIhEixEm:
  633|   397M|  const T &operator[](std::size_t id) const {
  634|   397M|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|   397M|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgUnitEE4sizeEv:
  643|  21.1M|  std::size_t size() const {
  644|  21.1M|    return size_;
  645|  21.1M|  }
_ZN5Darts7Details9AutoStackIjE4pushERKj:
  771|  66.7M|  void push(const T &value) {
  772|  66.7M|    pool_.push_back(value);
  773|  66.7M|  }
_ZN5Darts7Details8AutoPoolIjE9push_backERKj:
  654|  66.7M|  void push_back(const T &value) {
  655|  66.7M|    append(value);
  656|  66.7M|  }
_ZN5Darts7Details8AutoPoolIjE6resizeEmRKj:
  683|  66.8k|  void resize(std::size_t size, const T &value) {
  684|  66.8k|    while (size_ > size) {
  ------------------
  |  Branch (684:12): [True: 0, False: 66.8k]
  ------------------
  685|      0|      (*this)[--size_].~T();
  686|      0|    }
  687|  66.8k|    if (size > capacity_) {
  ------------------
  |  Branch (687:9): [True: 66.8k, False: 0]
  ------------------
  688|  66.8k|      resize_buf(size);
  689|  66.8k|    }
  690|  97.6M|    while (size_ < size) {
  ------------------
  |  Branch (690:12): [True: 97.6M, False: 66.8k]
  ------------------
  691|  97.6M|      new(&(*this)[size_++]) T(value);
  692|  97.6M|    }
  693|  66.8k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEEixEm:
  636|   497M|  T &operator[](std::size_t id) {
  637|   497M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|   497M|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEEixEm:
  636|   116M|  T &operator[](std::size_t id) {
  637|   116M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|   116M|  }
_ZN5Darts7Details8AutoPoolIhEixEm:
  636|   247M|  T &operator[](std::size_t id) {
  637|   247M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|   247M|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE5clearEv:
  647|   209k|  void clear() {
  648|   209k|    resize(0);
  649|   209k|    buf_.clear();
  650|   209k|    size_ = 0;
  651|   209k|    capacity_ = 0;
  652|   209k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE6resizeEm:
  672|   209k|  void resize(std::size_t size) {
  673|  3.61M|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 3.40M, False: 209k]
  ------------------
  674|  3.40M|      (*this)[--size_].~T();
  675|  3.40M|    }
  676|   209k|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 209k]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|   209k|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 209k]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|   209k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE10resize_bufEm:
  714|   373k|void AutoPool<T>::resize_buf(std::size_t size) {
  715|   373k|  std::size_t capacity;
  716|   373k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 104k, False: 268k]
  ------------------
  717|   104k|    capacity = size;
  718|   268k|  } else {
  719|   268k|    capacity = 1;
  720|  1.39M|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 1.12M, False: 268k]
  ------------------
  721|  1.12M|      capacity <<= 1;
  722|  1.12M|    }
  723|   268k|  }
  724|       |
  725|   373k|  AutoArray<char> buf;
  726|   373k|  try {
  727|   373k|    buf.reset(new char[sizeof(T) * capacity]);
  728|   373k|  } 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|   373k|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 321k, False: 52.3k]
  ------------------
  733|   321k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|   321k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|  5.12M|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 4.80M, False: 321k]
  ------------------
  736|  4.80M|      new(&dest[i]) T(src[i]);
  737|  4.80M|      src[i].~T();
  738|  4.80M|    }
  739|   321k|  }
  740|       |
  741|   373k|  buf_.swap(&buf);
  742|   373k|  capacity_ = capacity;
  743|   373k|}
_ZN5Darts7Details9AutoStackIjE5clearEv:
  778|   419k|  void clear() {
  779|   419k|    pool_.clear();
  780|   419k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE5clearEv:
  647|   157k|  void clear() {
  648|   157k|    resize(0);
  649|   157k|    buf_.clear();
  650|   157k|    size_ = 0;
  651|   157k|    capacity_ = 0;
  652|   157k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE6resizeEm:
  672|   157k|  void resize(std::size_t size) {
  673|  33.5M|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 33.4M, False: 157k]
  ------------------
  674|  33.4M|      (*this)[--size_].~T();
  675|  33.4M|    }
  676|   157k|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 157k]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|   157k|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 157k]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|   157k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE10resize_bufEm:
  714|   502k|void AutoPool<T>::resize_buf(std::size_t size) {
  715|   502k|  std::size_t capacity;
  716|   502k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 104k, False: 398k]
  ------------------
  717|   104k|    capacity = size;
  718|   398k|  } else {
  719|   398k|    capacity = 1;
  720|  2.61M|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 2.21M, False: 398k]
  ------------------
  721|  2.21M|      capacity <<= 1;
  722|  2.21M|    }
  723|   398k|  }
  724|       |
  725|   502k|  AutoArray<char> buf;
  726|   502k|  try {
  727|   502k|    buf.reset(new char[sizeof(T) * capacity]);
  728|   502k|  } 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|   502k|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 450k, False: 52.3k]
  ------------------
  733|   450k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|   450k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|  48.5M|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 48.0M, False: 450k]
  ------------------
  736|  48.0M|      new(&dest[i]) T(src[i]);
  737|  48.0M|      src[i].~T();
  738|  48.0M|    }
  739|   450k|  }
  740|       |
  741|   502k|  buf_.swap(&buf);
  742|   502k|  capacity_ = capacity;
  743|   502k|}
_ZN5Darts7Details8AutoPoolIhE5clearEv:
  647|   344k|  void clear() {
  648|   344k|    resize(0);
  649|   344k|    buf_.clear();
  650|   344k|    size_ = 0;
  651|   344k|    capacity_ = 0;
  652|   344k|  }
_ZN5Darts7Details9AutoStackIjE3topEv:
  760|   114M|  T &top() {
  761|   114M|    return pool_[size() - 1];
  762|   114M|  }
_ZNK5Darts7Details9AutoStackIjE4sizeEv:
  767|   114M|  std::size_t size() const {
  768|   114M|    return pool_.size();
  769|   114M|  }
_ZN5Darts7Details9AutoStackIjE3popEv:
  774|  63.4M|  void pop() {
  775|  63.4M|    pool_.pop_back();
  776|  63.4M|  }
_ZN5Darts7Details8AutoPoolIjE8pop_backEv:
  657|  63.4M|  void pop_back() {
  658|  63.4M|    (*this)[--size_].~T();
  659|  63.4M|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgNodeEEixEm:
  633|   161M|  const T &operator[](std::size_t id) const {
  634|   161M|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|   161M|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE6appendEv:
  661|  33.4M|  void append() {
  662|  33.4M|    if (size_ == capacity_)
  ------------------
  |  Branch (662:9): [True: 502k, False: 32.9M]
  ------------------
  663|   502k|      resize_buf(size_ + 1);
  664|  33.4M|    new(&(*this)[size_++]) T;
  665|  33.4M|  }
_ZN5Darts7Details8AutoPoolIhE6appendEv:
  661|  33.4M|  void append() {
  662|  33.4M|    if (size_ == capacity_)
  ------------------
  |  Branch (662:9): [True: 502k, False: 32.9M]
  ------------------
  663|   502k|      resize_buf(size_ + 1);
  664|  33.4M|    new(&(*this)[size_++]) T;
  665|  33.4M|  }
_ZN5Darts7Details8AutoPoolIhE10resize_bufEm:
  714|   837k|void AutoPool<T>::resize_buf(std::size_t size) {
  715|   837k|  std::size_t capacity;
  716|   837k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 229k, False: 607k]
  ------------------
  717|   229k|    capacity = size;
  718|   607k|  } else {
  719|   607k|    capacity = 1;
  720|  3.57M|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 2.97M, False: 607k]
  ------------------
  721|  2.97M|      capacity <<= 1;
  722|  2.97M|    }
  723|   607k|  }
  724|       |
  725|   837k|  AutoArray<char> buf;
  726|   837k|  try {
  727|   837k|    buf.reset(new char[sizeof(T) * capacity]);
  728|   837k|  } 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|   837k|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 722k, False: 114k]
  ------------------
  733|   722k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|   722k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|  50.9M|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 50.2M, False: 722k]
  ------------------
  736|  50.2M|      new(&dest[i]) T(src[i]);
  737|  50.2M|      src[i].~T();
  738|  50.2M|    }
  739|   722k|  }
  740|       |
  741|   837k|  buf_.swap(&buf);
  742|   837k|  capacity_ = capacity;
  743|   837k|}
_ZNK5Darts7Details9AutoStackIjE5emptyEv:
  764|  33.4M|  bool empty() const {
  765|  33.4M|    return pool_.empty();
  766|  33.4M|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgNodeEE4sizeEv:
  643|  3.40M|  std::size_t size() const {
  644|  3.40M|    return size_;
  645|  3.40M|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE6appendEv:
  661|  3.40M|  void append() {
  662|  3.40M|    if (size_ == capacity_)
  ------------------
  |  Branch (662:9): [True: 373k, False: 3.03M]
  ------------------
  663|   373k|      resize_buf(size_ + 1);
  664|  3.40M|    new(&(*this)[size_++]) T;
  665|  3.40M|  }
_ZNK5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE4sizeEv:
  643|   121M|  std::size_t size() const {
  644|   121M|    return size_;
  645|   121M|  }
_ZNK5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEixEm:
  589|   480M|  const T &operator[](std::size_t id) const {
  590|   480M|    return array_[id];
  591|   480M|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEixEm:
  592|   524M|  T &operator[](std::size_t id) {
  593|   524M|    return array_[id];
  594|   524M|  }
_ZNK5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEixEm:
  633|  47.2M|  const T &operator[](std::size_t id) const {
  634|  47.2M|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|  47.2M|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE5clearEv:
  647|   125k|  void clear() {
  648|   125k|    resize(0);
  649|   125k|    buf_.clear();
  650|   125k|    size_ = 0;
  651|   125k|    capacity_ = 0;
  652|   125k|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE5clearEv:
  600|   250k|  void clear() {
  601|   250k|    if (array_ != NULL) {
  ------------------
  |  Branch (601:9): [True: 62.5k, False: 187k]
  ------------------
  602|  62.5k|      delete[] array_;
  603|       |      array_ = NULL;
  604|  62.5k|    }
  605|   250k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE7reserveEm:
  695|  62.5k|  void reserve(std::size_t size) {
  696|  62.5k|    if (size > capacity_) {
  ------------------
  |  Branch (696:9): [True: 62.5k, False: 0]
  ------------------
  697|  62.5k|      resize_buf(size);
  698|  62.5k|    }
  699|  62.5k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE10resize_bufEm:
  714|  97.6k|void AutoPool<T>::resize_buf(std::size_t size) {
  715|  97.6k|  std::size_t capacity;
  716|  97.6k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 93.3k, False: 4.31k]
  ------------------
  717|  93.3k|    capacity = size;
  718|  93.3k|  } else {
  719|  4.31k|    capacity = 1;
  720|  49.4k|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 45.1k, False: 4.31k]
  ------------------
  721|  45.1k|      capacity <<= 1;
  722|  45.1k|    }
  723|  4.31k|  }
  724|       |
  725|  97.6k|  AutoArray<char> buf;
  726|  97.6k|  try {
  727|  97.6k|    buf.reset(new char[sizeof(T) * capacity]);
  728|  97.6k|  } 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|  97.6k|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 10.0k, False: 87.5k]
  ------------------
  733|  10.0k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|  10.0k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|  5.14M|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 5.13M, False: 10.0k]
  ------------------
  736|  5.13M|      new(&dest[i]) T(src[i]);
  737|  5.13M|      src[i].~T();
  738|  5.13M|    }
  739|  10.0k|  }
  740|       |
  741|  97.6k|  buf_.swap(&buf);
  742|  97.6k|  capacity_ = capacity;
  743|  97.6k|}
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE5resetEPS2_:
  611|  62.5k|  void reset(T *array = NULL) {
  612|  62.5k|    AutoArray(array).swap(this);
  613|  62.5k|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE4swapEPS3_:
  606|  62.5k|  void swap(AutoArray *array) {
  607|  62.5k|    T *temp = array_;
  608|  62.5k|    array_ = array->array_;
  609|  62.5k|    array->array_ = temp;
  610|  62.5k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEixEm:
  636|   175M|  T &operator[](std::size_t id) {
  637|   175M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|   175M|  }
_ZN5Darts7Details8AutoPoolIhE6resizeEm:
  672|  26.0M|  void resize(std::size_t size) {
  673|  93.0M|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 66.9M, False: 26.0M]
  ------------------
  674|  66.9M|      (*this)[--size_].~T();
  675|  66.9M|    }
  676|  26.0M|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 26.0M]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|  26.0M|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 26.0M]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|  26.0M|  }
_ZN5Darts7Details8AutoPoolIhE6appendERKh:
  666|  33.5M|  void append(const T &value) {
  667|  33.5M|    if (size_ == capacity_)
  ------------------
  |  Branch (667:9): [True: 334k, False: 33.2M]
  ------------------
  668|   334k|      resize_buf(size_ + 1);
  669|  33.5M|    new(&(*this)[size_++]) T(value);
  670|  33.5M|  }
_ZNK5Darts7Details8AutoPoolIhE4sizeEv:
  643|   132M|  std::size_t size() const {
  644|   132M|    return size_;
  645|   132M|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE6resizeEm:
  672|   309k|  void resize(std::size_t size) {
  673|  47.5M|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 47.2M, False: 309k]
  ------------------
  674|  47.2M|      (*this)[--size_].~T();
  675|  47.2M|    }
  676|   309k|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 35.1k, False: 274k]
  ------------------
  677|  35.1k|      resize_buf(size);
  678|  35.1k|    }
  679|  47.5M|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 47.2M, False: 309k]
  ------------------
  680|  47.2M|      new(&(*this)[size_++]) T;
  681|  47.2M|    }
  682|   309k|  }
_ZN5Darts15DoubleArrayImplIvvivEC2Ev:
  138|  82.7k|  DoubleArrayImpl() : size_(0), array_(NULL), buf_(NULL) {}
_ZN5Darts15DoubleArrayImplIvvivED2Ev:
  141|  82.7k|  virtual ~DoubleArrayImpl() {
  142|  82.7k|    clear();
  143|  82.7k|  }
_ZN5Darts15DoubleArrayImplIvvivE5clearEv:
  185|   165k|  void clear() {
  186|   165k|    size_ = 0;
  187|   165k|    array_ = NULL;
  188|   165k|    if (buf_ != NULL) {
  ------------------
  |  Branch (188:9): [True: 62.5k, False: 103k]
  ------------------
  189|  62.5k|      delete[] buf_;
  190|       |      buf_ = NULL;
  191|  62.5k|    }
  192|   165k|  }
_ZN5Darts15DoubleArrayImplIvvivE5buildEmPKPKcPKmPKiPFimmE:
 1922|  62.5k|    const value_type *values, Details::progress_func_type progress_func) {
 1923|  62.5k|  Details::Keyset<value_type> keyset(num_keys, keys, lengths, values);
 1924|       |
 1925|  62.5k|  Details::DoubleArrayBuilder builder(progress_func);
 1926|  62.5k|  builder.build(keyset);
 1927|       |
 1928|  62.5k|  std::size_t size = 0;
 1929|  62.5k|  unit_type *buf = NULL;
 1930|  62.5k|  builder.copy(&size, &buf);
 1931|       |
 1932|  62.5k|  clear();
 1933|       |
 1934|  62.5k|  size_ = size;
 1935|  62.5k|  array_ = buf;
 1936|  62.5k|  buf_ = buf;
 1937|       |
 1938|  62.5k|  if (progress_func != NULL) {
  ------------------
  |  Branch (1938:7): [True: 0, False: 62.5k]
  ------------------
 1939|      0|    progress_func(num_keys + 1, num_keys + 1);
 1940|      0|  }
 1941|       |
 1942|  62.5k|  return 0;
 1943|  62.5k|}
_ZN5Darts7Details6KeysetIiEC2EmPKPKcPKmPKi:
  887|  62.5k|      num_keys_(num_keys), keys_(keys), lengths_(lengths), values_(values) {}
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEC2Ev:
  630|  62.5k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoArrayIcEC2EPc:
  584|  6.11M|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEC2EPS2_:
  584|   125k|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details8AutoPoolIhEC2Ev:
  630|   114k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoArrayIjEC2EPj:
  584|   219k|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details8AutoPoolIhED2Ev:
  631|   114k|  ~AutoPool() { clear(); }
_ZN5Darts7Details9AutoArrayIcED2Ev:
  585|  6.11M|  ~AutoArray() {
  586|  6.11M|    clear();
  587|  6.11M|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEED2Ev:
  585|   125k|  ~AutoArray() {
  586|   125k|    clear();
  587|   125k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEED2Ev:
  631|  62.5k|  ~AutoPool() { clear(); }
_ZN5Darts7Details18DoubleArrayBuilder5buildIiEEvRKNS0_6KeysetIT_EE:
 1546|  62.5k|void DoubleArrayBuilder::build(const Keyset<T> &keyset) {
 1547|  62.5k|  if (keyset.has_values()) {
  ------------------
  |  Branch (1547:7): [True: 52.3k, False: 10.1k]
  ------------------
 1548|  52.3k|    Details::DawgBuilder dawg_builder;
 1549|  52.3k|    build_dawg(keyset, &dawg_builder);
 1550|  52.3k|    build_from_dawg(dawg_builder);
 1551|  52.3k|    dawg_builder.clear();
 1552|  52.3k|  } else {
 1553|  10.1k|    build_from_keyset(keyset);
 1554|  10.1k|  }
 1555|  62.5k|}
_ZNK5Darts7Details6KeysetIiE10has_valuesEv:
  915|  8.00M|  bool has_values() const {
  916|       |    return values_ != NULL;
  917|  8.00M|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEEC2Ev:
  630|  52.3k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEEC2Ev:
  630|  52.3k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details8AutoPoolIjEC2Ev:
  630|   209k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoStackIjEC2Ev:
  752|   104k|  AutoStack() : pool_() {}
_ZN5Darts7Details9AutoStackIjED2Ev:
  753|   104k|  ~AutoStack() {
  754|   104k|    clear();
  755|   104k|  }
_ZN5Darts7Details8AutoPoolIjED2Ev:
  631|   209k|  ~AutoPool() { clear(); }
_ZN5Darts7Details9AutoArrayIjED2Ev:
  585|   219k|  ~AutoArray() {
  586|   219k|    clear();
  587|   219k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEED2Ev:
  631|  52.3k|  ~AutoPool() { clear(); }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEED2Ev:
  631|  52.3k|  ~AutoPool() { clear(); }
_ZN5Darts7Details18DoubleArrayBuilder10build_dawgIiEEvRKNS0_6KeysetIT_EEPNS0_11DawgBuilderE:
 1581|  52.3k|    DawgBuilder *dawg_builder) {
 1582|  52.3k|  dawg_builder->init();
 1583|  7.89M|  for (std::size_t i = 0; i < keyset.num_keys(); ++i) {
  ------------------
  |  Branch (1583:27): [True: 7.83M, False: 52.3k]
  ------------------
 1584|  7.83M|    dawg_builder->insert(keyset.keys(i), keyset.lengths(i), keyset.values(i));
 1585|  7.83M|    if (progress_func_ != NULL) {
  ------------------
  |  Branch (1585:9): [True: 0, False: 7.83M]
  ------------------
 1586|      0|      progress_func_(i + 1, keyset.num_keys() + 1);
 1587|      0|    }
 1588|  7.83M|  }
 1589|  52.3k|  dawg_builder->finish();
 1590|  52.3k|}
_ZNK5Darts7Details6KeysetIiE8num_keysEv:
  889|  7.94M|  std::size_t num_keys() const {
  890|  7.94M|    return num_keys_;
  891|  7.94M|  }
_ZNK5Darts7Details6KeysetIiE4keysEm:
  892|  7.83M|  const char_type *keys(std::size_t id) const {
  893|  7.83M|    return keys_[id];
  894|  7.83M|  }
_ZNK5Darts7Details6KeysetIiE7lengthsEm:
  904|  7.89M|  std::size_t lengths(std::size_t id) const {
  905|  7.89M|    if (has_lengths()) {
  ------------------
  |  Branch (905:9): [True: 7.89M, False: 0]
  ------------------
  906|  7.89M|      return lengths_[id];
  907|  7.89M|    }
  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|  7.89M|  }
_ZNK5Darts7Details6KeysetIiE11has_lengthsEv:
  901|  8.70M|  bool has_lengths() const {
  902|       |    return lengths_ != NULL;
  903|  8.70M|  }
_ZNK5Darts7Details6KeysetIiE6valuesEm:
  918|  7.94M|  const value_type values(std::size_t id) const {
  919|  7.94M|    if (has_values()) {
  ------------------
  |  Branch (919:9): [True: 7.83M, False: 104k]
  ------------------
  920|  7.83M|      return static_cast<value_type>(values_[id]);
  921|  7.83M|    }
  922|   104k|    return static_cast<value_type>(id);
  923|  7.94M|  }
_ZN5Darts7Details18DoubleArrayBuilder17build_from_keysetIiEEvRKNS0_6KeysetIT_EE:
 1688|  10.1k|void DoubleArrayBuilder::build_from_keyset(const Keyset<T> &keyset) {
 1689|  10.1k|  std::size_t num_units = 1;
 1690|  30.9k|  while (num_units < keyset.num_keys()) {
  ------------------
  |  Branch (1690:10): [True: 20.8k, False: 10.1k]
  ------------------
 1691|  20.8k|    num_units <<= 1;
 1692|  20.8k|  }
 1693|  10.1k|  units_.reserve(num_units);
 1694|       |
 1695|  10.1k|  extras_.reset(new extra_type[NUM_EXTRAS]);
 1696|       |
 1697|  10.1k|  reserve_id(0);
 1698|  10.1k|  extras(0).set_is_used(true);
 1699|  10.1k|  units_[0].set_offset(1);
 1700|  10.1k|  units_[0].set_label('\0');
 1701|       |
 1702|  10.1k|  if (keyset.num_keys() > 0) {
  ------------------
  |  Branch (1702:7): [True: 10.1k, False: 0]
  ------------------
 1703|  10.1k|    build_from_keyset(keyset, 0, keyset.num_keys(), 0, 0);
 1704|  10.1k|  }
 1705|       |
 1706|  10.1k|  fix_all_blocks();
 1707|       |
 1708|  10.1k|  extras_.clear();
 1709|  10.1k|  labels_.clear();
 1710|  10.1k|}
_ZN5Darts7Details18DoubleArrayBuilder17build_from_keysetIiEEvRKNS0_6KeysetIT_EEmmmj:
 1714|   156k|    std::size_t begin, std::size_t end, std::size_t depth, id_type dic_id) {
 1715|   156k|  id_type offset = arrange_from_keyset(keyset, begin, end, depth, dic_id);
 1716|       |
 1717|   209k|  while (begin < end) {
  ------------------
  |  Branch (1717:10): [True: 156k, False: 52.3k]
  ------------------
 1718|   156k|    if (keyset.keys(begin, depth) != '\0') {
  ------------------
  |  Branch (1718:9): [True: 104k, False: 52.3k]
  ------------------
 1719|   104k|      break;
 1720|   104k|    }
 1721|  52.3k|    ++begin;
 1722|  52.3k|  }
 1723|   156k|  if (begin == end) {
  ------------------
  |  Branch (1723:7): [True: 52.3k, False: 104k]
  ------------------
 1724|  52.3k|    return;
 1725|  52.3k|  }
 1726|       |
 1727|   104k|  std::size_t last_begin = begin;
 1728|   104k|  uchar_type last_label = keyset.keys(begin, depth);
 1729|   253k|  while (++begin < end) {
  ------------------
  |  Branch (1729:10): [True: 149k, False: 104k]
  ------------------
 1730|   149k|    uchar_type label = keyset.keys(begin, depth);
 1731|   149k|    if (label != last_label) {
  ------------------
  |  Branch (1731:9): [True: 42.2k, False: 106k]
  ------------------
 1732|  42.2k|      build_from_keyset(keyset, last_begin, begin,
 1733|  42.2k|          depth + 1, offset ^ last_label);
 1734|  42.2k|      last_begin = begin;
 1735|  42.2k|      last_label = keyset.keys(begin, depth);
 1736|  42.2k|    }
 1737|   149k|  }
 1738|   104k|  build_from_keyset(keyset, last_begin, end, depth + 1, offset ^ last_label);
 1739|   104k|}
_ZN5Darts7Details18DoubleArrayBuilder19arrange_from_keysetIiEEjRKNS0_6KeysetIT_EEmmmj:
 1743|   156k|    std::size_t begin, std::size_t end, std::size_t depth, id_type dic_id) {
 1744|   156k|  labels_.resize(0);
 1745|       |
 1746|   156k|  value_type value = -1;
 1747|   462k|  for (std::size_t i = begin; i < end; ++i) {
  ------------------
  |  Branch (1747:31): [True: 305k, False: 156k]
  ------------------
 1748|   305k|    uchar_type label = keyset.keys(i, depth);
 1749|   305k|    if (label == '\0') {
  ------------------
  |  Branch (1749:9): [True: 52.3k, False: 253k]
  ------------------
 1750|  52.3k|      if (keyset.has_lengths() && depth < keyset.lengths(i)) {
  ------------------
  |  Branch (1750:11): [True: 52.3k, False: 0]
  |  Branch (1750:35): [True: 0, False: 52.3k]
  ------------------
 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|  52.3k|      } else if (keyset.values(i) < 0) {
  ------------------
  |  Branch (1753:18): [True: 0, False: 52.3k]
  ------------------
 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|  52.3k|      if (value == -1) {
  ------------------
  |  Branch (1757:11): [True: 52.3k, False: 0]
  ------------------
 1758|  52.3k|        value = keyset.values(i);
 1759|  52.3k|      }
 1760|  52.3k|      if (progress_func_ != NULL) {
  ------------------
  |  Branch (1760:11): [True: 0, False: 52.3k]
  ------------------
 1761|      0|        progress_func_(i + 1, keyset.num_keys() + 1);
 1762|      0|      }
 1763|  52.3k|    }
 1764|       |
 1765|   305k|    if (labels_.empty()) {
  ------------------
  |  Branch (1765:9): [True: 156k, False: 149k]
  ------------------
 1766|   156k|      labels_.append(label);
 1767|   156k|    } else if (label != labels_[labels_.size() - 1]) {
  ------------------
  |  Branch (1767:16): [True: 42.2k, False: 106k]
  ------------------
 1768|  42.2k|      if (label < labels_[labels_.size() - 1]) {
  ------------------
  |  Branch (1768:11): [True: 0, False: 42.2k]
  ------------------
 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|  42.2k|      labels_.append(label);
 1772|  42.2k|    }
 1773|   305k|  }
 1774|       |
 1775|   156k|  id_type offset = find_valid_offset(dic_id);
 1776|   156k|  units_[dic_id].set_offset(dic_id ^ offset);
 1777|       |
 1778|   356k|  for (std::size_t i = 0; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1778:27): [True: 199k, False: 156k]
  ------------------
 1779|   199k|    id_type dic_child_id = offset ^ labels_[i];
 1780|   199k|    reserve_id(dic_child_id);
 1781|   199k|    if (labels_[i] == '\0') {
  ------------------
  |  Branch (1781:9): [True: 52.3k, False: 146k]
  ------------------
 1782|  52.3k|      units_[dic_id].set_has_leaf(true);
 1783|  52.3k|      units_[dic_child_id].set_value(value);
 1784|   146k|    } else {
 1785|   146k|      units_[dic_child_id].set_label(labels_[i]);
 1786|   146k|    }
 1787|   199k|  }
 1788|   156k|  extras(offset).set_is_used(true);
 1789|       |
 1790|   156k|  return offset;
 1791|   156k|}
_ZNK5Darts7Details8AutoPoolIhE5emptyEv:
  640|   305k|  bool empty() const {
  641|   305k|    return size_ == 0;
  642|   305k|  }
_ZNK5Darts7Details6KeysetIiE4keysEmm:
  895|   758k|  uchar_type keys(std::size_t key_id, std::size_t char_id) const {
  896|   758k|    if (has_lengths() && char_id >= lengths_[key_id])
  ------------------
  |  Branch (896:9): [True: 758k, False: 0]
  |  Branch (896:26): [True: 104k, False: 654k]
  ------------------
  897|   104k|      return '\0';
  898|   654k|    return keys_[key_id][char_id];
  899|   758k|  }
_ZNK5Darts15DoubleArrayImplIvvivE18commonPrefixSearchINS1_16result_pair_typeEEEmPKcPT_mmm:
  497|   141M|    std::size_t length, std::size_t node_pos) const {
  498|   141M|  std::size_t num_results = 0;
  499|       |
  500|   141M|  unit_type unit = array_[node_pos];
  501|   141M|  node_pos ^= unit.offset();
  502|   141M|  if (length != 0) {
  ------------------
  |  Branch (502:7): [True: 141M, False: 0]
  ------------------
  503|   772M|    for (std::size_t i = 0; i < length; ++i) {
  ------------------
  |  Branch (503:29): [True: 753M, False: 19.2M]
  ------------------
  504|   753M|      node_pos ^= static_cast<uchar_type>(key[i]);
  505|   753M|      unit = array_[node_pos];
  506|   753M|      if (unit.label() != static_cast<uchar_type>(key[i])) {
  ------------------
  |  Branch (506:11): [True: 121M, False: 631M]
  ------------------
  507|   121M|        return num_results;
  508|   121M|      }
  509|       |
  510|   631M|      node_pos ^= unit.offset();
  511|   631M|      if (unit.has_leaf()) {
  ------------------
  |  Branch (511:11): [True: 236M, False: 395M]
  ------------------
  512|   236M|        if (num_results < max_num_results) {
  ------------------
  |  Branch (512:13): [True: 236M, False: 0]
  ------------------
  513|   236M|          set_result(&results[num_results], static_cast<value_type>(
  514|   236M|              array_[node_pos].value()), i + 1);
  515|   236M|        }
  516|   236M|        ++num_results;
  517|   236M|      }
  518|   631M|    }
  519|   141M|  } 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|  19.2M|  return num_results;
  539|   141M|}
_ZNK5Darts15DoubleArrayImplIvvivE10set_resultEPNS1_16result_pair_typeEim:
  159|   236M|      value_type value, std::size_t length) const {
  160|   236M|    result->value = value;
  161|   236M|    result->length = length;
  162|   236M|  }
_ZNK5Darts15DoubleArrayImplIvvivE9unit_sizeEv:
  195|  20.2k|  std::size_t unit_size() const {
  196|  20.2k|    return sizeof(unit_type);
  197|  20.2k|  }
_ZN5Darts15DoubleArrayImplIvvivE9set_arrayEPKvm:
  171|  20.2k|  void set_array(const void *ptr, std::size_t size = 0) {
  172|  20.2k|    clear();
  173|  20.2k|    array_ = static_cast<const unit_type *>(ptr);
  174|  20.2k|    size_ = size;
  175|  20.2k|  }
_ZNK5Darts15DoubleArrayImplIvvivE8validateEv:
  436|  20.2k|bool DoubleArrayImpl<A, B, T, C>::validate() const {
  437|  20.2k|  if (size_ == 0) {
  ------------------
  |  Branch (437:7): [True: 0, False: 20.2k]
  ------------------
  438|      0|    return true;
  439|      0|  }
  440|   907M|  for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (440:27): [True: 907M, False: 20.2k]
  ------------------
  441|       |    // Leaf/value units store data in the offset field, not child pointers.
  442|       |    // label() has MSB set (> 0xFF) for these units. Skip them, matching
  443|       |    // the same pattern used in open().
  444|   907M|    if (array_[i].label() > 0xFF) {
  ------------------
  |  Branch (444:9): [True: 302M, False: 605M]
  ------------------
  445|   302M|      continue;
  446|   302M|    }
  447|   605M|    const id_type offset = array_[i].offset();
  448|   605M|    if (offset == 0) {
  ------------------
  |  Branch (448:9): [True: 3.88M, False: 601M]
  ------------------
  449|  3.88M|      continue;
  450|  3.88M|    }
  451|   601M|    const std::size_t base = i ^ offset;
  452|   601M|    if ((base | 0xFF) >= size_) {
  ------------------
  |  Branch (452:9): [True: 0, False: 601M]
  ------------------
  453|      0|      return false;
  454|      0|    }
  455|   601M|  }
  456|  20.2k|  return true;
  457|  20.2k|}

_Z5esaxxINSt3__111__wrap_iterIPjEENS1_IPiEEiEiT_T0_S7_S7_S7_T1_S8_RS8_:
  114|  6.80k|     index_type n, index_type k, index_type& nodeNum) {
  115|  6.80k|  if ((n < 0) || (k <= 0)) return -1;
  ------------------
  |  Branch (115:7): [True: 0, False: 6.80k]
  |  Branch (115:18): [True: 0, False: 6.80k]
  ------------------
  116|  6.80k|  int err = saisxx(T, SA, n, k);
  117|  6.80k|  if (err != 0){
  ------------------
  |  Branch (117:7): [True: 0, False: 6.80k]
  ------------------
  118|      0|    return err;
  119|      0|  }
  120|  6.80k|  nodeNum = esaxx_private::suffixtree(T, SA, L, R, D, n);
  121|  6.80k|  return 0;
  122|  6.80k|}
_ZN13esaxx_private10suffixtreeINSt3__111__wrap_iterIPjEENS2_IPiEEiEET1_T_T0_S9_S9_S9_S7_:
   37|  6.80k|index_type suffixtree(string_type T, sarray_type SA, sarray_type L, sarray_type R, sarray_type D, index_type n){
   38|  6.80k|  if (n == 0){
  ------------------
  |  Branch (38:7): [True: 0, False: 6.80k]
  ------------------
   39|      0|    return 0;
   40|      0|  }
   41|  6.80k|  sarray_type Psi = L;
   42|  6.80k|  Psi[SA[0]] = SA[n-1];
   43|  6.34M|  for (index_type i = 1; i < n; ++i){
  ------------------
  |  Branch (43:26): [True: 6.34M, False: 6.80k]
  ------------------
   44|  6.34M|    Psi[SA[i]] = SA[i-1];
   45|  6.34M|  }
   46|       |
   47|       |  // Compare at most 2n log n charcters. Practically fastest
   48|       |  // "Permuted Longest-Common-Prefix Array", Juha Karkkainen, CPM 09
   49|  6.80k|  sarray_type PLCP = R;
   50|  6.80k|  index_type h = 0;
   51|  6.35M|  for (index_type i = 0; i < n; ++i){
  ------------------
  |  Branch (51:26): [True: 6.34M, False: 6.80k]
  ------------------
   52|  6.34M|    index_type j = Psi[i];
   53|  12.5M|    while (i+h < n && j+h < n && 
  ------------------
  |  Branch (53:12): [True: 12.5M, False: 0]
  |  Branch (53:23): [True: 12.4M, False: 72.8k]
  ------------------
   54|  12.4M|	   T[i+h] == T[j+h]){
  ------------------
  |  Branch (54:5): [True: 6.15M, False: 6.27M]
  ------------------
   55|  6.15M|      ++h;
   56|  6.15M|    }
   57|  6.34M|    PLCP[i] = h;
   58|  6.34M|    if (h > 0) --h;
  ------------------
  |  Branch (58:9): [True: 6.15M, False: 198k]
  ------------------
   59|  6.34M|  }
   60|       |
   61|  6.80k|  sarray_type H = L;
   62|  6.35M|  for (index_type i = 0; i < n; ++i){
  ------------------
  |  Branch (62:26): [True: 6.34M, False: 6.80k]
  ------------------
   63|  6.34M|    H[i] = PLCP[SA[i]];
   64|  6.34M|  }
   65|  6.80k|  H[0] = -1;
   66|       |
   67|  6.80k|  std::vector<std::pair<index_type, index_type> > S;
   68|  6.80k|  S.push_back(std::make_pair((index_type)-1, (index_type)-1));
   69|  6.80k|  size_t nodeNum = 0;
   70|  6.35M|  for (index_type i = 0; ; ++i){
   71|  6.35M|    std::pair<index_type, index_type> cur (i, (i == n) ? -1 : H[i]);
  ------------------
  |  Branch (71:47): [True: 6.80k, False: 6.34M]
  ------------------
   72|  6.35M|    std::pair<index_type, index_type> cand(S.back());
   73|  16.4M|    while (cand.second > cur.second){
  ------------------
  |  Branch (73:12): [True: 10.1M, False: 6.35M]
  ------------------
   74|  10.1M|      if (i - cand.first > 1){
  ------------------
  |  Branch (74:11): [True: 3.79M, False: 6.34M]
  ------------------
   75|  3.79M|	L[nodeNum] = cand.first;
   76|  3.79M|	R[nodeNum] = i;
   77|  3.79M|	D[nodeNum] = cand.second;
   78|  3.79M|	++nodeNum;
   79|  3.79M|      }
   80|  10.1M|      cur.first = cand.first;
   81|  10.1M|      S.pop_back();
   82|  10.1M|      cand = S.back();
   83|  10.1M|    }
   84|  6.35M|    if (cand.second < cur.second){
  ------------------
  |  Branch (84:9): [True: 3.79M, False: 2.56M]
  ------------------
   85|  3.79M|      S.push_back(cur);
   86|  3.79M|    }
   87|  6.35M|    if (i == n) break;
  ------------------
  |  Branch (87:9): [True: 6.80k, False: 6.34M]
  ------------------
   88|  6.34M|    S.push_back(std::make_pair(i, n - SA[i] + 1));
   89|  6.34M|  }
   90|  6.80k|  return nodeNum;
   91|  6.80k|}

_Z6saisxxINSt3__111__wrap_iterIPjEENS1_IPiEEiEiT_T0_T1_S8_:
  326|  6.80k|saisxx(string_type T, sarray_type SA, index_type n, index_type k = 256) {
  327|  6.80k|  int err;
  328|  6.80k|  if((n < 0) || (k <= 0)) { return -1; }
  ------------------
  |  Branch (328:6): [True: 0, False: 6.80k]
  |  Branch (328:17): [True: 0, False: 6.80k]
  ------------------
  329|  6.80k|  if(n <= 1) { if(n == 1) { SA[0] = 0; } return 0; }
  ------------------
  |  Branch (329:6): [True: 0, False: 6.80k]
  |  Branch (329:19): [True: 0, False: 0]
  ------------------
  330|  6.80k|  try { err = saisxx_private::suffixsort(T, SA, index_type(0), n, k, false); }
  331|  6.80k|  catch(...) { err = -2; }
  332|  6.80k|  return err;
  333|  6.80k|}
_ZN14saisxx_private10suffixsortINSt3__111__wrap_iterIPjEENS2_IPiEEiEEiT_T0_T1_S9_S9_b:
  164|  6.80k|           bool isbwt) {
  165|  6.80k|typedef typename std::iterator_traits<string_type>::value_type char_type;
  166|  6.80k|  sarray_type RA;
  167|  6.80k|  index_type i, j, m, p, q, plen, qlen, name;
  168|  6.80k|  int pidx = 0;
  169|  6.80k|  bool diff;
  170|  6.80k|  int c;
  171|       |#ifdef _OPENMP
  172|       |  int maxthreads = omp_get_max_threads();
  173|       |#else
  174|  6.80k|# define maxthreads 1
  175|  6.80k|#endif
  176|  6.80k|  char_type c0, c1;
  177|       |
  178|       |  /* stage 1: reduce the problem by at least 1/2
  179|       |     sort all the S-substrings */
  180|  6.80k|  if(fs < (maxthreads * k)) {
  ------------------
  |  |  174|  6.80k|# define maxthreads 1
  ------------------
  |  Branch (180:6): [True: 6.80k, False: 0]
  ------------------
  181|  6.80k|    index_type *C, *B;
  182|  6.80k|    C = new index_type[maxthreads * k];
  ------------------
  |  |  174|  6.80k|# define maxthreads 1
  ------------------
  183|  6.80k|    B = (1 < maxthreads) ? C + k : C;
  ------------------
  |  |  174|  6.80k|# define maxthreads 1
  ------------------
  |  Branch (183:9): [Folded, False: 6.80k]
  ------------------
  184|  6.80k|    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
  185|       |#ifdef _OPENMP
  186|       |#pragma omp parallel for default(shared) private(i)
  187|       |#endif
  188|  6.35M|    for(i = 0; i < n; ++i) { SA[i] = 0; }
  ------------------
  |  Branch (188:16): [True: 6.34M, False: 6.80k]
  ------------------
  189|  6.34M|    for(i = n - 2, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (189:42): [True: 6.34M, False: 6.80k]
  ------------------
  190|  6.34M|      if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (190:10): [True: 2.72M, False: 3.61M]
  ------------------
  191|  3.61M|      else if(c != 0) { SA[--B[c1]] = i + 1, c = 0; }
  ------------------
  |  Branch (191:15): [True: 1.52M, False: 2.09M]
  ------------------
  192|  6.34M|    }
  193|  6.80k|    induceSA(T, SA, C, B, n, k);
  194|  6.80k|    delete [] C;
  195|  6.80k|  } else {
  196|      0|    sarray_type C, B;
  197|      0|    C = SA + n;
  198|      0|    B = ((1 < maxthreads) || (k <= (fs - k))) ? C + k : C;
  ------------------
  |  |  174|      0|# define maxthreads 1
  ------------------
  |  Branch (198:10): [Folded, False: 0]
  |  Branch (198:30): [True: 0, False: 0]
  ------------------
  199|      0|    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
  200|       |#ifdef _OPENMP
  201|       |#pragma omp parallel for default(shared) private(i)
  202|       |#endif
  203|      0|    for(i = 0; i < n; ++i) { SA[i] = 0; }
  ------------------
  |  Branch (203:16): [True: 0, False: 0]
  ------------------
  204|      0|    for(i = n - 2, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (204:42): [True: 0, False: 0]
  ------------------
  205|      0|      if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (205:10): [True: 0, False: 0]
  ------------------
  206|      0|      else if(c != 0) { SA[--B[c1]] = i + 1, c = 0; }
  ------------------
  |  Branch (206:15): [True: 0, False: 0]
  ------------------
  207|      0|    }
  208|      0|    induceSA(T, SA, C, B, n, k);
  209|      0|  }
  210|       |
  211|       |  /* compact all the sorted substrings into the first m items of SA
  212|       |     2*m must be not larger than n (proveable) */
  213|       |#ifdef _OPENMP
  214|       |#pragma omp parallel for default(shared) private(i, j, p, c0, c1)
  215|       |  for(i = 0; i < n; ++i) {
  216|       |    p = SA[i];
  217|       |    if((0 < p) && (T[p - 1] > (c0 = T[p]))) {
  218|       |      for(j = p + 1; (j < n) && (c0 == (c1 = T[j])); ++j) { }
  219|       |      if((j < n) && (c0 < c1)) { SA[i] = ~p; }
  220|       |    }
  221|       |  }
  222|       |  for(i = 0, m = 0; i < n; ++i) { if((p = SA[i]) < 0) { SA[m++] = ~p; } }
  223|       |#else
  224|  6.35M|  for(i = 0, m = 0; i < n; ++i) {
  ------------------
  |  Branch (224:21): [True: 6.34M, False: 6.80k]
  ------------------
  225|  6.34M|    p = SA[i];
  226|  6.34M|    if((0 < p) && (T[p - 1] > (c0 = T[p]))) {
  ------------------
  |  Branch (226:8): [True: 6.34M, False: 6.80k]
  |  Branch (226:19): [True: 2.06M, False: 4.27M]
  ------------------
  227|  3.00M|      for(j = p + 1; (j < n) && (c0 == (c1 = T[j])); ++j) { }
  ------------------
  |  Branch (227:22): [True: 2.99M, False: 6.80k]
  |  Branch (227:33): [True: 933k, False: 2.06M]
  ------------------
  228|  2.06M|      if((j < n) && (c0 < c1)) { SA[m++] = p; }
  ------------------
  |  Branch (228:10): [True: 2.06M, False: 6.80k]
  |  Branch (228:21): [True: 1.52M, False: 538k]
  ------------------
  229|  2.06M|    }
  230|  6.34M|  }
  231|  6.80k|#endif
  232|  6.80k|  j = m + (n >> 1);
  233|       |#ifdef _OPENMP
  234|       |#pragma omp parallel for default(shared) private(i)
  235|       |#endif
  236|  3.18M|  for(i = m; i < j; ++i) { SA[i] = 0; } /* init the name array buffer */
  ------------------
  |  Branch (236:14): [True: 3.17M, False: 6.80k]
  ------------------
  237|       |  /* store the length of all substrings */
  238|  6.34M|  for(i = n - 2, j = n, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (238:47): [True: 6.34M, False: 6.80k]
  ------------------
  239|  6.34M|    if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (239:8): [True: 2.72M, False: 3.61M]
  ------------------
  240|  3.61M|    else if(c != 0) { SA[m + ((i + 1) >> 1)] = j - i - 1; j = i + 1; c = 0; }
  ------------------
  |  Branch (240:13): [True: 1.52M, False: 2.09M]
  ------------------
  241|  6.34M|  }
  242|       |  /* find the lexicographic names of all substrings */
  243|  1.53M|  for(i = 0, name = 0, q = n, qlen = 0; i < m; ++i) {
  ------------------
  |  Branch (243:41): [True: 1.52M, False: 6.80k]
  ------------------
  244|  1.52M|    p = SA[i], plen = SA[m + (p >> 1)], diff = true;
  245|  1.52M|    if(plen == qlen) {
  ------------------
  |  Branch (245:8): [True: 857k, False: 665k]
  ------------------
  246|  3.54M|      for(j = 0; (j < plen) && (T[p + j] == T[q + j]); ++j) { }
  ------------------
  |  Branch (246:18): [True: 2.82M, False: 726k]
  |  Branch (246:32): [True: 2.68M, False: 131k]
  ------------------
  247|   857k|      if(j == plen) { diff = false; }
  ------------------
  |  Branch (247:10): [True: 726k, False: 131k]
  ------------------
  248|   857k|    }
  249|  1.52M|    if(diff != false) { ++name, q = p, qlen = plen; }
  ------------------
  |  Branch (249:8): [True: 796k, False: 726k]
  ------------------
  250|  1.52M|    SA[m + (p >> 1)] = name;
  251|  1.52M|  }
  252|       |
  253|       |  /* stage 2: solve the reduced problem
  254|       |     recurse if names are not yet unique */
  255|  6.80k|  if(name < m) {
  ------------------
  |  Branch (255:6): [True: 4.21k, False: 2.59k]
  ------------------
  256|  4.21k|    RA = SA + n + fs - m;
  257|  3.09M|    for(i = m + (n >> 1) - 1, j = m - 1; m <= i; --i) {
  ------------------
  |  Branch (257:42): [True: 3.09M, False: 4.21k]
  ------------------
  258|  3.09M|      if(SA[i] != 0) { RA[j--] = SA[i] - 1; }
  ------------------
  |  Branch (258:10): [True: 1.50M, False: 1.59M]
  ------------------
  259|  3.09M|    }
  260|  4.21k|    if(suffixsort(RA, SA, fs + n - m * 2, m, name, false) != 0) { return -2; }
  ------------------
  |  Branch (260:8): [True: 0, False: 4.21k]
  ------------------
  261|  6.18M|    for(i = n - 2, j = m - 1, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (261:53): [True: 6.18M, False: 4.21k]
  ------------------
  262|  6.18M|      if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (262:10): [True: 2.66M, False: 3.51M]
  ------------------
  263|  3.51M|      else if(c != 0) { RA[j--] = i + 1, c = 0; } /* get p1 */
  ------------------
  |  Branch (263:15): [True: 1.50M, False: 2.01M]
  ------------------
  264|  6.18M|    }
  265|       |#ifdef _OPENMP
  266|       |#pragma omp parallel for default(shared) private(i)
  267|       |#endif
  268|  1.50M|    for(i = 0; i < m; ++i) { SA[i] = RA[SA[i]]; } /* get index in s */
  ------------------
  |  Branch (268:16): [True: 1.50M, False: 4.21k]
  ------------------
  269|  4.21k|  }
  270|       |
  271|       |  /* stage 3: induce the result for the original problem */
  272|  6.80k|  if(fs < (maxthreads * k)) {
  ------------------
  |  |  174|  6.80k|# define maxthreads 1
  ------------------
  |  Branch (272:6): [True: 6.80k, False: 0]
  ------------------
  273|  6.80k|    index_type *B, *C;
  274|  6.80k|    C = new index_type[maxthreads * k];
  ------------------
  |  |  174|  6.80k|# define maxthreads 1
  ------------------
  275|  6.80k|    B = (1 < maxthreads) ? C + k : C;
  ------------------
  |  |  174|  6.80k|# define maxthreads 1
  ------------------
  |  Branch (275:9): [Folded, False: 6.80k]
  ------------------
  276|       |    /* put all left-most S characters into their buckets */
  277|  6.80k|    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
  278|       |#ifdef _OPENMP
  279|       |#pragma omp parallel for default(shared) private(i)
  280|       |#endif
  281|  4.83M|    for(i = m; i < n; ++i) { SA[i] = 0; } /* init SA[m..n-1] */
  ------------------
  |  Branch (281:16): [True: 4.82M, False: 6.80k]
  ------------------
  282|  1.53M|    for(i = m - 1; 0 <= i; --i) {
  ------------------
  |  Branch (282:20): [True: 1.52M, False: 6.80k]
  ------------------
  283|  1.52M|      j = SA[i], SA[i] = 0;
  284|  1.52M|      SA[--B[T[j]]] = j;
  285|  1.52M|    }
  286|  6.80k|    if(isbwt == false) { induceSA(T, SA, C, B, n, k); }
  ------------------
  |  Branch (286:8): [True: 6.80k, False: 0]
  ------------------
  287|      0|    else { pidx = computeBWT(T, SA, C, B, n, k); }
  288|  6.80k|    delete [] C;
  289|  6.80k|  } else {
  290|      0|    sarray_type C, B;
  291|      0|    C = SA + n;
  292|      0|    B = ((1 < maxthreads) || (k <= (fs - k))) ? C + k : C;
  ------------------
  |  |  174|      0|# define maxthreads 1
  ------------------
  |  Branch (292:10): [Folded, False: 0]
  |  Branch (292:30): [True: 0, False: 0]
  ------------------
  293|       |    /* put all left-most S characters into their buckets */
  294|      0|    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
  295|       |#ifdef _OPENMP
  296|       |#pragma omp parallel for default(shared) private(i)
  297|       |#endif
  298|      0|    for(i = m; i < n; ++i) { SA[i] = 0; } /* init SA[m..n-1] */
  ------------------
  |  Branch (298:16): [True: 0, False: 0]
  ------------------
  299|      0|    for(i = m - 1; 0 <= i; --i) {
  ------------------
  |  Branch (299:20): [True: 0, False: 0]
  ------------------
  300|      0|      j = SA[i], SA[i] = 0;
  301|      0|      SA[--B[T[j]]] = j;
  302|      0|    }
  303|      0|    if(isbwt == false) { induceSA(T, SA, C, B, n, k); }
  ------------------
  |  Branch (303:8): [True: 0, False: 0]
  ------------------
  304|      0|    else { pidx = computeBWT(T, SA, C, B, n, k); }
  305|      0|  }
  306|       |
  307|  6.80k|  return pidx;
  308|  6.80k|#ifndef _OPENMP
  309|  6.80k|# undef maxthreads
  310|  6.80k|#endif
  311|  6.80k|}
_ZN14saisxx_private9getCountsINSt3__111__wrap_iterIPjEEPiiEEvT_T0_T1_S8_:
   47|  40.8k|getCounts(const string_type T, bucket_type C, index_type n, index_type k) {
   48|       |#ifdef _OPENMP
   49|       |  bucket_type D;
   50|       |  index_type i, j, p, sum, first, last;
   51|       |  int thnum, maxthreads = omp_get_max_threads();
   52|       |#pragma omp parallel default(shared) private(D, i, thnum, first, last)
   53|       |  {
   54|       |    thnum = omp_get_thread_num();
   55|       |    D = C + thnum * k;
   56|       |    first = n / maxthreads * thnum;
   57|       |    last = (thnum < (maxthreads - 1)) ? n / maxthreads * (thnum + 1) : n;
   58|       |    for(i = 0; i < k; ++i) { D[i] = 0; }
   59|       |    for(i = first; i < last; ++i) { ++D[T[i]]; }
   60|       |  }
   61|       |  if(1 < maxthreads) {
   62|       |#pragma omp parallel for default(shared) private(i, j, p, sum)
   63|       |    for(i = 0; i < k; ++i) {
   64|       |      for(j = 1, p = i + k, sum = C[i]; j < maxthreads; ++j, p += k) {
   65|       |        sum += C[p];
   66|       |      }
   67|       |      C[i] = sum;
   68|       |    }
   69|       |  }
   70|       |#else
   71|  40.8k|  index_type i;
   72|  45.4G|  for(i = 0; i < k; ++i) { C[i] = 0; }
  ------------------
  |  Branch (72:14): [True: 45.4G, False: 40.8k]
  ------------------
   73|  38.1M|  for(i = 0; i < n; ++i) { ++C[T[i]]; }
  ------------------
  |  Branch (73:14): [True: 38.0M, False: 40.8k]
  ------------------
   74|  40.8k|#endif
   75|  40.8k|}
_ZN14saisxx_private10getBucketsIPiiEEvT_S2_T0_b:
   78|  42.0k|getBuckets(const bucket_type C, bucket_type B, index_type k, bool end) {
   79|  42.0k|  index_type i, sum = 0;
   80|  30.3G|  if(end) { for(i = 0; i < k; ++i) { sum += C[i]; B[i] = sum; } }
  ------------------
  |  Branch (80:6): [True: 28.0k, False: 14.0k]
  |  Branch (80:24): [True: 30.3G, False: 28.0k]
  ------------------
   81|  15.1G|  else { for(i = 0; i < k; ++i) { sum += C[i]; B[i] = sum - C[i]; } }
  ------------------
  |  Branch (81:21): [True: 15.1G, False: 14.0k]
  ------------------
   82|  42.0k|}
_ZN14saisxx_private8induceSAINSt3__111__wrap_iterIPjEENS2_IPiEES5_iEEvT_T0_T1_S9_T2_SA_:
   89|  13.6k|         index_type n, index_type k) {
   90|  13.6k|typedef typename std::iterator_traits<string_type>::value_type char_type;
   91|  13.6k|  sarray_type b;
   92|  13.6k|  index_type i, j;
   93|  13.6k|  char_type c0, c1;
   94|       |  /* compute SAl */
   95|  13.6k|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (95:6): [True: 13.6k, False: 0]
  ------------------
   96|  13.6k|  getBuckets(C, B, k, false); /* find starts of buckets */
   97|  13.6k|  b = SA + B[c1 = T[j = n - 1]];
   98|  13.6k|  *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (98:11): [True: 13.6k, False: 0]
  |  Branch (98:22): [True: 0, False: 13.6k]
  ------------------
   99|  12.7M|  for(i = 0; i < n; ++i) {
  ------------------
  |  Branch (99:14): [True: 12.6M, False: 13.6k]
  ------------------
  100|  12.6M|    j = SA[i], SA[i] = ~j;
  101|  12.6M|    if(0 < j) {
  ------------------
  |  Branch (101:8): [True: 7.23M, False: 5.46M]
  ------------------
  102|  7.23M|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (102:10): [True: 2.67M, False: 4.56M]
  ------------------
  103|  7.23M|      *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (103:15): [True: 7.22M, False: 8.73k]
  |  Branch (103:26): [True: 3.05M, False: 4.17M]
  ------------------
  104|  7.23M|    }
  105|  12.6M|  }
  106|       |  /* compute SAs */
  107|  13.6k|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (107:6): [True: 13.6k, False: 0]
  ------------------
  108|  13.6k|  getBuckets(C, B, k, true); /* find ends of buckets */
  109|  12.7M|  for(i = n - 1, b = SA + B[c1 = 0]; 0 <= i; --i) {
  ------------------
  |  Branch (109:38): [True: 12.6M, False: 13.6k]
  ------------------
  110|  12.6M|    if(0 < (j = SA[i])) {
  ------------------
  |  Branch (110:8): [True: 5.45M, False: 7.24M]
  ------------------
  111|  5.45M|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (111:10): [True: 2.77M, False: 2.68M]
  ------------------
  112|  5.45M|      *--b = ((j == 0) || (T[j - 1] > c1)) ? ~j : j;
  ------------------
  |  Branch (112:15): [True: 4.87k, False: 5.44M]
  |  Branch (112:27): [True: 3.04M, False: 2.40M]
  ------------------
  113|  7.24M|    } else {
  114|  7.24M|      SA[i] = ~j;
  115|  7.24M|    }
  116|  12.6M|  }
  117|  13.6k|}
_ZN14saisxx_private10getBucketsINSt3__111__wrap_iterIPiEEiEEvT_S5_T0_b:
   78|  44.7k|getBuckets(const bucket_type C, bucket_type B, index_type k, bool end) {
   79|  44.7k|  index_type i, sum = 0;
   80|  4.73M|  if(end) { for(i = 0; i < k; ++i) { sum += C[i]; B[i] = sum; } }
  ------------------
  |  Branch (80:6): [True: 29.8k, False: 14.9k]
  |  Branch (80:24): [True: 4.70M, False: 29.8k]
  ------------------
   81|  2.36M|  else { for(i = 0; i < k; ++i) { sum += C[i]; B[i] = sum - C[i]; } }
  ------------------
  |  Branch (81:21): [True: 2.35M, False: 14.9k]
  ------------------
   82|  44.7k|}
_ZN14saisxx_private10suffixsortINSt3__111__wrap_iterIPiEES4_iEEiT_T0_T1_S7_S7_b:
  164|  7.65k|           bool isbwt) {
  165|  7.65k|typedef typename std::iterator_traits<string_type>::value_type char_type;
  166|  7.65k|  sarray_type RA;
  167|  7.65k|  index_type i, j, m, p, q, plen, qlen, name;
  168|  7.65k|  int pidx = 0;
  169|  7.65k|  bool diff;
  170|  7.65k|  int c;
  171|       |#ifdef _OPENMP
  172|       |  int maxthreads = omp_get_max_threads();
  173|       |#else
  174|  7.65k|# define maxthreads 1
  175|  7.65k|#endif
  176|  7.65k|  char_type c0, c1;
  177|       |
  178|       |  /* stage 1: reduce the problem by at least 1/2
  179|       |     sort all the S-substrings */
  180|  7.65k|  if(fs < (maxthreads * k)) {
  ------------------
  |  |  174|  7.65k|# define maxthreads 1
  ------------------
  |  Branch (180:6): [True: 198, False: 7.46k]
  ------------------
  181|    198|    index_type *C, *B;
  182|    198|    C = new index_type[maxthreads * k];
  ------------------
  |  |  174|    198|# define maxthreads 1
  ------------------
  183|    198|    B = (1 < maxthreads) ? C + k : C;
  ------------------
  |  |  174|    198|# define maxthreads 1
  ------------------
  |  Branch (183:9): [Folded, False: 198]
  ------------------
  184|    198|    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
  185|       |#ifdef _OPENMP
  186|       |#pragma omp parallel for default(shared) private(i)
  187|       |#endif
  188|  44.9k|    for(i = 0; i < n; ++i) { SA[i] = 0; }
  ------------------
  |  Branch (188:16): [True: 44.7k, False: 198]
  ------------------
  189|  44.7k|    for(i = n - 2, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (189:42): [True: 44.5k, False: 198]
  ------------------
  190|  44.5k|      if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (190:10): [True: 30.3k, False: 14.1k]
  ------------------
  191|  14.1k|      else if(c != 0) { SA[--B[c1]] = i + 1, c = 0; }
  ------------------
  |  Branch (191:15): [True: 6.45k, False: 7.67k]
  ------------------
  192|  44.5k|    }
  193|    198|    induceSA(T, SA, C, B, n, k);
  194|    198|    delete [] C;
  195|  7.46k|  } else {
  196|  7.46k|    sarray_type C, B;
  197|  7.46k|    C = SA + n;
  198|  7.46k|    B = ((1 < maxthreads) || (k <= (fs - k))) ? C + k : C;
  ------------------
  |  |  174|  7.46k|# define maxthreads 1
  ------------------
  |  Branch (198:10): [Folded, False: 7.46k]
  |  Branch (198:30): [True: 6.26k, False: 1.19k]
  ------------------
  199|  7.46k|    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
  200|       |#ifdef _OPENMP
  201|       |#pragma omp parallel for default(shared) private(i)
  202|       |#endif
  203|  1.95M|    for(i = 0; i < n; ++i) { SA[i] = 0; }
  ------------------
  |  Branch (203:16): [True: 1.95M, False: 7.46k]
  ------------------
  204|  1.95M|    for(i = n - 2, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (204:42): [True: 1.94M, False: 7.46k]
  ------------------
  205|  1.94M|      if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (205:10): [True: 982k, False: 962k]
  ------------------
  206|   962k|      else if(c != 0) { SA[--B[c1]] = i + 1, c = 0; }
  ------------------
  |  Branch (206:15): [True: 617k, False: 345k]
  ------------------
  207|  1.94M|    }
  208|  7.46k|    induceSA(T, SA, C, B, n, k);
  209|  7.46k|  }
  210|       |
  211|       |  /* compact all the sorted substrings into the first m items of SA
  212|       |     2*m must be not larger than n (proveable) */
  213|       |#ifdef _OPENMP
  214|       |#pragma omp parallel for default(shared) private(i, j, p, c0, c1)
  215|       |  for(i = 0; i < n; ++i) {
  216|       |    p = SA[i];
  217|       |    if((0 < p) && (T[p - 1] > (c0 = T[p]))) {
  218|       |      for(j = p + 1; (j < n) && (c0 == (c1 = T[j])); ++j) { }
  219|       |      if((j < n) && (c0 < c1)) { SA[i] = ~p; }
  220|       |    }
  221|       |  }
  222|       |  for(i = 0, m = 0; i < n; ++i) { if((p = SA[i]) < 0) { SA[m++] = ~p; } }
  223|       |#else
  224|  2.00M|  for(i = 0, m = 0; i < n; ++i) {
  ------------------
  |  Branch (224:21): [True: 1.99M, False: 7.65k]
  ------------------
  225|  1.99M|    p = SA[i];
  226|  1.99M|    if((0 < p) && (T[p - 1] > (c0 = T[p]))) {
  ------------------
  |  Branch (226:8): [True: 1.98M, False: 7.65k]
  |  Branch (226:19): [True: 953k, False: 1.03M]
  ------------------
  227|  1.00M|      for(j = p + 1; (j < n) && (c0 == (c1 = T[j])); ++j) { }
  ------------------
  |  Branch (227:22): [True: 999k, False: 4.55k]
  |  Branch (227:33): [True: 50.8k, False: 948k]
  ------------------
  228|   953k|      if((j < n) && (c0 < c1)) { SA[m++] = p; }
  ------------------
  |  Branch (228:10): [True: 948k, False: 4.55k]
  |  Branch (228:21): [True: 623k, False: 324k]
  ------------------
  229|   953k|    }
  230|  1.99M|  }
  231|  7.65k|#endif
  232|  7.65k|  j = m + (n >> 1);
  233|       |#ifdef _OPENMP
  234|       |#pragma omp parallel for default(shared) private(i)
  235|       |#endif
  236|  1.00M|  for(i = m; i < j; ++i) { SA[i] = 0; } /* init the name array buffer */
  ------------------
  |  Branch (236:14): [True: 996k, False: 7.65k]
  ------------------
  237|       |  /* store the length of all substrings */
  238|  1.99M|  for(i = n - 2, j = n, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (238:47): [True: 1.98M, False: 7.65k]
  ------------------
  239|  1.98M|    if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (239:8): [True: 1.01M, False: 976k]
  ------------------
  240|   976k|    else if(c != 0) { SA[m + ((i + 1) >> 1)] = j - i - 1; j = i + 1; c = 0; }
  ------------------
  |  Branch (240:13): [True: 623k, False: 352k]
  ------------------
  241|  1.98M|  }
  242|       |  /* find the lexicographic names of all substrings */
  243|   631k|  for(i = 0, name = 0, q = n, qlen = 0; i < m; ++i) {
  ------------------
  |  Branch (243:41): [True: 623k, False: 7.65k]
  ------------------
  244|   623k|    p = SA[i], plen = SA[m + (p >> 1)], diff = true;
  245|   623k|    if(plen == qlen) {
  ------------------
  |  Branch (245:8): [True: 249k, False: 374k]
  ------------------
  246|   590k|      for(j = 0; (j < plen) && (T[p + j] == T[q + j]); ++j) { }
  ------------------
  |  Branch (246:18): [True: 499k, False: 91.1k]
  |  Branch (246:32): [True: 341k, False: 158k]
  ------------------
  247|   249k|      if(j == plen) { diff = false; }
  ------------------
  |  Branch (247:10): [True: 91.1k, False: 158k]
  ------------------
  248|   249k|    }
  249|   623k|    if(diff != false) { ++name, q = p, qlen = plen; }
  ------------------
  |  Branch (249:8): [True: 532k, False: 91.1k]
  ------------------
  250|   623k|    SA[m + (p >> 1)] = name;
  251|   623k|  }
  252|       |
  253|       |  /* stage 2: solve the reduced problem
  254|       |     recurse if names are not yet unique */
  255|  7.65k|  if(name < m) {
  ------------------
  |  Branch (255:6): [True: 3.44k, False: 4.21k]
  ------------------
  256|  3.44k|    RA = SA + n + fs - m;
  257|   795k|    for(i = m + (n >> 1) - 1, j = m - 1; m <= i; --i) {
  ------------------
  |  Branch (257:42): [True: 792k, False: 3.44k]
  ------------------
  258|   792k|      if(SA[i] != 0) { RA[j--] = SA[i] - 1; }
  ------------------
  |  Branch (258:10): [True: 496k, False: 295k]
  ------------------
  259|   792k|    }
  260|  3.44k|    if(suffixsort(RA, SA, fs + n - m * 2, m, name, false) != 0) { return -2; }
  ------------------
  |  Branch (260:8): [True: 0, False: 3.44k]
  ------------------
  261|  1.58M|    for(i = n - 2, j = m - 1, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (261:53): [True: 1.58M, False: 3.44k]
  ------------------
  262|  1.58M|      if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (262:10): [True: 809k, False: 773k]
  ------------------
  263|   773k|      else if(c != 0) { RA[j--] = i + 1, c = 0; } /* get p1 */
  ------------------
  |  Branch (263:15): [True: 496k, False: 277k]
  ------------------
  264|  1.58M|    }
  265|       |#ifdef _OPENMP
  266|       |#pragma omp parallel for default(shared) private(i)
  267|       |#endif
  268|   500k|    for(i = 0; i < m; ++i) { SA[i] = RA[SA[i]]; } /* get index in s */
  ------------------
  |  Branch (268:16): [True: 496k, False: 3.44k]
  ------------------
  269|  3.44k|  }
  270|       |
  271|       |  /* stage 3: induce the result for the original problem */
  272|  7.65k|  if(fs < (maxthreads * k)) {
  ------------------
  |  |  174|  7.65k|# define maxthreads 1
  ------------------
  |  Branch (272:6): [True: 198, False: 7.46k]
  ------------------
  273|    198|    index_type *B, *C;
  274|    198|    C = new index_type[maxthreads * k];
  ------------------
  |  |  174|    198|# define maxthreads 1
  ------------------
  275|    198|    B = (1 < maxthreads) ? C + k : C;
  ------------------
  |  |  174|    198|# define maxthreads 1
  ------------------
  |  Branch (275:9): [Folded, False: 198]
  ------------------
  276|       |    /* put all left-most S characters into their buckets */
  277|    198|    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
  278|       |#ifdef _OPENMP
  279|       |#pragma omp parallel for default(shared) private(i)
  280|       |#endif
  281|  38.4k|    for(i = m; i < n; ++i) { SA[i] = 0; } /* init SA[m..n-1] */
  ------------------
  |  Branch (281:16): [True: 38.2k, False: 198]
  ------------------
  282|  6.65k|    for(i = m - 1; 0 <= i; --i) {
  ------------------
  |  Branch (282:20): [True: 6.45k, False: 198]
  ------------------
  283|  6.45k|      j = SA[i], SA[i] = 0;
  284|  6.45k|      SA[--B[T[j]]] = j;
  285|  6.45k|    }
  286|    198|    if(isbwt == false) { induceSA(T, SA, C, B, n, k); }
  ------------------
  |  Branch (286:8): [True: 198, False: 0]
  ------------------
  287|      0|    else { pidx = computeBWT(T, SA, C, B, n, k); }
  288|    198|    delete [] C;
  289|  7.46k|  } else {
  290|  7.46k|    sarray_type C, B;
  291|  7.46k|    C = SA + n;
  292|  7.46k|    B = ((1 < maxthreads) || (k <= (fs - k))) ? C + k : C;
  ------------------
  |  |  174|  7.46k|# define maxthreads 1
  ------------------
  |  Branch (292:10): [Folded, False: 7.46k]
  |  Branch (292:30): [True: 6.26k, False: 1.19k]
  ------------------
  293|       |    /* put all left-most S characters into their buckets */
  294|  7.46k|    getCounts(T, C, n, k); getBuckets(C, B, k, true); /* find ends of buckets */
  295|       |#ifdef _OPENMP
  296|       |#pragma omp parallel for default(shared) private(i)
  297|       |#endif
  298|  1.34M|    for(i = m; i < n; ++i) { SA[i] = 0; } /* init SA[m..n-1] */
  ------------------
  |  Branch (298:16): [True: 1.33M, False: 7.46k]
  ------------------
  299|   624k|    for(i = m - 1; 0 <= i; --i) {
  ------------------
  |  Branch (299:20): [True: 617k, False: 7.46k]
  ------------------
  300|   617k|      j = SA[i], SA[i] = 0;
  301|   617k|      SA[--B[T[j]]] = j;
  302|   617k|    }
  303|  7.46k|    if(isbwt == false) { induceSA(T, SA, C, B, n, k); }
  ------------------
  |  Branch (303:8): [True: 7.46k, False: 0]
  ------------------
  304|      0|    else { pidx = computeBWT(T, SA, C, B, n, k); }
  305|  7.46k|  }
  306|       |
  307|  7.65k|  return pidx;
  308|  7.65k|#ifndef _OPENMP
  309|  7.65k|# undef maxthreads
  310|  7.65k|#endif
  311|  7.65k|}
_ZN14saisxx_private9getCountsINSt3__111__wrap_iterIPiEES3_iEEvT_T0_T1_S7_:
   47|  1.18k|getCounts(const string_type T, bucket_type C, index_type n, index_type k) {
   48|       |#ifdef _OPENMP
   49|       |  bucket_type D;
   50|       |  index_type i, j, p, sum, first, last;
   51|       |  int thnum, maxthreads = omp_get_max_threads();
   52|       |#pragma omp parallel default(shared) private(D, i, thnum, first, last)
   53|       |  {
   54|       |    thnum = omp_get_thread_num();
   55|       |    D = C + thnum * k;
   56|       |    first = n / maxthreads * thnum;
   57|       |    last = (thnum < (maxthreads - 1)) ? n / maxthreads * (thnum + 1) : n;
   58|       |    for(i = 0; i < k; ++i) { D[i] = 0; }
   59|       |    for(i = first; i < last; ++i) { ++D[T[i]]; }
   60|       |  }
   61|       |  if(1 < maxthreads) {
   62|       |#pragma omp parallel for default(shared) private(i, j, p, sum)
   63|       |    for(i = 0; i < k; ++i) {
   64|       |      for(j = 1, p = i + k, sum = C[i]; j < maxthreads; ++j, p += k) {
   65|       |        sum += C[p];
   66|       |      }
   67|       |      C[i] = sum;
   68|       |    }
   69|       |  }
   70|       |#else
   71|  1.18k|  index_type i;
   72|  15.4k|  for(i = 0; i < k; ++i) { C[i] = 0; }
  ------------------
  |  Branch (72:14): [True: 14.2k, False: 1.18k]
  ------------------
   73|   269k|  for(i = 0; i < n; ++i) { ++C[T[i]]; }
  ------------------
  |  Branch (73:14): [True: 268k, False: 1.18k]
  ------------------
   74|  1.18k|#endif
   75|  1.18k|}
_ZN14saisxx_private8induceSAINSt3__111__wrap_iterIPiEES4_S3_iEEvT_T0_T1_S7_T2_S8_:
   89|    396|         index_type n, index_type k) {
   90|    396|typedef typename std::iterator_traits<string_type>::value_type char_type;
   91|    396|  sarray_type b;
   92|    396|  index_type i, j;
   93|    396|  char_type c0, c1;
   94|       |  /* compute SAl */
   95|    396|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (95:6): [True: 396, False: 0]
  ------------------
   96|    396|  getBuckets(C, B, k, false); /* find starts of buckets */
   97|    396|  b = SA + B[c1 = T[j = n - 1]];
   98|    396|  *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (98:11): [True: 396, False: 0]
  |  Branch (98:22): [True: 152, False: 244]
  ------------------
   99|  89.8k|  for(i = 0; i < n; ++i) {
  ------------------
  |  Branch (99:14): [True: 89.4k, False: 396]
  ------------------
  100|  89.4k|    j = SA[i], SA[i] = ~j;
  101|  89.4k|    if(0 < j) {
  ------------------
  |  Branch (101:8): [True: 28.2k, False: 61.1k]
  ------------------
  102|  28.2k|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (102:10): [True: 6.91k, False: 21.3k]
  ------------------
  103|  28.2k|      *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (103:15): [True: 27.9k, False: 286]
  |  Branch (103:26): [True: 12.8k, False: 15.0k]
  ------------------
  104|  28.2k|    }
  105|  89.4k|  }
  106|       |  /* compute SAs */
  107|    396|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (107:6): [True: 396, False: 0]
  ------------------
  108|    396|  getBuckets(C, B, k, true); /* find ends of buckets */
  109|  89.8k|  for(i = n - 1, b = SA + B[c1 = 0]; 0 <= i; --i) {
  ------------------
  |  Branch (109:38): [True: 89.4k, False: 396]
  ------------------
  110|  89.4k|    if(0 < (j = SA[i])) {
  ------------------
  |  Branch (110:8): [True: 60.7k, False: 28.6k]
  ------------------
  111|  60.7k|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (111:10): [True: 3.65k, False: 57.1k]
  ------------------
  112|  60.7k|      *--b = ((j == 0) || (T[j - 1] > c1)) ? ~j : j;
  ------------------
  |  Branch (112:15): [True: 110, False: 60.6k]
  |  Branch (112:27): [True: 12.9k, False: 47.7k]
  ------------------
  113|  60.7k|    } else {
  114|  28.6k|      SA[i] = ~j;
  115|  28.6k|    }
  116|  89.4k|  }
  117|    396|}
_ZN14saisxx_private9getCountsINSt3__111__wrap_iterIPiEES4_iEEvT_T0_T1_S7_:
   47|  19.7k|getCounts(const string_type T, bucket_type C, index_type n, index_type k) {
   48|       |#ifdef _OPENMP
   49|       |  bucket_type D;
   50|       |  index_type i, j, p, sum, first, last;
   51|       |  int thnum, maxthreads = omp_get_max_threads();
   52|       |#pragma omp parallel default(shared) private(D, i, thnum, first, last)
   53|       |  {
   54|       |    thnum = omp_get_thread_num();
   55|       |    D = C + thnum * k;
   56|       |    first = n / maxthreads * thnum;
   57|       |    last = (thnum < (maxthreads - 1)) ? n / maxthreads * (thnum + 1) : n;
   58|       |    for(i = 0; i < k; ++i) { D[i] = 0; }
   59|       |    for(i = first; i < last; ++i) { ++D[T[i]]; }
   60|       |  }
   61|       |  if(1 < maxthreads) {
   62|       |#pragma omp parallel for default(shared) private(i, j, p, sum)
   63|       |    for(i = 0; i < k; ++i) {
   64|       |      for(j = 1, p = i + k, sum = C[i]; j < maxthreads; ++j, p += k) {
   65|       |        sum += C[p];
   66|       |      }
   67|       |      C[i] = sum;
   68|       |    }
   69|       |  }
   70|       |#else
   71|  19.7k|  index_type i;
   72|  2.90M|  for(i = 0; i < k; ++i) { C[i] = 0; }
  ------------------
  |  Branch (72:14): [True: 2.88M, False: 19.7k]
  ------------------
   73|  4.66M|  for(i = 0; i < n; ++i) { ++C[T[i]]; }
  ------------------
  |  Branch (73:14): [True: 4.65M, False: 19.7k]
  ------------------
   74|  19.7k|#endif
   75|  19.7k|}
_ZN14saisxx_private8induceSAINSt3__111__wrap_iterIPiEES4_S4_iEEvT_T0_T1_S7_T2_S8_:
   89|  14.9k|         index_type n, index_type k) {
   90|  14.9k|typedef typename std::iterator_traits<string_type>::value_type char_type;
   91|  14.9k|  sarray_type b;
   92|  14.9k|  index_type i, j;
   93|  14.9k|  char_type c0, c1;
   94|       |  /* compute SAl */
   95|  14.9k|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (95:6): [True: 2.39k, False: 12.5k]
  ------------------
   96|  14.9k|  getBuckets(C, B, k, false); /* find starts of buckets */
   97|  14.9k|  b = SA + B[c1 = T[j = n - 1]];
   98|  14.9k|  *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (98:11): [True: 14.9k, False: 0]
  |  Branch (98:22): [True: 6.06k, False: 8.85k]
  ------------------
   99|  3.91M|  for(i = 0; i < n; ++i) {
  ------------------
  |  Branch (99:14): [True: 3.90M, False: 14.9k]
  ------------------
  100|  3.90M|    j = SA[i], SA[i] = ~j;
  101|  3.90M|    if(0 < j) {
  ------------------
  |  Branch (101:8): [True: 1.92M, False: 1.97M]
  ------------------
  102|  1.92M|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (102:10): [True: 1.51M, False: 407k]
  ------------------
  103|  1.92M|      *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (103:15): [True: 1.91M, False: 7.35k]
  |  Branch (103:26): [True: 1.23M, False: 681k]
  ------------------
  104|  1.92M|    }
  105|  3.90M|  }
  106|       |  /* compute SAs */
  107|  14.9k|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (107:6): [True: 2.39k, False: 12.5k]
  ------------------
  108|  14.9k|  getBuckets(C, B, k, true); /* find ends of buckets */
  109|  3.91M|  for(i = n - 1, b = SA + B[c1 = 0]; 0 <= i; --i) {
  ------------------
  |  Branch (109:38): [True: 3.90M, False: 14.9k]
  ------------------
  110|  3.90M|    if(0 < (j = SA[i])) {
  ------------------
  |  Branch (110:8): [True: 1.96M, False: 1.94M]
  ------------------
  111|  1.96M|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (111:10): [True: 1.51M, False: 449k]
  ------------------
  112|  1.96M|      *--b = ((j == 0) || (T[j - 1] > c1)) ? ~j : j;
  ------------------
  |  Branch (112:15): [True: 7.56k, False: 1.95M]
  |  Branch (112:27): [True: 1.23M, False: 721k]
  ------------------
  113|  1.96M|    } else {
  114|  1.94M|      SA[i] = ~j;
  115|  1.94M|    }
  116|  3.90M|  }
  117|  14.9k|}

_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_9allocatorIcEEEERSA_PNS0_5ArenaE:
   66|   459k|                         ConstStringParam value, ::google::protobuf::Arena* arena) {
   67|   459k|  if (IsDefault(default_value)) {
  ------------------
  |  Branch (67:7): [True: 459k, False: 0]
  ------------------
   68|   459k|    tagged_ptr_.Set(Arena::Create<std::string>(arena, value));
   69|   459k|  } else {
   70|      0|    UnsafeMutablePointer()->assign(value.data(), value.length());
   71|      0|  }
   72|   459k|}
_ZN6google8protobuf8internal14ArenaStringPtr3SetEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEOS9_PNS0_5ArenaE:
   75|  7.85M|                         ::google::protobuf::Arena* arena) {
   76|  7.85M|  if (IsDefault(default_value)) {
  ------------------
  |  Branch (76:7): [True: 1.96M, False: 5.89M]
  ------------------
   77|  1.96M|    if (arena == nullptr) {
  ------------------
  |  Branch (77:9): [True: 1.96M, False: 0]
  ------------------
   78|  1.96M|      tagged_ptr_.Set(new std::string(std::move(value)));
   79|  1.96M|    } else {
   80|      0|      tagged_ptr_.Set(Arena::Create<std::string>(arena, std::move(value)));
   81|      0|    }
   82|  5.89M|  } else if (IsDonatedString()) {
  ------------------
  |  Branch (82:14): [True: 0, False: 5.89M]
  ------------------
   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|  5.89M|  } else /* !IsDonatedString() */ {
   88|  5.89M|    *UnsafeMutablePointer() = std::move(value);
   89|  5.89M|  }
   90|  7.85M|}
_ZN6google8protobuf8internal14ArenaStringPtr3SetENS2_12EmptyDefaultERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaE:
   93|   459k|                         ::google::protobuf::Arena* arena) {
   94|   459k|  Set(&GetEmptyStringAlreadyInited(), value, arena);
   95|   459k|}
_ZN6google8protobuf8internal14ArenaStringPtr3SetENS2_12EmptyDefaultEONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaE:
   98|  7.85M|                         ::google::protobuf::Arena* arena) {
   99|  7.85M|  Set(&GetEmptyStringAlreadyInited(), std::move(value), arena);
  100|  7.85M|}
_ZN6google8protobuf8internal14ArenaStringPtr7MutableENS2_12EmptyDefaultEPNS0_5ArenaE:
  112|  10.1k|std::string* ArenaStringPtr::Mutable(EmptyDefault, ::google::protobuf::Arena* arena) {
  113|  10.1k|  if (!IsDonatedString() && !IsDefault(&GetEmptyStringAlreadyInited())) {
  ------------------
  |  Branch (113:7): [True: 10.1k, False: 0]
  |  Branch (113:29): [True: 0, False: 10.1k]
  ------------------
  114|      0|    return UnsafeMutablePointer();
  115|  10.1k|  } else {
  116|  10.1k|    return MutableSlow(arena);
  117|  10.1k|  }
  118|  10.1k|}
_ZN6google8protobuf8internal14ArenaStringPtr11MutableSlowIJEEEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaEDpRKT_:
  144|  10.1k|                                         const Lazy&... lazy_default) {
  145|  10.1k|  const std::string* const default_value =
  146|  10.1k|      sizeof...(Lazy) == 0 ? &GetEmptyStringAlreadyInited() : nullptr;
  ------------------
  |  Branch (146:7): [True: 10.1k, Folded]
  ------------------
  147|  10.1k|  GOOGLE_DCHECK(IsDefault(default_value));
  ------------------
  |  |  181|  10.1k|#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.1k]
  |  |  ------------------
  ------------------
  148|  10.1k|  std::string* new_string =
  149|  10.1k|      Arena::Create<std::string>(arena, lazy_default.get()...);
  150|  10.1k|  tagged_ptr_.Set(new_string);
  151|  10.1k|  return new_string;
  152|  10.1k|}

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

_ZN6google8protobuf8internal13VerifyVersionEiiPKc:
   73|      6|                   const char* filename) {
   74|      6|  if (GOOGLE_PROTOBUF_VERSION < minLibraryVersion) {
  ------------------
  |  |   85|      6|#define GOOGLE_PROTOBUF_VERSION 3014000
  ------------------
  |  Branch (74:7): [True: 0, False: 6]
  ------------------
   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|      6|  if (headerVersion < kMinHeaderVersionForLibrary) {
  ------------------
  |  Branch (85:7): [True: 0, False: 6]
  ------------------
   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|      6|}

_ZN6google8protobuf8internal12ExtensionSetC2EPNS0_5ArenaE:
  188|  2.43M|    : arena_(arena),
  189|  2.43M|      flat_capacity_(0),
  190|  2.43M|      flat_size_(0),
  191|  2.43M|      map_{flat_capacity_ == 0
  ------------------
  |  Branch (191:12): [True: 2.43M, False: 0]
  ------------------
  192|  2.43M|               ? NULL
  193|  2.43M|               : Arena::CreateArray<KeyValue>(arena_, flat_capacity_)} {}
_ZN6google8protobuf8internal12ExtensionSetD2Ev:
  195|  2.49M|ExtensionSet::~ExtensionSet() {
  196|       |  // Deletes all allocated extensions.
  197|  2.49M|  if (arena_ == NULL) {
  ------------------
  |  Branch (197:7): [True: 2.49M, False: 0]
  ------------------
  198|  2.49M|    ForEach([](int /* number */, Extension& ext) { ext.Free(); });
  199|  2.49M|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  2.49M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 2.49M]
  |  |  ------------------
  ------------------
  200|      0|      delete map_.large;
  201|  2.49M|    } else {
  202|  2.49M|      DeleteFlatMap(map_.flat, flat_capacity_);
  203|  2.49M|    }
  204|  2.49M|  }
  205|  2.49M|}
_ZN6google8protobuf8internal12ExtensionSet13DeleteFlatMapEPKNS2_8KeyValueEt:
  208|  2.49M|                                 uint16 flat_capacity) {
  209|  2.49M|#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|  2.49M|  static_assert(std::is_trivially_destructible<KeyValue>::value,
  213|  2.49M|                "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|  2.49M|  ::operator delete[](const_cast<ExtensionSet::KeyValue*>(flat),
  217|  2.49M|                      sizeof(*flat) * flat_capacity);
  218|       |#else   // !__cpp_sized_deallocation
  219|       |  delete[] flat;
  220|       |#endif  // !__cpp_sized_deallocation
  221|  2.49M|}
_ZN6google8protobuf8internal12ExtensionSet5ClearEv:
  877|  7.66M|void ExtensionSet::Clear() {
  878|  7.66M|  ForEach([](int /* number */, Extension& ext) { ext.Clear(); });
  879|  7.66M|}
_ZN6google8protobuf8internal12ExtensionSet9MergeFromERKS2_:
  903|  84.3k|void ExtensionSet::MergeFrom(const ExtensionSet& other) {
  904|  84.3k|  if (PROTOBUF_PREDICT_TRUE(!is_large())) {
  ------------------
  |  |  236|  84.3k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 84.3k, False: 0]
  |  |  ------------------
  ------------------
  905|  84.3k|    if (PROTOBUF_PREDICT_TRUE(!other.is_large())) {
  ------------------
  |  |  236|  84.3k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 84.3k, False: 0]
  |  |  ------------------
  ------------------
  906|  84.3k|      GrowCapacity(SizeOfUnion(flat_begin(), flat_end(), other.flat_begin(),
  907|  84.3k|                               other.flat_end()));
  908|  84.3k|    } else {
  909|      0|      GrowCapacity(SizeOfUnion(flat_begin(), flat_end(),
  910|      0|                               other.map_.large->begin(),
  911|      0|                               other.map_.large->end()));
  912|      0|    }
  913|  84.3k|  }
  914|  84.3k|  other.ForEach([this](int number, const Extension& ext) {
  915|  84.3k|    this->InternalExtensionMergeFrom(number, ext);
  916|  84.3k|  });
  917|  84.3k|}
_ZNK6google8protobuf8internal12ExtensionSet18_InternalSerializeEiiPhPNS0_2io19EpsCopyOutputStreamE:
 1460|   302k|                                        io::EpsCopyOutputStream* stream) const {
 1461|   302k|  if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|   302k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 302k]
  |  |  ------------------
  ------------------
 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|   302k|  const KeyValue* end = flat_end();
 1471|   302k|  for (const KeyValue* it = std::lower_bound(
 1472|   302k|           flat_begin(), end, start_field_number, KeyValue::FirstComparator());
 1473|   302k|       it != end && it->first < end_field_number; ++it) {
  ------------------
  |  Branch (1473:8): [True: 0, False: 302k]
  |  Branch (1473:21): [True: 0, False: 0]
  ------------------
 1474|      0|    target = it->second.InternalSerializeFieldWithCachedSizesToArray(
 1475|      0|        it->first, target, stream);
 1476|      0|  }
 1477|   302k|  return target;
 1478|   302k|}
_ZNK6google8protobuf8internal12ExtensionSet8ByteSizeEv:
 1489|   302k|size_t ExtensionSet::ByteSize() const {
 1490|   302k|  size_t total_size = 0;
 1491|   302k|  ForEach([&total_size](int number, const Extension& ext) {
 1492|   302k|    total_size += ext.ByteSize(number);
 1493|   302k|  });
 1494|   302k|  return total_size;
 1495|   302k|}
_ZN6google8protobuf8internal12ExtensionSet12GrowCapacityEm:
 1857|  84.3k|void ExtensionSet::GrowCapacity(size_t minimum_new_capacity) {
 1858|  84.3k|  if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  84.3k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 84.3k]
  |  |  ------------------
  ------------------
 1859|      0|    return;  // LargeMap does not have a "reserve" method.
 1860|      0|  }
 1861|  84.3k|  if (flat_capacity_ >= minimum_new_capacity) {
  ------------------
  |  Branch (1861:7): [True: 84.3k, False: 0]
  ------------------
 1862|  84.3k|    return;
 1863|  84.3k|  }
 1864|       |
 1865|      0|  auto new_flat_capacity = flat_capacity_;
 1866|      0|  do {
 1867|      0|    new_flat_capacity = new_flat_capacity == 0 ? 1 : new_flat_capacity * 4;
  ------------------
  |  Branch (1867:25): [True: 0, False: 0]
  ------------------
 1868|      0|  } while (new_flat_capacity < minimum_new_capacity);
  ------------------
  |  Branch (1868:12): [True: 0, False: 0]
  ------------------
 1869|       |
 1870|      0|  const KeyValue* begin = flat_begin();
 1871|      0|  const KeyValue* end = flat_end();
 1872|      0|  AllocatedData new_map;
 1873|      0|  if (new_flat_capacity > kMaximumFlatCapacity) {
  ------------------
  |  Branch (1873:7): [True: 0, False: 0]
  ------------------
 1874|      0|    new_map.large = Arena::Create<LargeMap>(arena_);
 1875|      0|    LargeMap::iterator hint = new_map.large->begin();
 1876|      0|    for (const KeyValue* it = begin; it != end; ++it) {
  ------------------
  |  Branch (1876:38): [True: 0, False: 0]
  ------------------
 1877|      0|      hint = new_map.large->insert(hint, {it->first, it->second});
 1878|      0|    }
 1879|      0|  } else {
 1880|      0|    new_map.flat = Arena::CreateArray<KeyValue>(arena_, new_flat_capacity);
 1881|      0|    std::copy(begin, end, new_map.flat);
 1882|      0|  }
 1883|       |
 1884|      0|  if (arena_ == nullptr) {
  ------------------
  |  Branch (1884:7): [True: 0, False: 0]
  ------------------
 1885|      0|    DeleteFlatMap(begin, flat_capacity_);
 1886|      0|  }
 1887|      0|  flat_capacity_ = new_flat_capacity;
 1888|      0|  map_ = new_map;
 1889|      0|  if (is_large()) {
  ------------------
  |  Branch (1889:7): [True: 0, False: 0]
  ------------------
 1890|      0|    flat_size_ = 0;
 1891|      0|  }
 1892|      0|}
extension_set.cc:_ZN6google8protobuf8internal12_GLOBAL__N_111SizeOfUnionIPNS1_12ExtensionSet8KeyValueEPKS5_EEmT_S9_T0_SA_:
  884|  84.3k|size_t SizeOfUnion(ItX it_xs, ItX end_xs, ItY it_ys, ItY end_ys) {
  885|  84.3k|  size_t result = 0;
  886|  84.3k|  while (it_xs != end_xs && it_ys != end_ys) {
  ------------------
  |  Branch (886:10): [True: 0, False: 84.3k]
  |  Branch (886:29): [True: 0, False: 0]
  ------------------
  887|      0|    ++result;
  888|      0|    if (it_xs->first < it_ys->first) {
  ------------------
  |  Branch (888:9): [True: 0, False: 0]
  ------------------
  889|      0|      ++it_xs;
  890|      0|    } else if (it_xs->first == it_ys->first) {
  ------------------
  |  Branch (890:16): [True: 0, False: 0]
  ------------------
  891|      0|      ++it_xs;
  892|      0|      ++it_ys;
  893|      0|    } else {
  894|      0|      ++it_ys;
  895|      0|    }
  896|      0|  }
  897|  84.3k|  result += std::distance(it_xs, end_xs);
  898|  84.3k|  result += std::distance(it_ys, end_ys);
  899|  84.3k|  return result;
  900|  84.3k|}

_ZN6google8protobuf8internal24InitProtobufDefaultsSlowEv:
   89|      1|void InitProtobufDefaultsSlow() {
   90|      1|  static bool is_inited = InitProtobufDefaultsImpl();
   91|      1|  (void)is_inited;
   92|      1|}
_ZN6google8protobuf8internal11InitSCCImplEPNS1_11SCCInfoBaseE:
  764|      9|void InitSCCImpl(SCCInfoBase* scc) {
  765|      9|  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|      9|#ifndef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
  769|      9|  static std::atomic<std::thread::id> runner;
  770|      9|  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|      9|  if (runner.load(std::memory_order_relaxed) == me) {
  ------------------
  |  Branch (781:7): [True: 6, 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|      6|    GOOGLE_CHECK_EQ(scc->visit_status.load(std::memory_order_relaxed),
  ------------------
  |  |  156|      6|#define GOOGLE_CHECK_EQ(A, B) GOOGLE_CHECK((A) == (B))
  |  |  ------------------
  |  |  |  |  154|      6|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      6|  !(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: 6, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  785|      6|             SCCInfoBase::kRunning);
  786|      6|    return;
  787|      6|  }
  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|      8|void InitSCC_DFS(SCCInfoBase* scc) {
  737|      8|  if (scc->visit_status.load(std::memory_order_relaxed) !=
  ------------------
  |  Branch (737:7): [True: 2, False: 6]
  ------------------
  738|      8|      SCCInfoBase::kUninitialized)
  739|      2|    return;
  740|      6|  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|      6|  auto deps = reinterpret_cast<void**>(scc + 1);
  744|      6|  auto strong_deps = reinterpret_cast<SCCInfoBase* const*>(deps);
  745|     11|  for (int i = 0; i < scc->num_deps; ++i) {
  ------------------
  |  Branch (745:19): [True: 5, False: 6]
  ------------------
  746|      5|    if (strong_deps[i]) InitSCC_DFS(strong_deps[i]);
  ------------------
  |  Branch (746:9): [True: 5, False: 0]
  ------------------
  747|      5|  }
  748|      6|  auto implicit_weak_deps =
  749|      6|      reinterpret_cast<SCCInfoBase** const*>(deps + scc->num_deps);
  750|      6|  for (int i = 0; i < scc->num_implicit_weak_deps; ++i) {
  ------------------
  |  Branch (750:19): [True: 0, False: 6]
  ------------------
  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|      6|  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|      6|  scc->visit_status.store(SCCInfoBase::kInitialized, std::memory_order_release);
  760|      6|}

_ZN6google8protobuf5Arena6CreateINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_:
  292|  10.1k|  PROTOBUF_ALWAYS_INLINE static T* Create(Arena* arena, Args&&... args) {
  293|  10.1k|    return CreateNoMessage<T>(arena, is_arena_constructable<T>(),
  294|  10.1k|                              std::forward<Args>(args)...);
  295|  10.1k|  }
_ZN6google8protobuf5Arena15CreateNoMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  547|  10.1k|                                                   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|  10.1k|    return CreateMaybeMessage<T>(arena, std::forward<Args>(args)...);
  552|  10.1k|  }
_ZN6google8protobuf5Arena18CreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_:
  530|  10.1k|                                                      Args&&... args) {
  531|  10.1k|    return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(),
  532|  10.1k|                                   std::forward<Args>(args)...);
  533|  10.1k|  }
_ZN6google8protobuf5Arena20DoCreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  524|  10.1k|                                                        Args&&... args) {
  525|  10.1k|    return CreateInternal<T>(arena, std::forward<Args>(args)...);
  526|  10.1k|  }
_ZN6google8protobuf5Arena14CreateInternalINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_:
  472|  10.1k|                                                  Args&&... args) {
  473|  10.1k|    if (arena == NULL) {
  ------------------
  |  Branch (473:9): [True: 10.1k, False: 0]
  ------------------
  474|  10.1k|      return new T(std::forward<Args>(args)...);
  475|  10.1k|    } else {
  476|      0|      return arena->DoCreate<T>(std::is_trivially_destructible<T>::value,
  477|      0|                                std::forward<Args>(args)...);
  478|      0|    }
  479|  10.1k|  }
_ZN6google8protobuf5Arena6CreateINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_DpOT0_:
  292|   459k|  PROTOBUF_ALWAYS_INLINE static T* Create(Arena* arena, Args&&... args) {
  293|   459k|    return CreateNoMessage<T>(arena, is_arena_constructable<T>(),
  294|   459k|                              std::forward<Args>(args)...);
  295|   459k|  }
_ZN6google8protobuf5Arena15CreateNoMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  547|   459k|                                                   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|   459k|    return CreateMaybeMessage<T>(arena, std::forward<Args>(args)...);
  552|   459k|  }
_ZN6google8protobuf5Arena18CreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_DpOT0_:
  530|   459k|                                                      Args&&... args) {
  531|   459k|    return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(),
  532|   459k|                                   std::forward<Args>(args)...);
  533|   459k|  }
_ZN6google8protobuf5Arena20DoCreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  524|   459k|                                                        Args&&... args) {
  525|   459k|    return CreateInternal<T>(arena, std::forward<Args>(args)...);
  526|   459k|  }
_ZN6google8protobuf5Arena14CreateInternalINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_DpOT0_:
  472|   459k|                                                  Args&&... args) {
  473|   459k|    if (arena == NULL) {
  ------------------
  |  Branch (473:9): [True: 459k, False: 0]
  ------------------
  474|   459k|      return new T(std::forward<Args>(args)...);
  475|   459k|    } else {
  476|      0|      return arena->DoCreate<T>(std::is_trivially_destructible<T>::value,
  477|      0|                                std::forward<Args>(args)...);
  478|      0|    }
  479|   459k|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece11TrainerSpecEEEPT_PS1_:
  459|  9.97k|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  9.97k|    static_assert(
  461|  9.97k|        InternalHelper<T>::is_arena_constructable::value,
  462|  9.97k|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  9.97k|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 9.97k, False: 0]
  ------------------
  464|  9.97k|      return new T();
  465|  9.97k|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  9.97k|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece14NormalizerSpecEEEPT_PS1_:
  459|  9.97k|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  9.97k|    static_assert(
  461|  9.97k|        InternalHelper<T>::is_arena_constructable::value,
  462|  9.97k|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  9.97k|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 9.97k, False: 0]
  ------------------
  464|  9.97k|      return new T();
  465|  9.97k|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  9.97k|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece24ModelProto_SentencePieceEEEPT_PS1_:
  459|  2.35M|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  2.35M|    static_assert(
  461|  2.35M|        InternalHelper<T>::is_arena_constructable::value,
  462|  2.35M|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  2.35M|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 2.35M, False: 0]
  ------------------
  464|  2.35M|      return new T();
  465|  2.35M|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  2.35M|  }

_ZNK6google8protobuf8internal14ArenaStringPtr3GetEv:
  194|  2.14M|  const std::string& Get() const PROTOBUF_ALWAYS_INLINE {
  195|       |    // Unconditionally mask away the tag.
  196|  2.14M|    return *tagged_ptr_.Get();
  197|  2.14M|  }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEv:
   99|  9.72M|  T* Get() const { return reinterpret_cast<T*>(as_int() & -2); }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE6as_intEv:
  109|  9.72M|  uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
_ZNK6google8protobuf8internal14ArenaStringPtr9IsDefaultEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  279|  11.6M|  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|  11.6M|    return tagged_ptr_.UnsafeGet() == default_value;
  285|  11.6M|  }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE9UnsafeGetEv:
  104|  19.9M|  T* UnsafeGet() const { return static_cast<T*>(ptr_); }
_ZNK6google8protobuf8internal10LazyString3getEv:
   74|   300k|  const std::string& get() const {
   75|       |    // This check generates less code than a call-once invocation.
   76|   300k|    auto* res = inited_.load(std::memory_order_acquire);
   77|   300k|    if (PROTOBUF_PREDICT_FALSE(res == nullptr)) return Init();
  ------------------
  |  |  247|   300k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 5, False: 300k]
  |  |  ------------------
  ------------------
   78|   300k|    return *res;
   79|   300k|  }
_ZNK6google8protobuf8internal14ArenaStringPtr15IsDonatedStringEv:
  290|  5.90M|  bool IsDonatedString() const { return false; }
_ZN6google8protobuf8internal14ArenaStringPtr16UnsafeSetDefaultEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  301|  2.98M|inline void ArenaStringPtr::UnsafeSetDefault(const std::string* value) {
  302|  2.98M|  tagged_ptr_.Set(const_cast<std::string*>(value));
  303|  2.98M|}
_ZN6google8protobuf8internal14ArenaStringPtr22ClearNonDefaultToEmptyEv:
  336|  7.58M|inline void ArenaStringPtr::ClearNonDefaultToEmpty() {
  337|       |  // Unconditionally mask away the tag.
  338|  7.58M|  tagged_ptr_.Get()->clear();
  339|  7.58M|}
_ZN6google8protobuf8internal14ArenaStringPtr14DestroyNoArenaEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  356|  2.98M|inline void ArenaStringPtr::DestroyNoArena(const std::string* default_value) {
  357|  2.98M|  if (!IsDefault(default_value)) {
  ------------------
  |  Branch (357:7): [True: 2.43M, False: 550k]
  ------------------
  358|  2.43M|    delete UnsafeMutablePointer();
  359|  2.43M|  }
  360|  2.98M|}
_ZN6google8protobuf8internal14ArenaStringPtr20UnsafeMutablePointerEv:
  362|  8.32M|inline std::string* ArenaStringPtr::UnsafeMutablePointer() {
  363|  8.32M|  GOOGLE_DCHECK(!tagged_ptr_.IsTagged());
  ------------------
  |  |  181|  8.32M|#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: 8.32M]
  |  |  ------------------
  ------------------
  364|  8.32M|  GOOGLE_DCHECK(tagged_ptr_.UnsafeGet() != nullptr);
  ------------------
  |  |  181|  8.32M|#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: 8.32M]
  |  |  ------------------
  ------------------
  365|  8.32M|  return tagged_ptr_.UnsafeGet();
  366|  8.32M|}
_ZN6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3SetEPS9_:
   98|  5.42M|  void Set(T* p) { ptr_ = p; }

_ZNK6google8protobuf8internal12ExtensionSet8is_largeEv:
  667|  13.5M|  bool is_large() const { return flat_capacity_ > kMaximumFlatCapacity; }
_ZN6google8protobuf8internal12ExtensionSet10flat_beginEv:
  816|  10.2M|  KeyValue* flat_begin() {
  817|       |    assert(!is_large());
  818|  10.2M|    return map_.flat;
  819|  10.2M|  }
_ZNK6google8protobuf8internal12ExtensionSet10flat_beginEv:
  820|   774k|  const KeyValue* flat_begin() const {
  821|       |    assert(!is_large());
  822|   774k|    return map_.flat;
  823|   774k|  }
_ZN6google8protobuf8internal12ExtensionSet8flat_endEv:
  824|  10.2M|  KeyValue* flat_end() {
  825|       |    assert(!is_large());
  826|  10.2M|    return map_.flat + flat_size_;
  827|  10.2M|  }
_ZNK6google8protobuf8internal12ExtensionSet8flat_endEv:
  828|   774k|  const KeyValue* flat_end() const {
  829|       |    assert(!is_large());
  830|   774k|    return map_.flat + flat_size_;
  831|   774k|  }
_ZN6google8protobuf8internal12ExtensionSetC2Ev:
  854|  64.4k|    : arena_(nullptr), flat_capacity_(0), flat_size_(0), map_{nullptr} {}
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIZNS2_D1EvE3$_0EET_S5_:
  688|  2.49M|  KeyValueFunctor ForEach(KeyValueFunctor func) {
  689|  2.49M|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  2.49M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 2.49M]
  |  |  ------------------
  ------------------
  690|      0|      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
  691|      0|    }
  692|  2.49M|    return ForEach(flat_begin(), flat_end(), std::move(func));
  693|  2.49M|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIPNS2_8KeyValueEZNS2_D1EvE3$_0EET0_T_S8_S7_:
  681|  2.49M|                                 KeyValueFunctor func) {
  682|  2.49M|    for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
  ------------------
  |  Branch (682:31): [True: 0, False: 2.49M]
  ------------------
  683|  2.49M|    return std::move(func);
  684|  2.49M|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIZNS2_5ClearEvE3$_0EET_S5_:
  688|  7.66M|  KeyValueFunctor ForEach(KeyValueFunctor func) {
  689|  7.66M|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  7.66M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 7.66M]
  |  |  ------------------
  ------------------
  690|      0|      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
  691|      0|    }
  692|  7.66M|    return ForEach(flat_begin(), flat_end(), std::move(func));
  693|  7.66M|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIPNS2_8KeyValueEZNS2_5ClearEvE3$_0EET0_T_S8_S7_:
  681|  7.66M|                                 KeyValueFunctor func) {
  682|  7.66M|    for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
  ------------------
  |  Branch (682:31): [True: 0, False: 7.66M]
  ------------------
  683|  7.66M|    return std::move(func);
  684|  7.66M|  }
extension_set.cc:_ZNK6google8protobuf8internal12ExtensionSet7ForEachIZNS2_9MergeFromERKS2_E3$_0EET_S7_:
  697|  84.3k|  KeyValueFunctor ForEach(KeyValueFunctor func) const {
  698|  84.3k|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  84.3k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 84.3k]
  |  |  ------------------
  ------------------
  699|      0|      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
  700|      0|    }
  701|  84.3k|    return ForEach(flat_begin(), flat_end(), std::move(func));
  702|  84.3k|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIPKNS2_8KeyValueEZNS2_9MergeFromERKS2_E3$_0EET0_T_SB_SA_:
  681|  84.3k|                                 KeyValueFunctor func) {
  682|  84.3k|    for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
  ------------------
  |  Branch (682:31): [True: 0, False: 84.3k]
  ------------------
  683|  84.3k|    return std::move(func);
  684|  84.3k|  }
extension_set.cc:_ZNK6google8protobuf8internal12ExtensionSet7ForEachIZNKS2_8ByteSizeEvE3$_0EET_S5_:
  697|   302k|  KeyValueFunctor ForEach(KeyValueFunctor func) const {
  698|   302k|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|   302k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 302k]
  |  |  ------------------
  ------------------
  699|      0|      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
  700|      0|    }
  701|   302k|    return ForEach(flat_begin(), flat_end(), std::move(func));
  702|   302k|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIPKNS2_8KeyValueEZNKS2_8ByteSizeEvE3$_0EET0_T_S9_S8_:
  681|   302k|                                 KeyValueFunctor func) {
  682|   302k|    for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
  ------------------
  |  Branch (682:31): [True: 0, False: 302k]
  ------------------
  683|   302k|    return std::move(func);
  684|   302k|  }

_ZNK6google8protobuf8internal10CachedSize3GetEv:
  188|   297k|  int Get() const { return size_.load(std::memory_order_relaxed); }
_ZN6google8protobuf8internal10CachedSize3SetEi:
  189|   302k|  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|  2.43M|inline void InitSCC(SCCInfoBase* scc) {
  248|  2.43M|  auto status = scc->visit_status.load(std::memory_order_acquire);
  249|  2.43M|  if (PROTOBUF_PREDICT_FALSE(status != SCCInfoBase::kInitialized))
  ------------------
  |  |  247|  2.43M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 9, False: 2.43M]
  |  |  ------------------
  ------------------
  250|      9|    InitSCCImpl(scc);
  251|  2.43M|}
_ZN6google8protobuf8internal24OnShutdownDestroyMessageEPKv:
  256|      6|inline void OnShutdownDestroyMessage(const void* ptr) {
  257|      6|  OnShutdownRun(DestroyMessage, ptr);
  258|      6|}
_ZN6google8protobuf8internal23OnShutdownDestroyStringEPKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  260|      1|inline void OnShutdownDestroyString(const std::string* ptr) {
  261|      1|  OnShutdownRun(DestroyString, ptr);
  262|      1|}

_ZN6google8protobuf8internal7HasBitsILm2EEixEi:
   56|  88.1k|  uint32& operator[](int index) PROTOBUF_ALWAYS_INLINE {
   57|  88.1k|    return has_bits_[index];
   58|  88.1k|  }
_ZN6google8protobuf8internal7HasBitsILm1EEixEi:
   56|  24.2M|  uint32& operator[](int index) PROTOBUF_ALWAYS_INLINE {
   57|  24.2M|    return has_bits_[index];
   58|  24.2M|  }
_ZNK6google8protobuf8internal7HasBitsILm2EEixEi:
   60|   234k|  const uint32& operator[](int index) const PROTOBUF_ALWAYS_INLINE {
   61|   234k|    return has_bits_[index];
   62|   234k|  }
_ZNK6google8protobuf8internal7HasBitsILm1EEixEi:
   60|   747k|  const uint32& operator[](int index) const PROTOBUF_ALWAYS_INLINE {
   61|   747k|    return has_bits_[index];
   62|   747k|  }
_ZN6google8protobuf8internal7HasBitsILm1EEC2Ev:
   50|  2.41M|  constexpr HasBits() PROTOBUF_ALWAYS_INLINE : has_bits_{} {}
_ZN6google8protobuf8internal7HasBitsILm1EE5ClearEv:
   52|  7.65M|  void Clear() PROTOBUF_ALWAYS_INLINE {
   53|  7.65M|    memset(has_bits_, 0, sizeof(has_bits_));
   54|  7.65M|  }
_ZN6google8protobuf8internal7HasBitsILm2EEC2Ev:
   50|  20.1k|  constexpr HasBits() PROTOBUF_ALWAYS_INLINE : has_bits_{} {}
_ZN6google8protobuf8internal7HasBitsILm2EE5ClearEv:
   52|  9.97k|  void Clear() PROTOBUF_ALWAYS_INLINE {
   53|  9.97k|    memset(has_bits_, 0, sizeof(has_bits_));
   54|  9.97k|  }

_ZN6google8protobuf2io19EpsCopyOutputStreamC2EPvib:
  669|  4.89k|      : end_(static_cast<uint8*>(data) + size),
  670|  4.89k|        buffer_end_(nullptr),
  671|  4.89k|        stream_(nullptr),
  672|  4.89k|        is_serialization_deterministic_(deterministic) {}
_ZN6google8protobuf2io19EpsCopyOutputStream11EnsureSpaceEPh:
  688|   630k|  PROTOBUF_MUST_USE_RESULT uint8* EnsureSpace(uint8* ptr) {
  689|   630k|    if (PROTOBUF_PREDICT_FALSE(ptr >= end_)) {
  ------------------
  |  |  247|   630k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 630k]
  |  |  ------------------
  ------------------
  690|      0|      return EnsureSpaceFallback(ptr);
  691|      0|    }
  692|   630k|    return ptr;
  693|   630k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream8WriteRawEPKviPh:
  695|  5.22k|  uint8* WriteRaw(const void* data, int size, uint8* ptr) {
  696|  5.22k|    if (PROTOBUF_PREDICT_FALSE(end_ - ptr < size)) {
  ------------------
  |  |  247|  5.22k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 5.22k]
  |  |  ------------------
  ------------------
  697|      0|      return WriteRawFallback(data, size, ptr);
  698|      0|    }
  699|  5.22k|    std::memcpy(ptr, data, size);
  700|  5.22k|    return ptr + size;
  701|  5.22k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream20WriteRawMaybeAliasedEPKviPh:
  706|  5.22k|  uint8* WriteRawMaybeAliased(const void* data, int size, uint8* ptr) {
  707|  5.22k|    if (aliasing_enabled_) {
  ------------------
  |  Branch (707:9): [True: 0, False: 5.22k]
  ------------------
  708|      0|      return WriteAliasedRaw(data, size, ptr);
  709|  5.22k|    } else {
  710|  5.22k|      return WriteRaw(data, size, ptr);
  711|  5.22k|    }
  712|  5.22k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream23WriteStringMaybeAliasedEjRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPh:
  715|   297k|  uint8* WriteStringMaybeAliased(uint32 num, const std::string& s, uint8* ptr) {
  716|   297k|    std::ptrdiff_t size = s.size();
  717|   297k|    if (PROTOBUF_PREDICT_FALSE(
  ------------------
  |  |  247|   590k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 5.22k, False: 292k]
  |  |  |  Branch (247:53): [True: 5.22k, False: 292k]
  |  |  |  Branch (247:53): [True: 0, False: 292k]
  |  |  ------------------
  ------------------
  718|   297k|            size >= 128 || end_ - ptr + 16 - TagSize(num << 3) - 1 < size)) {
  719|  5.22k|      return WriteStringMaybeAliasedOutline(num, s, ptr);
  720|  5.22k|    }
  721|   292k|    ptr = UnsafeVarint((num << 3) | 2, ptr);
  722|   292k|    *ptr++ = static_cast<uint8>(size);
  723|   292k|    std::memcpy(ptr, s.data(), size);
  724|   292k|    return ptr + size;
  725|   297k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream22WriteBytesMaybeAliasedEjRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEPh:
  726|  4.89k|  uint8* WriteBytesMaybeAliased(uint32 num, const std::string& s, uint8* ptr) {
  727|  4.89k|    return WriteStringMaybeAliased(num, s, ptr);
  728|  4.89k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream7TagSizeEj:
  849|   292k|  static constexpr int TagSize(uint32 tag) {
  850|   292k|    return (tag < (1 << 7))
  ------------------
  |  Branch (850:12): [True: 292k, False: 0]
  ------------------
  851|   292k|               ? 1
  852|   292k|               : (tag < (1 << 14))
  ------------------
  |  Branch (852:18): [True: 0, False: 0]
  ------------------
  853|      0|                     ? 2
  854|      0|                     : (tag < (1 << 21)) ? 3 : (tag < (1 << 28)) ? 4 : 5;
  ------------------
  |  Branch (854:24): [True: 0, False: 0]
  |  Branch (854:48): [True: 0, False: 0]
  ------------------
  855|   292k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream8WriteTagEjjPh:
  857|  5.22k|  PROTOBUF_ALWAYS_INLINE uint8* WriteTag(uint32 num, uint32 wt, uint8* ptr) {
  858|  5.22k|    GOOGLE_DCHECK(ptr < end_);  // NOLINT
  ------------------
  |  |  181|  5.22k|#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.22k]
  |  |  ------------------
  ------------------
  859|  5.22k|    return UnsafeVarint((num << 3) | wt, ptr);
  860|  5.22k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream16WriteLengthDelimEijPh:
  863|  5.22k|                                                 uint8* ptr) {
  864|  5.22k|    ptr = WriteTag(num, 2, ptr);
  865|  5.22k|    return UnsafeWriteSize(size, ptr);
  866|  5.22k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream15UnsafeWriteSizeEjPh:
  924|  5.22k|                                                       uint8* ptr) {
  925|  15.3k|    while (PROTOBUF_PREDICT_FALSE(value >= 0x80)) {
  ------------------
  |  |  247|  15.3k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 10.1k, False: 5.22k]
  |  |  ------------------
  ------------------
  926|  10.1k|      *ptr = static_cast<uint8>(value | 0x80);
  927|  10.1k|      value >>= 7;
  928|  10.1k|      ++ptr;
  929|  10.1k|    }
  930|  5.22k|    *ptr++ = static_cast<uint8>(value);
  931|  5.22k|    return ptr;
  932|  5.22k|  }
_ZN6google8protobuf2io17CodedOutputStream35IsDefaultSerializationDeterministicEv:
 1234|  4.89k|  static bool IsDefaultSerializationDeterministic() {
 1235|  4.89k|    return default_serialization_deterministic_.load(
 1236|  4.89k|               std::memory_order_relaxed) != 0;
 1237|  4.89k|  }
_ZN6google8protobuf2io17CodedOutputStream20WriteVarint32ToArrayEjPh:
 1589|   930k|                                                      uint8* target) {
 1590|   930k|  return EpsCopyOutputStream::UnsafeVarint(value, target);
 1591|   930k|}
_ZN6google8protobuf2io17CodedOutputStream20WriteVarint64ToArrayEmPh:
 1594|  30.5k|                                                      uint8* target) {
 1595|  30.5k|  return EpsCopyOutputStream::UnsafeVarint(value, target);
 1596|  30.5k|}
_ZN6google8protobuf2io17CodedOutputStream32WriteVarint32SignExtendedToArrayEiPh:
 1603|  29.3k|    int32 value, uint8* target) {
 1604|  29.3k|  return WriteVarint64ToArray(static_cast<uint64>(value), target);
 1605|  29.3k|}
_ZN6google8protobuf2io17CodedOutputStream26WriteLittleEndian32ToArrayEjPh:
 1608|   289k|                                                            uint8* target) {
 1609|   289k|#if defined(PROTOBUF_LITTLE_ENDIAN)
 1610|   289k|  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|   289k|  return target + sizeof(value);
 1618|   289k|}
_ZN6google8protobuf2io17CodedOutputStream15WriteTagToArrayEjPh:
 1652|   625k|inline uint8* CodedOutputStream::WriteTagToArray(uint32 value, uint8* target) {
 1653|   625k|  return WriteVarint32ToArray(value, target);
 1654|   625k|}
_ZN6google8protobuf2io17CodedOutputStream12VarintSize32Ej:
 1656|   624k|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|   624k|  uint32 log2value = Bits::Log2FloorNonZero(value | 0x1);
 1663|   624k|  return static_cast<size_t>((log2value * 9 + 73) / 64);
 1664|   624k|}
_ZN6google8protobuf2io17CodedOutputStream12VarintSize64Em:
 1666|  1.19k|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|  1.19k|  uint32 log2value = Bits::Log2FloorNonZero64(value | 0x1);
 1673|  1.19k|  return static_cast<size_t>((log2value * 9 + 73) / 64);
 1674|  1.19k|}
_ZN6google8protobuf2io17CodedOutputStream24VarintSize32SignExtendedEi:
 1676|  29.3k|inline size_t CodedOutputStream::VarintSize32SignExtended(int32 value) {
 1677|  29.3k|  if (value < 0) {
  ------------------
  |  Branch (1677:7): [True: 0, False: 29.3k]
  ------------------
 1678|      0|    return 10;  // TODO(kenton):  Make this a symbolic constant.
 1679|  29.3k|  } else {
 1680|  29.3k|    return VarintSize32(static_cast<uint32>(value));
 1681|  29.3k|  }
 1682|  29.3k|}
_ZN6google8protobuf2io19EpsCopyOutputStream12UnsafeVarintIjEEPhT_S4_:
  900|  1.22M|  PROTOBUF_ALWAYS_INLINE static uint8* UnsafeVarint(T value, uint8* ptr) {
  901|  1.22M|    static_assert(std::is_unsigned<T>::value,
  902|  1.22M|                  "Varint serialization must be unsigned");
  903|  1.22M|    if (value < 0x80) {
  ------------------
  |  Branch (903:9): [True: 1.21M, False: 17.7k]
  ------------------
  904|  1.21M|      ptr[0] = static_cast<uint8>(value);
  905|  1.21M|      return ptr + 1;
  906|  1.21M|    }
  907|  17.7k|    ptr[0] = static_cast<uint8>(value | 0x80);
  908|  17.7k|    value >>= 7;
  909|  17.7k|    if (value < 0x80) {
  ------------------
  |  Branch (909:9): [True: 12.9k, False: 4.89k]
  ------------------
  910|  12.9k|      ptr[1] = static_cast<uint8>(value);
  911|  12.9k|      return ptr + 2;
  912|  12.9k|    }
  913|  4.89k|    ptr++;
  914|  4.89k|    do {
  915|  4.89k|      *ptr = static_cast<uint8>(value | 0x80);
  916|  4.89k|      value >>= 7;
  917|  4.89k|      ++ptr;
  918|  4.89k|    } while (PROTOBUF_PREDICT_FALSE(value >= 0x80));
  ------------------
  |  |  247|  4.89k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.89k]
  |  |  ------------------
  ------------------
  919|  4.89k|    *ptr++ = static_cast<uint8>(value);
  920|  4.89k|    return ptr;
  921|  17.7k|  }
_ZN6google8protobuf2io19EpsCopyOutputStream12UnsafeVarintImEEPhT_S4_:
  900|  30.5k|  PROTOBUF_ALWAYS_INLINE static uint8* UnsafeVarint(T value, uint8* ptr) {
  901|  30.5k|    static_assert(std::is_unsigned<T>::value,
  902|  30.5k|                  "Varint serialization must be unsigned");
  903|  30.5k|    if (value < 0x80) {
  ------------------
  |  Branch (903:9): [True: 29.5k, False: 1.03k]
  ------------------
  904|  29.5k|      ptr[0] = static_cast<uint8>(value);
  905|  29.5k|      return ptr + 1;
  906|  29.5k|    }
  907|  1.03k|    ptr[0] = static_cast<uint8>(value | 0x80);
  908|  1.03k|    value >>= 7;
  909|  1.03k|    if (value < 0x80) {
  ------------------
  |  Branch (909:9): [True: 1.03k, False: 0]
  ------------------
  910|  1.03k|      ptr[1] = static_cast<uint8>(value);
  911|  1.03k|      return ptr + 2;
  912|  1.03k|    }
  913|      0|    ptr++;
  914|      0|    do {
  915|      0|      *ptr = static_cast<uint8>(value | 0x80);
  916|      0|      value >>= 7;
  917|      0|      ++ptr;
  918|      0|    } while (PROTOBUF_PREDICT_FALSE(value >= 0x80));
  ------------------
  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  919|      0|    *ptr++ = static_cast<uint8>(value);
  920|      0|    return ptr;
  921|  1.03k|  }

_ZN6google8protobuf2io19mutable_string_dataEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  387|  4.89k|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|  4.89k|  return &(*s)[0];
  391|  4.89k|}

_ZNK6google8protobuf11MessageLite8GetArenaEv:
  230|  8.34M|  Arena* GetArena() const { return _internal_metadata_.arena(); }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN13sentencepiece14NormalizerSpecEEEPT_PNS0_5ArenaE:
  479|  9.97k|  static T* CreateMaybeMessage(Arena* arena) {
  480|  9.97k|    return Arena::CreateMaybeMessage<T>(arena);
  481|  9.97k|  }
_ZN6google8protobuf11MessageLiteC2EPNS0_5ArenaE:
  483|  2.43M|  inline explicit MessageLite(Arena* arena) : _internal_metadata_(arena) {}
_ZN6google8protobuf8internal12ToCachedSizeEm:
   97|   302k|inline int ToCachedSize(size_t size) { return static_cast<int>(size); }
_ZN6google8protobuf8internal11FromIntSizeEi:
  104|  19.5k|inline size_t FromIntSize(int size) {
  105|       |  // Convert to unsigned before widening so sign extension is not necessary.
  106|  19.5k|  return static_cast<unsigned int>(size);
  107|  19.5k|}
_ZN6google8protobuf8internal27GetEmptyStringAlreadyInitedEv:
  173|  13.9M|PROTOBUF_EXPORT constexpr const std::string& GetEmptyStringAlreadyInited() {
  174|  13.9M|  return fixed_address_empty_string.value;
  175|  13.9M|}
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN13sentencepiece11TrainerSpecEEEPT_PNS0_5ArenaE:
  479|  9.97k|  static T* CreateMaybeMessage(Arena* arena) {
  480|  9.97k|    return Arena::CreateMaybeMessage<T>(arena);
  481|  9.97k|  }
_ZN6google8protobuf11MessageLiteD2Ev:
  210|  2.49M|  virtual ~MessageLite() = default;
_ZN6google8protobuf11MessageLiteC2Ev:
  209|  64.4k|  constexpr MessageLite() = default;

_ZNK6google8protobuf8internal16InternalMetadata5arenaEv:
   72|  8.34M|  PROTOBUF_ALWAYS_INLINE Arena* arena() const {
   73|  8.34M|    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
  ------------------
  |  |  247|  8.34M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 8.34M]
  |  |  ------------------
  ------------------
   74|      0|      return PtrValue<ContainerBase>()->arena;
   75|  8.34M|    } else {
   76|  8.34M|      return PtrValue<Arena>();
   77|  8.34M|    }
   78|  8.34M|  }
_ZNK6google8protobuf8internal16InternalMetadata19have_unknown_fieldsEv:
   80|  19.1M|  PROTOBUF_ALWAYS_INLINE bool have_unknown_fields() const {
   81|  19.1M|    return PtrTag() == kTagContainer;
   82|  19.1M|  }
_ZNK6google8protobuf8internal16InternalMetadata6PtrTagEv:
  146|  19.1M|  PROTOBUF_ALWAYS_INLINE int PtrTag() const {
  147|  19.1M|    return reinterpret_cast<intptr_t>(ptr_) & kPtrTagMask;
  148|  19.1M|  }
_ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS0_5ArenaEEEPT_v:
  151|  8.34M|  U* PtrValue() const {
  152|  8.34M|    return reinterpret_cast<U*>(reinterpret_cast<intptr_t>(ptr_) &
  153|  8.34M|                                kPtrValueMask);
  154|  8.34M|  }
_ZN6google8protobuf8internal16InternalMetadataC2Ev:
   61|  64.4k|  constexpr InternalMetadata() : ptr_(nullptr) {}
_ZN6google8protobuf8internal16InternalMetadataC2EPNS0_5ArenaE:
   62|  2.43M|  explicit InternalMetadata(Arena* arena) : ptr_(arena) {}
_ZN6google8protobuf8internal16InternalMetadata9MergeFromINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvRKS2_:
  119|  84.3k|  PROTOBUF_ALWAYS_INLINE void MergeFrom(const InternalMetadata& other) {
  120|  84.3k|    if (other.have_unknown_fields()) {
  ------------------
  |  Branch (120:9): [True: 0, False: 84.3k]
  ------------------
  121|      0|      DoMergeFrom<T>(other.unknown_fields<T>(nullptr));
  122|      0|    }
  123|  84.3k|  }
_ZN6google8protobuf8internal16InternalMetadata6DeleteINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvv:
   65|  2.49M|  void Delete() {
   66|       |    // Note that Delete<> should be called not more than once.
   67|  2.49M|    if (have_unknown_fields() && arena() == NULL) {
  ------------------
  |  Branch (67:9): [True: 0, False: 2.49M]
  |  Branch (67:34): [True: 0, False: 0]
  ------------------
   68|      0|      delete PtrValue<Container<T>>();
   69|      0|    }
   70|  2.49M|  }
_ZN6google8protobuf8internal16InternalMetadata5ClearINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvv:
  126|  7.66M|  PROTOBUF_ALWAYS_INLINE void Clear() {
  127|  7.66M|    if (have_unknown_fields()) {
  ------------------
  |  Branch (127:9): [True: 0, False: 7.66M]
  ------------------
  128|      0|      DoClear<T>();
  129|      0|    }
  130|  7.66M|  }

_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5beginEv:
 2613|  60.7k|RepeatedPtrField<Element>::begin() const {
 2614|  60.7k|  return iterator(raw_data());
 2615|  60.7k|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8raw_dataEv:
 1857|   131k|inline void* const* RepeatedPtrFieldBase::raw_data() const {
 1858|   131k|  return rep_ ? rep_->elements : NULL;
  ------------------
  |  Branch (1858:10): [True: 9.78k, False: 121k]
  ------------------
 1859|   131k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEC2EPKPv:
 2432|   121k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEC2IS9_EERKNS2_IT_EE:
 2438|   121k|      : it_(other.it_) {
 2439|       |    // Force a compiler error if the other type is not convertible to ours.
 2440|   121k|    if (false) {
  ------------------
  |  Branch (2440:9): [Folded, False: 121k]
  ------------------
 2441|      0|      implicit_cast<Element*>(static_cast<OtherElement*>(nullptr));
 2442|      0|    }
 2443|   121k|  }
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE3endEv:
 2628|  60.7k|RepeatedPtrField<Element>::end() const {
 2629|  60.7k|  return iterator(raw_data() + size());
 2630|  60.7k|}
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE4sizeEv:
 2167|   119k|inline int RepeatedPtrField<Element>::size() const {
 2168|   119k|  return RepeatedPtrFieldBase::size();
 2169|   119k|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv:
 1700|   301k|inline int RepeatedPtrFieldBase::size() const { return current_size_; }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEneERKSB_:
 2463|  60.7k|  bool operator!=(const iterator& x) const { return it_ != x.it_; }
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseD2Ev:
  582|   165k|  ~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|   165k|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8GetArenaEv:
  719|  80.0k|  inline Arena* GetArena() const { return arena_; }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase5emptyEv:
 1698|  10.1k|inline bool RepeatedPtrFieldBase::empty() const { return current_size_ == 0; }
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5ClearEv:
 2293|  39.8k|inline void RepeatedPtrField<Element>::Clear() {
 2294|  39.8k|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 2295|  39.8k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEvv:
 1778|  39.8k|void RepeatedPtrFieldBase::Clear() {
 1779|  39.8k|  const int n = current_size_;
 1780|  39.8k|  GOOGLE_DCHECK_GE(n, 0);
  ------------------
  |  |  188|  39.8k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|  39.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: 39.8k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1781|  39.8k|  if (n > 0) {
  ------------------
  |  Branch (1781:7): [True: 0, False: 39.8k]
  ------------------
 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|  39.8k|}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE4sizeEv:
 2167|   182k|inline int RepeatedPtrField<Element>::size() const {
 2168|   182k|  return RepeatedPtrFieldBase::size();
 2169|   182k|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE5ClearEv:
 2293|  62.3k|inline void RepeatedPtrField<Element>::Clear() {
 2294|  62.3k|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 2295|  62.3k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEvv:
 1778|  62.3k|void RepeatedPtrFieldBase::Clear() {
 1779|  62.3k|  const int n = current_size_;
 1780|  62.3k|  GOOGLE_DCHECK_GE(n, 0);
  ------------------
  |  |  188|  62.3k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|  62.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: 62.3k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1781|  62.3k|  if (n > 0) {
  ------------------
  |  Branch (1781:7): [True: 45.5k, False: 16.7k]
  ------------------
 1782|  45.5k|    void* const* elements = rep_->elements;
 1783|  45.5k|    int i = 0;
 1784|  7.58M|    do {
 1785|  7.58M|      TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
 1786|  7.58M|    } while (i < n);
  ------------------
  |  Branch (1786:14): [True: 7.53M, False: 45.5k]
  ------------------
 1787|  45.5k|    current_size_ = 0;
 1788|  45.5k|  }
 1789|  62.3k|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE5ClearEPS4_:
  826|  7.58M|  static inline void Clear(GenericType* value) { value->Clear(); }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEPNT_4TypeEPv:
  748|   663M|  static inline typename TypeHandler::Type* cast(void* element) {
  749|   663M|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  750|   663M|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3GetEi:
 2172|   647M|inline const Element& RepeatedPtrField<Element>::Get(int index) const {
 2173|   647M|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 2174|   647M|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEERKNT_4TypeEi:
 1704|   647M|    int index) const {
 1705|   647M|  GOOGLE_DCHECK_GE(index, 0);
  ------------------
  |  |  188|   647M|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|   647M|#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: 647M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1706|   647M|  GOOGLE_DCHECK_LT(index, current_size_);
  ------------------
  |  |  185|   647M|#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
  |  |  ------------------
  |  |  |  |  181|   647M|#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: 647M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1707|   647M|  return *cast<TypeHandler>(rep_->elements[index]);
 1708|   647M|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3AddEv:
 2193|  8.24M|inline Element* RepeatedPtrField<Element>::Add() {
 2194|  8.24M|  return RepeatedPtrFieldBase::Add<TypeHandler>();
 2195|  8.24M|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEPNT_4TypeESB_:
 1741|  8.24M|    typename TypeHandler::Type* prototype) {
 1742|  8.24M|  if (rep_ != NULL && current_size_ < rep_->allocated_size) {
  ------------------
  |  Branch (1742:7): [True: 8.22M, False: 16.7k]
  |  Branch (1742:23): [True: 5.89M, False: 2.33M]
  ------------------
 1743|  5.89M|    return cast<TypeHandler>(rep_->elements[current_size_++]);
 1744|  5.89M|  }
 1745|  2.35M|  if (!rep_ || rep_->allocated_size == total_size_) {
  ------------------
  |  Branch (1745:7): [True: 16.7k, False: 2.33M]
  |  Branch (1745:16): [True: 63.3k, False: 2.27M]
  ------------------
 1746|  80.0k|    Reserve(total_size_ + 1);
 1747|  80.0k|  }
 1748|  2.35M|  ++rep_->allocated_size;
 1749|  2.35M|  typename TypeHandler::Type* result =
 1750|  2.35M|      TypeHandler::NewFromPrototype(prototype, arena_);
 1751|  2.35M|  rep_->elements[current_size_++] = result;
 1752|  2.35M|  return result;
 1753|  8.24M|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE16NewFromPrototypeEPKS4_PNS0_5ArenaE:
  836|  2.35M|    const GenericType* /* prototype */, Arena* arena) {
  837|  2.35M|  return New(arena);
  838|  2.35M|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE3NewEPNS0_5ArenaE:
  806|  2.35M|  static inline GenericType* New(Arena* arena) {
  807|  2.35M|    return Arena::CreateMaybeMessage<Type>(arena);
  808|  2.35M|  }
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5emptyEv:
 2162|  10.1k|inline bool RepeatedPtrField<Element>::empty() const {
 2163|  10.1k|  return RepeatedPtrFieldBase::empty();
 2164|  10.1k|}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE5beginEv:
 2613|  4.89k|RepeatedPtrField<Element>::begin() const {
 2614|  4.89k|  return iterator(raw_data());
 2615|  4.89k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN13sentencepiece24ModelProto_SentencePieceEEC2EPKPv:
 2432|  9.78k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEC2IS4_EERKNS2_IT_EE:
 2438|  9.78k|      : it_(other.it_) {
 2439|       |    // Force a compiler error if the other type is not convertible to ours.
 2440|  9.78k|    if (false) {
  ------------------
  |  Branch (2440:9): [Folded, False: 9.78k]
  ------------------
 2441|      0|      implicit_cast<Element*>(static_cast<OtherElement*>(nullptr));
 2442|      0|    }
 2443|  9.78k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3endEv:
 2628|  4.89k|RepeatedPtrField<Element>::end() const {
 2629|  4.89k|  return iterator(raw_data() + size());
 2630|  4.89k|}
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEneERKS6_:
 2463|   292k|  bool operator!=(const iterator& x) const { return it_ != x.it_; }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEppEv:
 2450|   287k|  iterator& operator++() {
 2451|   287k|    ++it_;
 2452|   287k|    return *this;
 2453|   287k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEdeEv:
 2446|   287k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPNS0_5ArenaE:
 2098|  80.4k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2ERKS9_:
 2103|  68.1k|    : RepeatedPtrFieldBase() {
 2104|  68.1k|  MergeFrom(other);
 2105|  68.1k|}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEED2Ev:
 2121|   148k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 2122|   148k|  Destroy<TypeHandler>();
 2123|   148k|}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE9MergeFromERKS9_:
 2299|   108k|    const RepeatedPtrField& other) {
 2300|   108k|  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
 2301|   108k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2Ev:
 1651|  68.1k|    : arena_(NULL), current_size_(0), total_size_(0), rep_(NULL) {}
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2EPNS0_5ArenaE:
 1654|  97.4k|    : arena_(arena), current_size_(0), total_size_(0), rep_(NULL) {}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7DestroyINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEvv:
 1657|   148k|void RepeatedPtrFieldBase::Destroy() {
 1658|   148k|  if (rep_ != NULL && arena_ == NULL) {
  ------------------
  |  Branch (1658:7): [True: 0, False: 148k]
  |  Branch (1658:23): [True: 0, False: 0]
  ------------------
 1659|      0|    int n = rep_->allocated_size;
 1660|      0|    void* const* elements = rep_->elements;
 1661|      0|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1661:21): [True: 0, False: 0]
  ------------------
 1662|      0|      TypeHandler::Delete(cast<TypeHandler>(elements[i]), NULL);
 1663|      0|    }
 1664|      0|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
 1665|      0|    const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
 1666|      0|    ::operator delete(static_cast<void*>(rep_), size);
 1667|       |#else
 1668|       |    ::operator delete(static_cast<void*>(rep_));
 1669|       |#endif
 1670|      0|  }
 1671|       |  rep_ = NULL;
 1672|   148k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase9MergeFromINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEvRKS2_:
 1798|   108k|inline void RepeatedPtrFieldBase::MergeFrom(const RepeatedPtrFieldBase& other) {
 1799|   108k|  GOOGLE_DCHECK_NE(&other, this);
  ------------------
  |  |  184|   108k|#define GOOGLE_DCHECK_NE(A, B) GOOGLE_DCHECK((A) != (B))
  |  |  ------------------
  |  |  |  |  181|   108k|#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: 108k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1800|   108k|  if (other.current_size_ == 0) return;
  ------------------
  |  Branch (1800:7): [True: 108k, False: 0]
  ------------------
 1801|      0|  MergeFromInternal(other,
 1802|      0|                    &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
 1803|      0|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEEC2EPNS0_5ArenaE:
 2098|      1|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEEC2EPNS0_5ArenaE:
 2098|  17.0k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEED2Ev:
 2121|  17.0k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 2122|  17.0k|  Destroy<TypeHandler>();
 2123|  17.0k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7DestroyINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEvv:
 1657|  17.0k|void RepeatedPtrFieldBase::Destroy() {
 1658|  17.0k|  if (rep_ != NULL && arena_ == NULL) {
  ------------------
  |  Branch (1658:7): [True: 16.7k, False: 252]
  |  Branch (1658:23): [True: 16.7k, False: 0]
  ------------------
 1659|  16.7k|    int n = rep_->allocated_size;
 1660|  16.7k|    void* const* elements = rep_->elements;
 1661|  2.37M|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1661:21): [True: 2.35M, False: 16.7k]
  ------------------
 1662|  2.35M|      TypeHandler::Delete(cast<TypeHandler>(elements[i]), NULL);
 1663|  2.35M|    }
 1664|  16.7k|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
 1665|  16.7k|    const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
 1666|  16.7k|    ::operator delete(static_cast<void*>(rep_), size);
 1667|       |#else
 1668|       |    ::operator delete(static_cast<void*>(rep_));
 1669|       |#endif
 1670|  16.7k|  }
 1671|       |  rep_ = NULL;
 1672|  17.0k|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE6DeleteEPS4_PNS0_5ArenaE:
  814|  2.35M|  static inline void Delete(GenericType* value, Arena* arena) {
  815|  2.35M|    if (arena == NULL) {
  ------------------
  |  Branch (815:9): [True: 2.35M, False: 0]
  ------------------
  816|  2.35M|      delete value;
  817|  2.35M|    }
  818|  2.35M|  }

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

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

_ZN6google8protobuf4Bits16Log2FloorNonZeroEj:
  282|   624k|  static uint32 Log2FloorNonZero(uint32 n) {
  283|   624k|#if defined(__GNUC__)
  284|   624k|  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|   624k|  }
_ZN6google8protobuf4Bits18Log2FloorNonZero64Em:
  294|  1.19k|  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|  1.19k|#if defined(__GNUC__) && !defined(GOOGLE_PROTOBUF_USE_PORTABLE_LOG2)
  302|  1.19k|  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|  1.19k|  }

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

_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|     20|      : ptr_(offset), length_(len) {
  229|       |    assert(len >= 0);
  230|     20|  }
_ZNK6google8protobuf11StringPiece4dataEv:
  246|      4|  const char* data() const { return ptr_; }
_ZNK6google8protobuf11StringPiece4sizeEv:
  247|      4|  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|   625k|                                                WireType type) {
  786|   625k|  return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
  ------------------
  |  |  204|   625k|  static_cast<uint32>((static_cast<uint32>(FIELD_NUMBER) << 3) | (TYPE))
  ------------------
  787|   625k|}
_ZN6google8protobuf8internal14WireFormatLite11EncodeFloatEf:
  809|   289k|inline uint32 WireFormatLite::EncodeFloat(float value) {
  810|   289k|  return bit_cast<uint32>(value);
  811|   289k|}
_ZN6google8protobuf8internal14WireFormatLite15WriteTagToArrayEiNS2_8WireTypeEPh:
 1355|   625k|                                              uint8* target) {
 1356|   625k|  return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type),
 1357|   625k|                                                target);
 1358|   625k|}
_ZN6google8protobuf8internal14WireFormatLite22WriteInt32NoTagToArrayEiPh:
 1361|  9.78k|                                                     uint8* target) {
 1362|  9.78k|  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
 1363|  9.78k|}
_ZN6google8protobuf8internal14WireFormatLite23WriteUInt64NoTagToArrayEmPh:
 1374|  1.19k|                                                      uint8* target) {
 1375|  1.19k|  return io::CodedOutputStream::WriteVarint64ToArray(value, target);
 1376|  1.19k|}
_ZN6google8protobuf8internal14WireFormatLite22WriteFloatNoTagToArrayEfPh:
 1406|   289k|                                                     uint8* target) {
 1407|   289k|  return io::CodedOutputStream::WriteLittleEndian32ToArray(EncodeFloat(value),
 1408|   289k|                                                           target);
 1409|   289k|}
_ZN6google8protobuf8internal14WireFormatLite21WriteBoolNoTagToArrayEbPh:
 1415|  7.66k|inline uint8* WireFormatLite::WriteBoolNoTagToArray(bool value, uint8* target) {
 1416|  7.66k|  return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target);
  ------------------
  |  Branch (1416:54): [True: 2.66k, False: 5.00k]
  ------------------
 1417|  7.66k|}
_ZN6google8protobuf8internal14WireFormatLite21WriteEnumNoTagToArrayEiPh:
 1418|  19.5k|inline uint8* WireFormatLite::WriteEnumNoTagToArray(int value, uint8* target) {
 1419|  19.5k|  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
 1420|  19.5k|}
_ZN6google8protobuf8internal14WireFormatLite17WriteInt32ToArrayEiiPh:
 1513|  9.78k|                                                uint8* target) {
 1514|  9.78k|  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 1515|  9.78k|  return WriteInt32NoTagToArray(value, target);
 1516|  9.78k|}
_ZN6google8protobuf8internal14WireFormatLite18WriteUInt64ToArrayEimPh:
 1528|  1.19k|                                                 uint8* target) {
 1529|  1.19k|  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 1530|  1.19k|  return WriteUInt64NoTagToArray(value, target);
 1531|  1.19k|}
_ZN6google8protobuf8internal14WireFormatLite17WriteFloatToArrayEifPh:
 1563|   289k|                                                uint8* target) {
 1564|   289k|  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
 1565|   289k|  return WriteFloatNoTagToArray(value, target);
 1566|   289k|}
_ZN6google8protobuf8internal14WireFormatLite16WriteBoolToArrayEibPh:
 1573|  7.66k|                                               uint8* target) {
 1574|  7.66k|  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 1575|  7.66k|  return WriteBoolNoTagToArray(value, target);
 1576|  7.66k|}
_ZN6google8protobuf8internal14WireFormatLite16WriteEnumToArrayEiiPh:
 1578|  19.5k|                                               uint8* target) {
 1579|  19.5k|  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
 1580|  19.5k|  return WriteEnumNoTagToArray(value, target);
 1581|  19.5k|}
_ZN6google8protobuf8internal14WireFormatLite9Int32SizeEi:
 1727|  9.78k|inline size_t WireFormatLite::Int32Size(int32 value) {
 1728|  9.78k|  return io::CodedOutputStream::VarintSize32SignExtended(value);
 1729|  9.78k|}
_ZN6google8protobuf8internal14WireFormatLite10UInt64SizeEm:
 1736|  1.19k|inline size_t WireFormatLite::UInt64Size(uint64 value) {
 1737|  1.19k|  return io::CodedOutputStream::VarintSize64(value);
 1738|  1.19k|}
_ZN6google8protobuf8internal14WireFormatLite8EnumSizeEi:
 1745|  19.5k|inline size_t WireFormatLite::EnumSize(int value) {
 1746|  19.5k|  return io::CodedOutputStream::VarintSize32SignExtended(value);
 1747|  19.5k|}
_ZN6google8protobuf8internal14WireFormatLite10StringSizeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1749|   292k|inline size_t WireFormatLite::StringSize(const std::string& value) {
 1750|   292k|  return LengthDelimitedSize(value.size());
 1751|   292k|}
_ZN6google8protobuf8internal14WireFormatLite9BytesSizeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1752|  4.89k|inline size_t WireFormatLite::BytesSize(const std::string& value) {
 1753|  4.89k|  return LengthDelimitedSize(value.size());
 1754|  4.89k|}
_ZN6google8protobuf8internal14WireFormatLite19LengthDelimitedSizeEm:
 1780|   595k|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|   595k|  return length +
 1786|   595k|         io::CodedOutputStream::VarintSize32(static_cast<uint32>(length));
 1787|   595k|}
_ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageIN13sentencepiece24ModelProto_SentencePieceEEEPhiRKT_S6_PNS0_2io19EpsCopyOutputStreamE:
 1693|   287k|    io::EpsCopyOutputStream* stream) {
 1694|   287k|  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 1695|   287k|  target = io::CodedOutputStream::WriteVarint32ToArray(
 1696|   287k|      static_cast<uint32>(value.GetCachedSize()), target);
 1697|   287k|  return value._InternalSerialize(target, stream);
 1698|   287k|}
_ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageIN13sentencepiece11TrainerSpecEEEPhiRKT_S6_PNS0_2io19EpsCopyOutputStreamE:
 1693|  4.89k|    io::EpsCopyOutputStream* stream) {
 1694|  4.89k|  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 1695|  4.89k|  target = io::CodedOutputStream::WriteVarint32ToArray(
 1696|  4.89k|      static_cast<uint32>(value.GetCachedSize()), target);
 1697|  4.89k|  return value._InternalSerialize(target, stream);
 1698|  4.89k|}
_ZN6google8protobuf8internal14WireFormatLite20InternalWriteMessageIN13sentencepiece14NormalizerSpecEEEPhiRKT_S6_PNS0_2io19EpsCopyOutputStreamE:
 1693|  4.89k|    io::EpsCopyOutputStream* stream) {
 1694|  4.89k|  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
 1695|  4.89k|  target = io::CodedOutputStream::WriteVarint32ToArray(
 1696|  4.89k|      static_cast<uint32>(value.GetCachedSize()), target);
 1697|  4.89k|  return value._InternalSerialize(target, stream);
 1698|  4.89k|}
_ZN6google8protobuf8internal14WireFormatLite11MessageSizeIN13sentencepiece24ModelProto_SentencePieceEEEmRKT_:
 1762|   287k|inline size_t WireFormatLite::MessageSize(const MessageType& value) {
 1763|   287k|  return LengthDelimitedSize(value.ByteSizeLong());
 1764|   287k|}
_ZN6google8protobuf8internal14WireFormatLite11MessageSizeIN13sentencepiece11TrainerSpecEEEmRKT_:
 1762|  4.89k|inline size_t WireFormatLite::MessageSize(const MessageType& value) {
 1763|  4.89k|  return LengthDelimitedSize(value.ByteSizeLong());
 1764|  4.89k|}
_ZN6google8protobuf8internal14WireFormatLite11MessageSizeIN13sentencepiece14NormalizerSpecEEEmRKT_:
 1762|  4.89k|inline size_t WireFormatLite::MessageSize(const MessageType& value) {
 1763|  4.89k|  return LengthDelimitedSize(value.ByteSizeLong());
 1764|  4.89k|}

_ZNK6google8protobuf11MessageLite14AppendToStringEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  448|  4.89k|bool MessageLite::AppendToString(std::string* output) const {
  449|  4.89k|  GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
  ------------------
  |  |  181|  4.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: 4.89k]
  |  |  ------------------
  ------------------
  450|  4.89k|  return AppendPartialToString(output);
  451|  4.89k|}
_ZNK6google8protobuf11MessageLite21AppendPartialToStringEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  453|  4.89k|bool MessageLite::AppendPartialToString(std::string* output) const {
  454|  4.89k|  size_t old_size = output->size();
  455|  4.89k|  size_t byte_size = ByteSizeLong();
  456|  4.89k|  if (byte_size > INT_MAX) {
  ------------------
  |  Branch (456:7): [True: 0, False: 4.89k]
  ------------------
  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|  4.89k|  STLStringResizeUninitialized(output, old_size + byte_size);
  463|  4.89k|  uint8* start =
  464|  4.89k|      reinterpret_cast<uint8*>(io::mutable_string_data(output) + old_size);
  465|  4.89k|  SerializeToArrayImpl(*this, start, byte_size);
  466|  4.89k|  return true;
  467|  4.89k|}
_ZNK6google8protobuf11MessageLite17SerializeAsStringEv:
  497|  4.89k|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|  4.89k|  std::string output;
  503|  4.89k|  if (!AppendToString(&output)) output.clear();
  ------------------
  |  Branch (503:7): [True: 0, False: 4.89k]
  ------------------
  504|  4.89k|  return output;
  505|  4.89k|}
_ZN6google8protobuf8internal13OnShutdownRunEPFvPKvES3_:
  564|      7|void OnShutdownRun(void (*f)(const void*), const void* arg) {
  565|      7|  auto shutdown_data = ShutdownData::get();
  566|      7|  MutexLock lock(&shutdown_data->mutex);
  567|      7|  shutdown_data->functions.push_back(std::make_pair(f, arg));
  568|      7|}
_ZN6google8protobuf20SerializeToArrayImplERKNS0_11MessageLiteEPhi:
  340|  4.89k|                                   int size) {
  341|  4.89k|  constexpr bool debug = false;
  342|  4.89k|  if (debug) {
  ------------------
  |  Branch (342:7): [Folded, False: 4.89k]
  ------------------
  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|  4.89k|  } else {
  356|  4.89k|    io::EpsCopyOutputStream out(
  357|  4.89k|        target, size,
  358|  4.89k|        io::CodedOutputStream::IsDefaultSerializationDeterministic());
  359|  4.89k|    auto res = msg._InternalSerialize(target, &out);
  360|  4.89k|    GOOGLE_DCHECK(target + size == res);
  ------------------
  |  |  181|  4.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: 4.89k]
  |  |  ------------------
  ------------------
  361|  4.89k|    return res;
  362|  4.89k|  }
  363|  4.89k|}
_ZN6google8protobuf8internal12ShutdownData3getEv:
  546|      7|  static ShutdownData* get() {
  547|      7|    static auto* data = new ShutdownData;
  548|      7|    return data;
  549|      7|  }

_ZN6google8protobuf8internal20RepeatedPtrFieldBase14InternalExtendEi:
   50|  80.0k|void** RepeatedPtrFieldBase::InternalExtend(int extend_amount) {
   51|  80.0k|  int new_size = current_size_ + extend_amount;
   52|  80.0k|  if (total_size_ >= new_size) {
  ------------------
  |  Branch (52:7): [True: 0, False: 80.0k]
  ------------------
   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|  80.0k|  Rep* old_rep = rep_;
   58|  80.0k|  Arena* arena = GetArena();
   59|  80.0k|  new_size = std::max(internal::kRepeatedFieldLowerClampLimit,
   60|  80.0k|                      std::max(total_size_ * 2, new_size));
   61|  80.0k|  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|  80.0k|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|  80.0k|  !(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: 80.0k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   62|      0|                         sizeof(old_rep->elements[0]))
   63|      0|      << "Requested size is too large to fit into size_t.";
   64|  80.0k|  size_t bytes = kRepHeaderSize + sizeof(old_rep->elements[0]) * new_size;
   65|  80.0k|  if (arena == NULL) {
  ------------------
  |  Branch (65:7): [True: 80.0k, False: 0]
  ------------------
   66|  80.0k|    rep_ = reinterpret_cast<Rep*>(::operator new(bytes));
   67|  80.0k|  } else {
   68|      0|    rep_ = reinterpret_cast<Rep*>(Arena::CreateArray<char>(arena, bytes));
   69|      0|  }
   70|  80.0k|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
   71|  80.0k|  const int old_total_size = total_size_;
   72|  80.0k|#endif
   73|  80.0k|  total_size_ = new_size;
   74|  80.0k|  if (old_rep && old_rep->allocated_size > 0) {
  ------------------
  |  Branch (74:7): [True: 63.3k, False: 16.7k]
  |  Branch (74:18): [True: 63.3k, False: 0]
  ------------------
   75|  63.3k|    memcpy(rep_->elements, old_rep->elements,
   76|  63.3k|           old_rep->allocated_size * sizeof(rep_->elements[0]));
   77|  63.3k|    rep_->allocated_size = old_rep->allocated_size;
   78|  63.3k|  } else {
   79|  16.7k|    rep_->allocated_size = 0;
   80|  16.7k|  }
   81|  80.0k|  if (arena == NULL) {
  ------------------
  |  Branch (81:7): [True: 80.0k, False: 0]
  ------------------
   82|  80.0k|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
   83|  80.0k|    const size_t old_size =
   84|  80.0k|        old_total_size * sizeof(rep_->elements[0]) + kRepHeaderSize;
   85|  80.0k|    ::operator delete(static_cast<void*>(old_rep), old_size);
   86|       |#else
   87|       |    ::operator delete(static_cast<void*>(old_rep));
   88|       |#endif
   89|  80.0k|  }
   90|  80.0k|  return &rep_->elements[current_size_];
   91|  80.0k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7ReserveEi:
   93|  80.0k|void RepeatedPtrFieldBase::Reserve(int new_size) {
   94|  80.0k|  if (new_size > current_size_) {
  ------------------
  |  Branch (94:7): [True: 80.0k, False: 0]
  ------------------
   95|  80.0k|    InternalExtend(new_size - current_size_);
   96|  80.0k|  }
   97|  80.0k|}

_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|  }

LLVMFuzzerTestOneInput:
   23|  10.1k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   24|  10.1k|  FuzzedDataProvider fdp(data, size);
   25|       |
   26|       |  // Training is expensive, so we limit the number of sentences and their length.
   27|       |  // We also limit the vocab_size.
   28|       |  
   29|  10.1k|  int vocab_size = fdp.ConsumeIntegralInRange<int>(10, 100);
   30|  10.1k|  std::string model_type;
   31|  10.1k|  switch (fdp.ConsumeIntegralInRange<int>(0, 3)) {
  ------------------
  |  Branch (31:11): [True: 10.1k, False: 0]
  ------------------
   32|  6.89k|    case 0: model_type = "unigram"; break;
  ------------------
  |  Branch (32:5): [True: 6.89k, False: 3.23k]
  ------------------
   33|  1.81k|    case 1: model_type = "bpe"; break;
  ------------------
  |  Branch (33:5): [True: 1.81k, False: 8.31k]
  ------------------
   34|  1.17k|    case 2: model_type = "word"; break;
  ------------------
  |  Branch (34:5): [True: 1.17k, False: 8.96k]
  ------------------
   35|    246|    case 3: model_type = "char"; break;
  ------------------
  |  Branch (35:5): [True: 246, False: 9.88k]
  ------------------
   36|  10.1k|  }
   37|       |
   38|       |  // We use an empty model_prefix and pass a pointer to a string to receive
   39|       |  // the serialized model proto. This avoids writing to disk.
   40|  10.1k|  std::string args = "--vocab_size=" + std::to_string(vocab_size) +
   41|  10.1k|                     " --model_type=" + model_type;
   42|       |
   43|       |  // Randomly add some other common flags
   44|  10.1k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (44:7): [True: 2.54k, False: 7.58k]
  ------------------
   45|  2.54k|    args += " --character_coverage=" + std::to_string(fdp.ConsumeFloatingPointInRange<float>(0.98, 1.0));
   46|  2.54k|  }
   47|  10.1k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (47:7): [True: 2.04k, False: 8.08k]
  ------------------
   48|  2.04k|    args += " --input_sentence_size=" + std::to_string(fdp.ConsumeIntegralInRange<int>(100, 500));
   49|  2.04k|  }
   50|  10.1k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (50:7): [True: 2.53k, False: 7.59k]
  ------------------
   51|  2.53k|    args += " --shuffle_input_sentence=" + std::string(fdp.ConsumeBool() ? "true" : "false");
  ------------------
  |  Branch (51:56): [True: 1.13k, False: 1.40k]
  ------------------
   52|  2.53k|  }
   53|  10.1k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (53:7): [True: 3.55k, False: 6.58k]
  ------------------
   54|  3.55k|    args += " --split_by_unicode_script=" + std::string(fdp.ConsumeBool() ? "true" : "false");
  ------------------
  |  Branch (54:57): [True: 693, False: 2.85k]
  ------------------
   55|  3.55k|  }
   56|  10.1k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (56:7): [True: 2.64k, False: 7.48k]
  ------------------
   57|  2.64k|    args += " --split_by_whitespace=" + std::string(fdp.ConsumeBool() ? "true" : "false");
  ------------------
  |  Branch (57:53): [True: 1.40k, False: 1.24k]
  ------------------
   58|  2.64k|  }
   59|  10.1k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (59:7): [True: 2.75k, False: 7.37k]
  ------------------
   60|  2.75k|    args += " --split_by_number=" + std::string(fdp.ConsumeBool() ? "true" : "false");
  ------------------
  |  Branch (60:49): [True: 1.30k, False: 1.45k]
  ------------------
   61|  2.75k|  }
   62|  10.1k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (62:7): [True: 1.65k, False: 8.47k]
  ------------------
   63|  1.65k|    args += " --byte_fallback=" + std::string(fdp.ConsumeBool() ? "true" : "false");
  ------------------
  |  Branch (63:47): [True: 86, False: 1.56k]
  ------------------
   64|  1.65k|  }
   65|       |  
   66|       |  // Mandatory for performance in fuzzing
   67|  10.1k|  args += " --num_threads=1";
   68|       |
   69|       |  // Generate a small number of training sentences
   70|  10.1k|  int num_sentences = fdp.ConsumeIntegralInRange<int>(1, 50);
   71|  10.1k|  std::vector<std::string> sentences;
   72|   269k|  for (int i = 0; i < num_sentences; ++i) {
  ------------------
  |  Branch (72:19): [True: 259k, False: 10.1k]
  ------------------
   73|       |    // Keep sentences relatively short
   74|   259k|    std::string s = fdp.ConsumeRandomLengthString(200);
   75|   259k|    if (!s.empty()) {
  ------------------
  |  Branch (75:9): [True: 65.3k, False: 194k]
  ------------------
   76|  65.3k|      sentences.push_back(s);
   77|  65.3k|    }
   78|   259k|  }
   79|       |
   80|       |  // Ensure we have at least one non-empty sentence to avoid immediate 
   81|       |  // failure in some trainer types that CHECK(!sentences_.empty()).
   82|  10.1k|  if (sentences.empty()) {
  ------------------
  |  Branch (82:7): [True: 452, False: 9.68k]
  ------------------
   83|    452|    sentences.push_back("the quick brown fox jumps over the lazy dog");
   84|    452|  }
   85|       |
   86|  10.1k|  std::string serialized_model_proto;
   87|       |  // Train can return various errors for invalid combinations of parameters,
   88|       |  // which is expected.
   89|  10.1k|  sentencepiece::SentencePieceTrainer::Train(args, sentences, &serialized_model_proto);
   90|       |
   91|  10.1k|  return 0;
   92|  10.1k|}