_ZNK13sentencepiece3bpe7Trainer6Symbol8ToStringEv:
   39|   124k|std::string Trainer::Symbol::ToString() const {
   40|   124k|  return string_util::UnicodeTextToUTF8(chars);
   41|   124k|}
_ZN13sentencepiece3bpe7Trainer13GetCharSymbolEDi:
   43|  1.10M|Trainer::Symbol* Trainer::GetCharSymbol(char32_t c) {
   44|  1.10M|  const uint64_t freq = port::FindWithDefault(required_chars_, c, 1);
   45|  1.10M|  CHECK_GT(freq, 0);
  ------------------
  |  |  128|  1.10M|  ABSL_LOG_INTERNAL_CHECK_GT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   59|  1.10M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_GT, >, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  1.10M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 1.10M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  1.10M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  1.10M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  1.10M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  1.10M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  1.10M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  1.10M|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   46|  1.10M|  const auto it = symbols_cache_.find(c);
   47|  1.10M|  if (it != symbols_cache_.end()) {
  ------------------
  |  Branch (47:7): [True: 1.07M, False: 28.8k]
  ------------------
   48|  1.07M|    return it->second;
   49|  1.07M|  }
   50|  28.8k|  auto s = std::make_unique<Symbol>();
   51|  28.8k|  s->is_unk = (kUNKChar == c);
   52|  28.8k|  s->fp = c;
   53|  28.8k|  s->chars.push_back(c);
   54|  28.8k|  s->freq = freq;
   55|  28.8k|  port::InsertOrDie(&symbols_cache_, s->fp, s.get());
   56|  28.8k|  Symbol* s_ptr = s.get();
   57|  28.8k|  allocated_.push_back(std::move(s));
   58|  28.8k|  return s_ptr;
   59|  1.10M|}
_ZN13sentencepiece3bpe7Trainer13GetPairSymbolEPKNS1_6SymbolES4_:
   62|  3.49M|                                        const Symbol* right) {
   63|  3.49M|  if (left == nullptr || right == nullptr || left->is_unk || right->is_unk) {
  ------------------
  |  Branch (63:7): [True: 0, False: 3.49M]
  |  Branch (63:26): [True: 0, False: 3.49M]
  |  Branch (63:46): [True: 54.5k, False: 3.43M]
  |  Branch (63:62): [True: 25.9k, False: 3.41M]
  ------------------
   64|  80.4k|    return nullptr;
   65|  80.4k|  }
   66|       |
   67|  3.41M|  const uint64_t fp = absl::HashOf(left->fp, right->fp);
   68|  3.41M|  const auto it = symbols_cache_.find(fp);
   69|  3.41M|  if (it != symbols_cache_.end()) {
  ------------------
  |  Branch (69:7): [True: 2.98M, False: 431k]
  ------------------
   70|  2.98M|    return it->second;
   71|  2.98M|  }
   72|       |
   73|   431k|  CHECK(!left->chars.empty());
  ------------------
  |  |   58|  3.41M|#define CHECK(condition) ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   27|  1.29M|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  180|   431k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|   863k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|   863k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 431k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|   431k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 431k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|   863k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 431k, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 431k]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 431k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  1.29M|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |   29|  1.29M|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   74|   431k|  CHECK(!right->chars.empty());
  ------------------
  |  |   58|   431k|#define CHECK(condition) ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   27|  1.29M|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  180|   431k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|   863k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|   863k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 431k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|   431k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 431k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|   863k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 431k, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 431k]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 431k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  1.29M|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |   29|  1.29M|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   84|      0|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   75|   431k|  string_util::UnicodeText ut;
   76|  1.63M|  for (const char32_t c : left->chars) {
  ------------------
  |  Branch (76:25): [True: 1.63M, False: 431k]
  ------------------
   77|  1.63M|    ut.push_back(c);
   78|  1.63M|  }
   79|  1.48M|  for (const char32_t c : right->chars) {
  ------------------
  |  Branch (79:25): [True: 1.48M, False: 431k]
  ------------------
   80|  1.48M|    ut.push_back(c);
   81|  1.48M|  }
   82|       |
   83|       |  // Do not make an invalid piece.
   84|   431k|  if (!IsValidSentencePiece(ut)) {
  ------------------
  |  Branch (84:7): [True: 167k, False: 264k]
  ------------------
   85|   167k|    return nullptr;
   86|   167k|  }
   87|       |
   88|   264k|  auto s = std::make_unique<Symbol>();
   89|   264k|  s->fp = fp;
   90|   264k|  s->left = left;
   91|   264k|  s->right = right;
   92|   264k|  s->chars = ut;
   93|   264k|  port::InsertOrDie(&symbols_cache_, s->fp, s.get());
   94|   264k|  Symbol* s_ptr = s.get();
   95|   264k|  allocated_.push_back(std::move(s));
   96|   264k|  return s_ptr;
   97|   431k|}
_ZNK13sentencepiece3bpe7Trainer11ComputeFreqEPNS1_6SymbolE:
   99|   333k|void Trainer::ComputeFreq(Symbol* symbol) const {
  100|   333k|  if (!symbol->needs_recomputation) {
  ------------------
  |  Branch (100:7): [True: 0, False: 333k]
  ------------------
  101|      0|    return;
  102|      0|  }
  103|   333k|  symbol->freq = 0;
  104|  3.26M|  for (auto it = symbol->positions.begin(); it != symbol->positions.end();) {
  ------------------
  |  Branch (104:45): [True: 2.92M, False: 333k]
  ------------------
  105|  2.92M|    const Position pos = DecodePos(*it);
  106|       |    // symbols_[sid][left] and symbols_[sid]right] must store
  107|       |    // the same symbols in symbol->left and symbols->right.
  108|  2.92M|    if (symbol->left != symbols_[pos.sid][pos.left] ||
  ------------------
  |  Branch (108:9): [True: 270k, False: 2.65M]
  ------------------
  109|  2.65M|        symbol->right != symbols_[pos.sid][pos.right]) {
  ------------------
  |  Branch (109:9): [True: 482k, False: 2.17M]
  ------------------
  110|   752k|      it = symbol->positions.erase(it);
  111|  2.17M|    } else {
  112|  2.17M|      symbol->freq += sentences_[pos.sid].second;
  113|  2.17M|      ++it;
  114|  2.17M|    }
  115|  2.92M|  }
  116|   333k|  symbol->needs_recomputation = false;
  117|   333k|}
_ZNK13sentencepiece3bpe7Trainer12GetNextIndexEii:
  119|   625k|int Trainer::GetNextIndex(int sid, int index) const {
  120|  1.10M|  for (size_t i = index + 1; i < symbols_[sid].size(); ++i) {
  ------------------
  |  Branch (120:30): [True: 1.08M, False: 15.4k]
  ------------------
  121|  1.08M|    if (symbols_[sid][i] == nullptr) {
  ------------------
  |  Branch (121:9): [True: 474k, False: 610k]
  ------------------
  122|   474k|      continue;
  123|   474k|    }
  124|   610k|    return i;
  125|  1.08M|  }
  126|  15.4k|  return -1;
  127|   625k|}
_ZNK13sentencepiece3bpe7Trainer12GetPrevIndexEii:
  129|   625k|int Trainer::GetPrevIndex(int sid, int index) const {
  130|  1.73M|  for (int i = index - 1; i >= 0; --i) {
  ------------------
  |  Branch (130:27): [True: 1.71M, False: 14.6k]
  ------------------
  131|  1.71M|    if (symbols_[sid][i] == nullptr) {
  ------------------
  |  Branch (131:9): [True: 1.10M, False: 611k]
  ------------------
  132|  1.10M|      continue;
  133|  1.10M|    }
  134|   611k|    return i;
  135|  1.71M|  }
  136|  14.6k|  return -1;
  137|   625k|}
_ZN13sentencepiece3bpe7Trainer10AddNewPairEiii:
  139|  2.30M|void Trainer::AddNewPair(int sid, int left, int right) {
  140|  2.30M|  if (left == -1 || right == -1) {
  ------------------
  |  Branch (140:7): [True: 14.6k, False: 2.28M]
  |  Branch (140:21): [True: 15.4k, False: 2.27M]
  ------------------
  141|  30.0k|    return;
  142|  30.0k|  }
  143|  2.27M|  auto* symbol = GetPairSymbol(symbols_[sid][left], symbols_[sid][right]);
  144|  2.27M|  if (symbol != nullptr) {
  ------------------
  |  Branch (144:7): [True: 2.09M, False: 173k]
  ------------------
  145|  2.09M|    symbol->positions.insert(EncodePos(sid, left, right));
  146|  2.09M|    if (!symbol->pending) {
  ------------------
  |  Branch (146:9): [True: 264k, False: 1.83M]
  ------------------
  147|   264k|      symbol->pending = true;
  148|   264k|      pending_queue_.push_back(symbol);
  149|   264k|    }
  150|  2.09M|  }
  151|  2.27M|}
_ZN13sentencepiece3bpe7Trainer9ResetFreqEiiiPKNS1_6SymbolE:
  153|  1.25M|void Trainer::ResetFreq(int sid, int left, int right, const Symbol* best) {
  154|  1.25M|  if (left == -1 || right == -1) {
  ------------------
  |  Branch (154:7): [True: 14.6k, False: 1.23M]
  |  Branch (154:21): [True: 15.4k, False: 1.22M]
  ------------------
  155|  30.0k|    return;
  156|  30.0k|  }
  157|  1.22M|  auto* symbol = GetPairSymbol(symbols_[sid][left], symbols_[sid][right]);
  158|  1.22M|  if (symbol != nullptr && symbol != best) {
  ------------------
  |  Branch (158:7): [True: 1.14M, False: 73.9k]
  |  Branch (158:28): [True: 859k, False: 288k]
  ------------------
  159|   859k|    symbol->needs_recomputation = true;
  160|   859k|  }
  161|  1.22M|}
_ZN13sentencepiece3bpe7Trainer12AcceptSymbolEPNS1_6SymbolE:
  163|  47.5k|absl::Status Trainer::AcceptSymbol(Symbol* symbol) {
  164|       |  // Add new bigrams which are created after symbol replacement.
  165|       |  // We do not need to scan all characters, but scan the neighbors in
  166|       |  // best_symbol.
  167|   914k|  for (const uint64_t& encoded_pos : symbol->positions) {
  ------------------
  |  Branch (167:36): [True: 914k, False: 47.5k]
  ------------------
  168|   914k|    const Position pos = DecodePos(encoded_pos);
  169|       |
  170|   914k|    if (symbols_[pos.sid][pos.left] == nullptr) {
  ------------------
  |  Branch (170:9): [True: 288k, False: 625k]
  ------------------
  171|       |      // left index might be NULL (set in the previous iteration)
  172|       |      // when left_symbol == right_symbol.
  173|   288k|      continue;
  174|   288k|    }
  175|   625k|    RET_CHECK(symbols_[pos.sid][pos.right]);
  ------------------
  |  |  285|   625k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 625k, False: 0]
  |  |  ------------------
  |  |  286|   625k|  } else /* NOLINT */                                         \
  |  |  287|   625k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  176|       |
  177|       |    // We have three bigrams [prev, left], [left, right], [right, next],
  178|       |    // which are affected with this symbol replacement.
  179|   625k|    const int next = GetNextIndex(pos.sid, pos.right);
  180|   625k|    const int prev = GetPrevIndex(pos.sid, pos.left);
  181|       |
  182|       |    // Resets the frequencies of bigrams [prev, left] and [right, next].
  183|   625k|    ResetFreq(pos.sid, prev, pos.left, symbol);
  184|   625k|    ResetFreq(pos.sid, pos.right, next, symbol);
  185|       |
  186|       |    // Merges two symbols.
  187|   625k|    symbols_[pos.sid][pos.left] = symbol;
  188|   625k|    symbols_[pos.sid][pos.right] = nullptr;
  189|       |
  190|       |    // Makes new symbol bigrams [prev, left] and [left, next].
  191|   625k|    AddNewPair(pos.sid, prev, pos.left);
  192|   625k|    AddNewPair(pos.sid, pos.left, next);
  193|   625k|  }
  194|       |
  195|       |  // Removes best_symbol so it is not selected again.
  196|  47.5k|  symbols_cache_.erase(symbol->fp);
  197|  47.5k|  symbol->active = false;
  198|       |
  199|  47.5k|  return absl::OkStatus();
  200|  47.5k|}
_ZN13sentencepiece3bpe7Trainer5TrainEv:
  202|  1.44k|absl::Status Trainer::Train() {
  203|  1.44k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  1.44k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  1.44k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  2.88k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  2.88k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  2.88k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 1.44k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  1.44k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 1.44k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  2.88k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 1.44k, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  2.88k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  2.88k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  1.44k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  2.88k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  204|       |
  205|       |#ifdef SPM_NLCODEC_BPE
  206|       |  if (absl::GetFlag(FLAGS_nlcodec_bpe)) {
  207|       |    return TrainFast();
  208|       |  }
  209|       |#endif  // SPM_NLCODEC_BPE
  210|       |
  211|  1.44k|  RET_CHECK(normalizer_spec_.escape_whitespaces());
  ------------------
  |  |  285|  1.44k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 1.44k, False: 0]
  |  |  ------------------
  |  |  286|  1.44k|  } else /* NOLINT */                                         \
  |  |  287|  1.44k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  212|  1.44k|  RET_CHECK_EQ(TrainerSpec::BPE, trainer_spec_.model_type());
  ------------------
  |  |  290|  1.44k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  285|  1.44k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 1.44k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  1.44k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  1.44k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  213|       |
  214|  1.44k|  symbols_.clear();
  215|  1.44k|  allocated_.clear();
  216|  1.44k|  symbols_cache_.clear();
  217|  1.44k|  pq_ = decltype(pq_)();
  218|  1.44k|  pending_queue_.clear();
  219|       |
  220|       |  // Load all sentences
  221|  1.44k|  RETURN_IF_ERROR(LoadSentences());
  ------------------
  |  |   44|  1.44k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  1.44k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  2.88k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  2.88k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  2.88k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 1.44k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  1.44k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 1.44k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  2.88k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 1.42k, False: 15]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  2.88k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  2.88k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  1.42k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  2.88k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  222|       |
  223|  1.42k|  if (trainer_spec_.split_by_whitespace()) {
  ------------------
  |  Branch (223:7): [True: 1.13k, False: 290]
  ------------------
  224|  1.13k|    SplitSentencesByWhitespace();
  225|  1.13k|  }
  226|       |
  227|       |  // Pretokenizer applied only in training time.
  228|       |  // Pretokenizer is used as a constraint of piece extractions.
  229|  1.42k|  const auto* pretokenizer = SentencePieceTrainer::GetPretokenizerForTraining();
  230|       |
  231|  1.42k|  if ((pretokenizer != nullptr) ||
  ------------------
  |  Branch (231:7): [True: 0, False: 1.42k]
  ------------------
  232|  1.42k|      !trainer_spec_.pretokenization_delimiter().empty()) {
  ------------------
  |  Branch (232:7): [True: 0, False: 1.42k]
  ------------------
  233|      0|    absl::string_view delimiter = trainer_spec_.pretokenization_delimiter();
  234|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  235|      0|    for (auto& w : sentences_) {
  ------------------
  |  Branch (235:18): [True: 0, False: 0]
  ------------------
  236|      0|      if (pretokenizer != nullptr) {
  ------------------
  |  Branch (236:11): [True: 0, False: 0]
  ------------------
  237|      0|        w.first = absl::StrJoin(pretokenizer->PreTokenize(w.first),
  238|      0|                                TrainerInterface::kUPPBoundaryStr);
  239|      0|      } else if (!delimiter.empty()) {
  ------------------
  |  Branch (239:18): [True: 0, False: 0]
  ------------------
  240|      0|        w.first = absl::StrReplaceAll(
  241|      0|            w.first, {{delimiter, TrainerInterface::kUPPBoundaryStr}});
  242|      0|      }
  243|      0|    }
  244|      0|  }
  245|       |
  246|       |  // Initializes symbols_. symbols_[sid][i] stores an unary symbol.
  247|  1.42k|  symbols_.resize(sentences_.size());
  248|  30.5k|  for (size_t i = 0; i < sentences_.size(); ++i) {
  ------------------
  |  Branch (248:22): [True: 29.1k, False: 1.42k]
  ------------------
  249|  29.1k|    for (const char32_t c :
  ------------------
  |  Branch (249:27): [True: 1.07M, False: 29.1k]
  ------------------
  250|  1.07M|         string_util::UTF8ToUnicodeText(sentences_[i].first)) {
  251|  1.07M|      symbols_[i].push_back(GetCharSymbol(c));
  252|  1.07M|    }
  253|  29.1k|  }
  254|       |
  255|       |  // Makes all bigram symbols.
  256|  30.5k|  for (size_t sid = 0; sid < symbols_.size(); ++sid) {
  ------------------
  |  Branch (256:24): [True: 29.1k, False: 1.42k]
  ------------------
  257|  1.07M|    for (size_t i = 1; i < symbols_[sid].size(); ++i) {
  ------------------
  |  Branch (257:24): [True: 1.04M, False: 29.1k]
  ------------------
  258|  1.04M|      AddNewPair(sid, i - 1, i);
  259|  1.04M|    }
  260|  29.1k|  }
  261|       |
  262|  80.5k|  for (Symbol* symbol : pending_queue_) {
  ------------------
  |  Branch (262:23): [True: 80.5k, False: 1.42k]
  ------------------
  263|  80.5k|    symbol->pending = false;
  264|  80.5k|    ComputeFreq(symbol);
  265|  80.5k|    pq_.push({symbol->freq, symbol});
  266|  80.5k|  }
  267|  1.42k|  pending_queue_.clear();
  268|       |
  269|  1.42k|  const int vocab_size =
  270|  1.42k|      trainer_spec_.vocab_size() - meta_pieces_.size() - required_chars_.size();
  271|  1.42k|  RET_CHECK_GE(vocab_size, 0);
  ------------------
  |  |  292|  1.42k|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  285|  1.42k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 1.42k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  1.42k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  1.42k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  272|       |
  273|       |  // We may see duplicated pieces that are extracted with different path.
  274|       |  // In real segmentation phase, we can consider them as one symbol.
  275|       |  // e.g., "aaa" => "aa" + "a" or "a" + "aa".
  276|  1.42k|  absl::flat_hash_set<std::string> dup;
  277|       |
  278|       |  // Main loop.
  279|  1.42k|  RET_CHECK(final_pieces_.empty());
  ------------------
  |  |  285|  1.42k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 1.42k, False: 0]
  |  |  ------------------
  |  |  286|  1.42k|  } else /* NOLINT */                                         \
  |  |  287|  1.42k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  280|  48.9k|  while (final_pieces_.size() < static_cast<size_t>(vocab_size)) {
  ------------------
  |  Branch (280:10): [True: 48.0k, False: 884]
  ------------------
  281|  48.0k|    Symbol* best_symbol = nullptr;
  282|   116k|    while (!pq_.empty()) {
  ------------------
  |  Branch (282:12): [True: 116k, False: 542]
  ------------------
  283|   116k|      QueueEntry entry = pq_.top();
  284|   116k|      Symbol* symbol = entry.symbol;
  285|   116k|      if (!symbol->active) {
  ------------------
  |  Branch (285:11): [True: 0, False: 116k]
  ------------------
  286|      0|        pq_.pop();
  287|      0|        continue;
  288|      0|      }
  289|   116k|      if (entry.freq != symbol->freq) {
  ------------------
  |  Branch (289:11): [True: 0, False: 116k]
  ------------------
  290|      0|        pq_.pop();
  291|      0|        continue;
  292|      0|      }
  293|   116k|      if (symbol->needs_recomputation) {
  ------------------
  |  Branch (293:11): [True: 68.4k, False: 47.5k]
  ------------------
  294|  68.4k|        pq_.pop();
  295|  68.4k|        ComputeFreq(symbol);
  296|  68.4k|        pq_.push({symbol->freq, symbol});
  297|  68.4k|        continue;
  298|  68.4k|      }
  299|  47.5k|      best_symbol = symbol;
  300|  47.5k|      pq_.pop();
  301|  47.5k|      break;
  302|   116k|    }
  303|       |
  304|  48.0k|    if (best_symbol == nullptr) {
  ------------------
  |  Branch (304:9): [True: 542, False: 47.5k]
  ------------------
  305|  1.62k|      LOG(WARNING) << "No valid symbol found";
  ------------------
  |  |  218|    542|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|    542|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  174|    542|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  1.08k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  1.08k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 542, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|    542|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 542]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|    542|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 542]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|    542|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   60|  1.08k|  ::absl::log_internal::LogMessage(   \
  |  |  |  |  |  |   61|  1.08k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::WarningTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  306|    542|      break;
  307|    542|    }
  308|       |
  309|  47.5k|    if (!dup.insert(best_symbol->ToString()).second) {
  ------------------
  |  Branch (309:9): [True: 0, False: 47.5k]
  ------------------
  310|       |      // Removes best_symbol so it is not selected again.
  311|      0|      symbols_cache_.erase(best_symbol->fp);
  312|      0|      best_symbol->active = false;
  313|      0|      continue;
  314|      0|    }
  315|       |
  316|       |    // Stores the best_symbol in the final output.
  317|  47.5k|    final_pieces_.emplace_back(best_symbol->ToString(),
  318|  47.5k|                               -static_cast<float>(final_pieces_.size()));
  319|       |
  320|  47.5k|    if (final_pieces_.size() % 20 == 0) {
  ------------------
  |  Branch (320:9): [True: 1.79k, False: 45.7k]
  ------------------
  321|  5.38k|      LOG(INFO) << "Added: freq=" << best_symbol->freq
  ------------------
  |  |  218|  1.79k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  1.79k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  1.79k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  3.58k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  3.58k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 1.79k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  1.79k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 1.79k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  1.79k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 1.79k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  1.79k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  19.7k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  19.7k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  322|  5.38k|                << " size=" << final_pieces_.size()
  323|  5.38k|                << " all=" << symbols_cache_.size() << " active=" << pq_.size()
  324|  5.38k|                << " piece=" << best_symbol->ToString();
  325|  1.79k|    }
  326|       |
  327|  47.5k|    RETURN_IF_ERROR(AcceptSymbol(best_symbol));
  ------------------
  |  |   44|  47.5k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  47.5k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|   142k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  95.0k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  95.0k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 47.5k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  47.5k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 47.5k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|   142k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 47.5k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|   142k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|   142k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  47.5k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|   142k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  328|       |
  329|   184k|    for (Symbol* symbol : pending_queue_) {
  ------------------
  |  Branch (329:25): [True: 184k, False: 47.5k]
  ------------------
  330|   184k|      symbol->pending = false;
  331|   184k|      if (symbol->active) {
  ------------------
  |  Branch (331:11): [True: 184k, False: 0]
  ------------------
  332|   184k|        ComputeFreq(symbol);
  333|   184k|        pq_.push({symbol->freq, symbol});
  334|   184k|      }
  335|   184k|    }
  336|  47.5k|    pending_queue_.clear();
  337|  47.5k|  }  // end of main loop
  338|       |
  339|       |  // Adds required_chars_
  340|  28.1k|  for (const auto& w : Sorted(required_chars_)) {
  ------------------
  |  Branch (340:22): [True: 28.1k, False: 1.42k]
  ------------------
  341|  28.1k|    const Symbol* symbol = GetCharSymbol(w.first);
  342|  28.1k|    final_pieces_.emplace_back(symbol->ToString(),
  343|  28.1k|                               -static_cast<float>(final_pieces_.size()));
  344|  28.1k|  }
  345|       |
  346|  1.42k|  allocated_.clear();
  347|  1.42k|  symbols_cache_.clear();
  348|       |
  349|  1.42k|  return Save();
  350|  1.42k|}

_ZN13sentencepiece3bpe7TrainerC2ERKNS_11TrainerSpecERKNS_14NormalizerSpecES7_:
   39|  1.44k|      : TrainerInterface::TrainerInterface(trainer_spec, normalizer_spec,
   40|  1.44k|                                           denormalizer_spec) {}
_ZN13sentencepiece3bpe7Trainer9EncodePosEiii:
   85|  2.09M|  static uint64_t EncodePos(int sid, int l, int r) {
   86|  2.09M|    CHECK_GE(l, 0);
  ------------------
  |  |  126|  2.09M|  ABSL_LOG_INTERNAL_CHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   57|  2.09M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_GE, >=, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  2.09M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 2.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  2.09M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  2.09M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  2.09M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  2.09M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  2.09M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  2.09M|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   87|  2.09M|    CHECK_GE(r, 0);
  ------------------
  |  |  126|  2.09M|  ABSL_LOG_INTERNAL_CHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   57|  2.09M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_GE, >=, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  2.09M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 2.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  2.09M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  2.09M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  2.09M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  2.09M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  2.09M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  2.09M|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   88|  2.09M|    CHECK_LE(l, std::numeric_limits<uint16_t>::max());
  ------------------
  |  |  122|  2.09M|  ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   53|  2.09M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  2.09M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 2.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  2.09M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  2.09M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  2.09M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  2.09M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  2.09M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  2.09M|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   89|  2.09M|    CHECK_LE(r, std::numeric_limits<uint16_t>::max());
  ------------------
  |  |  122|  2.09M|  ABSL_LOG_INTERNAL_CHECK_LE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   53|  2.09M|  ABSL_LOG_INTERNAL_CHECK_OP(Check_LE, <=, val1, val1_text, val2, val2_text)
  |  |  |  |  ------------------
  |  |  |  |  |  |   68|  2.09M|  while (const char* absl_nullable absl_log_internal_check_op_result           \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (68:36): [True: 0, False: 2.09M]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   69|  2.09M|         [[maybe_unused]] = ::absl::log_internal::name##Impl(                  \
  |  |  |  |  |  |   70|  2.09M|             ::absl::log_internal::GetReferenceableValue(val1),                \
  |  |  |  |  |  |   71|  2.09M|             ::absl::log_internal::GetReferenceableValue(val2),                \
  |  |  |  |  |  |   72|  2.09M|             ABSL_LOG_INTERNAL_STRIP_STRING_LITERAL(val1_text " " #op          \
  |  |  |  |  |  |   73|  2.09M|                                                              " " val2_text))) \
  |  |  |  |  |  |   74|  2.09M|    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()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   90|  2.09M|    const uint64_t n = (static_cast<uint64_t>(sid) << 32) |
   91|  2.09M|                       (static_cast<uint64_t>(l) << 16) | r;
   92|  2.09M|    return n;
   93|  2.09M|  }
_ZN13sentencepiece3bpe7Trainer9DecodePosEm:
   96|  3.84M|  static Position DecodePos(uint64_t n) {
   97|  3.84M|    Position p;
   98|  3.84M|    p.sid = n >> 32;
   99|  3.84M|    p.left = (n >> 16) & 0xffff;
  100|  3.84M|    p.right = n & 0xffff;
  101|  3.84M|    return p;
  102|  3.84M|  }
_ZNK13sentencepiece3bpe7Trainer20QueueEntryComparatorclERKNS1_10QueueEntryES5_:
  139|  1.37M|    bool operator()(const QueueEntry& e1, const QueueEntry& e2) const {
  140|  1.37M|      if (e1.freq != e2.freq) {
  ------------------
  |  Branch (140:11): [True: 689k, False: 685k]
  ------------------
  141|   689k|        return e1.freq < e2.freq;
  142|   689k|      }
  143|   685k|      if (e1.symbol->chars.size() != e2.symbol->chars.size()) {
  ------------------
  |  Branch (143:11): [True: 278k, False: 406k]
  ------------------
  144|   278k|        return e1.symbol->chars.size() > e2.symbol->chars.size();
  145|   278k|      }
  146|   406k|      return e1.symbol->chars > e2.symbol->chars;
  147|   685k|    }
_ZN13sentencepiece3bpe7Trainer6SymbolC2Ev:
   74|   293k|    Symbol() = default;

_ZN13sentencepiece10normalizer7Builder22GetPrecompiledCharsMapENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEE:
  340|  8.54k|                                             std::string* output) {
  341|  8.54k|  RET_CHECK(output);
  ------------------
  |  |  285|  8.54k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  ------------------
  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  342|       |
  343|  8.54k|  if (name == "identity") {
  ------------------
  |  Branch (343:7): [True: 0, False: 8.54k]
  ------------------
  344|      0|    output->clear();
  345|      0|    return absl::OkStatus();
  346|      0|  }
  347|       |
  348|  8.54k|  if (!std::all_of(name.begin(), name.end(), [](auto c) {
  ------------------
  |  Branch (348:7): [True: 0, False: 8.54k]
  ------------------
  349|  8.54k|        return (c >= 'a' && c <= 'z') || c == '_' || c == '-';
  350|  8.54k|      })) {
  351|      0|    return absl::StatusBuilder(absl::StatusCode::kInvalidArgument)
  352|      0|           << "Invalid charsmap name " << name;
  353|      0|  }
  354|       |
  355|  8.54k|  std::string result;
  356|       |
  357|  8.54k|#ifndef DISABLE_EMBEDDED_DATA
  358|  17.0k|  for (size_t i = 0; i < kNormalizationRules_size; ++i) {
  ------------------
  |  Branch (358:22): [True: 17.0k, False: 0]
  ------------------
  359|  17.0k|    const auto* blob = &kNormalizationRules_blob[i];
  360|  17.0k|    if (blob->name == name) {
  ------------------
  |  Branch (360:9): [True: 8.54k, False: 8.54k]
  ------------------
  361|  8.54k|      output->assign(blob->data, blob->size);
  362|  8.54k|      return IsValidNormalizerData(*output);
  363|  8.54k|    }
  364|  17.0k|  }
  365|       |#else   // DISABLE_EMBEDDED_DATA
  366|       |  {
  367|       |    const std::string filename =
  368|       |        absl::StrCat(util::JoinPath(GetDataDir(), name), ".bin");
  369|       |    auto input = filesystem::NewReadableFile(filename, true /* is binary */);
  370|       |    if (input->status().ok()) {
  371|       |      input->ReadAll(output);
  372|       |      return IsValidNormalizerData(*output);
  373|       |    }
  374|       |  }
  375|       |#endif  // DISABLE_EMBEDDED_DATA
  376|       |
  377|      0|  return absl::StatusBuilder(absl::StatusCode::kNotFound)
  378|      0|         << "No precompiled charsmap is found: " << name << " in "
  379|      0|         << GetDataDir();
  380|  8.54k|}
builder.cc:_ZN13sentencepiece10normalizer12_GLOBAL__N_121IsValidNormalizerDataENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  164|  8.54k|absl::Status IsValidNormalizerData(absl::string_view blob_data) {
  165|  8.54k|  NormalizerSpec spec;
  166|  8.54k|  spec.set_precompiled_charsmap(blob_data.data(), blob_data.size());
  167|  8.54k|  const Normalizer normalizer(spec);
  168|  8.54k|  return normalizer.status();
  169|  8.54k|}
builder.cc:_ZZN13sentencepiece10normalizer7Builder22GetPrecompiledCharsMapENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEEENK3$_0clIcEEDaT_:
  348|  68.3k|  if (!std::all_of(name.begin(), name.end(), [](auto c) {
  349|  68.3k|        return (c >= 'a' && c <= 'z') || c == '_' || c == '-';
  ------------------
  |  Branch (349:17): [True: 59.8k, False: 8.54k]
  |  Branch (349:29): [True: 59.8k, False: 0]
  |  Branch (349:42): [True: 8.54k, False: 0]
  |  Branch (349:54): [True: 0, False: 0]
  ------------------
  350|  68.3k|      })) {

_ZN13sentencepiece11TrainerSpecC2EPN6google8protobuf5ArenaE:
  415|  25.5k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  416|  25.5k|  _extensions_(arena),
  417|  25.5k|  input_(arena),
  418|  25.5k|  accept_language_(arena),
  419|  25.5k|  control_symbols_(arena),
  420|  25.5k|  user_defined_symbols_(arena) {
  421|  25.5k|  SharedCtor();
  422|  25.5k|  RegisterArenaDtor(arena);
  423|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.TrainerSpec)
  424|  25.5k|}
_ZN13sentencepiece11TrainerSpecC2ERKS0_:
  426|  14.4k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
  427|  14.4k|      _has_bits_(from._has_bits_),
  428|  14.4k|      input_(from.input_),
  429|  14.4k|      accept_language_(from.accept_language_),
  430|  14.4k|      control_symbols_(from.control_symbols_),
  431|  14.4k|      user_defined_symbols_(from.user_defined_symbols_) {
  432|  14.4k|  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
  433|  14.4k|  _extensions_.MergeFrom(from._extensions_);
  434|  14.4k|  model_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  435|  14.4k|  if (from._internal_has_model_prefix()) {
  ------------------
  |  Branch (435:7): [True: 0, False: 14.4k]
  ------------------
  436|      0|    model_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_model_prefix(), 
  437|      0|      GetArena());
  438|      0|  }
  439|  14.4k|  input_format_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  440|  14.4k|  if (from._internal_has_input_format()) {
  ------------------
  |  Branch (440:7): [True: 0, False: 14.4k]
  ------------------
  441|      0|    input_format_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_input_format(), 
  442|      0|      GetArena());
  443|      0|  }
  444|  14.4k|  required_chars_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  445|  14.4k|  if (from._internal_has_required_chars()) {
  ------------------
  |  Branch (445:7): [True: 0, False: 14.4k]
  ------------------
  446|      0|    required_chars_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_required_chars(), 
  447|      0|      GetArena());
  448|      0|  }
  449|  14.4k|  unk_surface_.UnsafeSetDefault(nullptr);
  450|  14.4k|  if (from._internal_has_unk_surface()) {
  ------------------
  |  Branch (450:7): [True: 0, False: 14.4k]
  ------------------
  451|      0|    unk_surface_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_unk_surface(), 
  452|      0|      GetArena());
  453|      0|  }
  454|  14.4k|  unk_piece_.UnsafeSetDefault(nullptr);
  455|  14.4k|  if (from._internal_has_unk_piece()) {
  ------------------
  |  Branch (455:7): [True: 0, False: 14.4k]
  ------------------
  456|      0|    unk_piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_unk_piece(), 
  457|      0|      GetArena());
  458|      0|  }
  459|  14.4k|  bos_piece_.UnsafeSetDefault(nullptr);
  460|  14.4k|  if (from._internal_has_bos_piece()) {
  ------------------
  |  Branch (460:7): [True: 0, False: 14.4k]
  ------------------
  461|      0|    bos_piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_bos_piece(), 
  462|      0|      GetArena());
  463|      0|  }
  464|  14.4k|  eos_piece_.UnsafeSetDefault(nullptr);
  465|  14.4k|  if (from._internal_has_eos_piece()) {
  ------------------
  |  Branch (465:7): [True: 0, False: 14.4k]
  ------------------
  466|      0|    eos_piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_eos_piece(), 
  467|      0|      GetArena());
  468|      0|  }
  469|  14.4k|  pad_piece_.UnsafeSetDefault(nullptr);
  470|  14.4k|  if (from._internal_has_pad_piece()) {
  ------------------
  |  Branch (470:7): [True: 0, False: 14.4k]
  ------------------
  471|      0|    pad_piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, from._internal_pad_piece(), 
  472|      0|      GetArena());
  473|      0|  }
  474|  14.4k|  pretokenization_delimiter_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  475|  14.4k|  if (from._internal_has_pretokenization_delimiter()) {
  ------------------
  |  Branch (475:7): [True: 0, False: 14.4k]
  ------------------
  476|      0|    pretokenization_delimiter_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_pretokenization_delimiter(), 
  477|      0|      GetArena());
  478|      0|  }
  479|  14.4k|  seed_sentencepieces_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  480|  14.4k|  if (from._internal_has_seed_sentencepieces_file()) {
  ------------------
  |  Branch (480:7): [True: 0, False: 14.4k]
  ------------------
  481|      0|    seed_sentencepieces_file_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_seed_sentencepieces_file(), 
  482|      0|      GetArena());
  483|      0|  }
  484|  14.4k|  ::memcpy(&self_test_sample_size_, &from.self_test_sample_size_,
  485|  14.4k|    static_cast<size_t>(reinterpret_cast<char*>(&pad_id_) -
  486|  14.4k|    reinterpret_cast<char*>(&self_test_sample_size_)) + sizeof(pad_id_));
  487|       |  // @@protoc_insertion_point(copy_constructor:sentencepiece.TrainerSpec)
  488|  14.4k|}
_ZN13sentencepiece11TrainerSpecD2Ev:
  526|  39.9k|TrainerSpec::~TrainerSpec() {
  527|       |  // @@protoc_insertion_point(destructor:sentencepiece.TrainerSpec)
  528|  39.9k|  SharedDtor();
  529|  39.9k|  _internal_metadata_.Delete<std::string>();
  530|  39.9k|}
_ZNK13sentencepiece11TrainerSpec13SetCachedSizeEi:
  552|  4.30k|void TrainerSpec::SetCachedSize(int size) const {
  553|  4.30k|  _cached_size_.Set(size);
  554|  4.30k|}
_ZN13sentencepiece11TrainerSpec5ClearEv:
  561|  8.41k|void TrainerSpec::Clear() {
  562|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.TrainerSpec)
  563|  8.41k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  564|       |  // Prevent compiler warnings about cached_has_bits being unused
  565|  8.41k|  (void) cached_has_bits;
  566|       |
  567|  8.41k|  _extensions_.Clear();
  568|  8.41k|  input_.Clear();
  569|  8.41k|  accept_language_.Clear();
  570|  8.41k|  control_symbols_.Clear();
  571|  8.41k|  user_defined_symbols_.Clear();
  572|  8.41k|  cached_has_bits = _has_bits_[0];
  573|  8.41k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (573:7): [True: 0, False: 8.41k]
  ------------------
  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|  8.41k|  if (cached_has_bits & 0x00000300u) {
  ------------------
  |  Branch (599:7): [True: 0, False: 8.41k]
  ------------------
  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|  8.41k|  if (cached_has_bits & 0x0000fc00u) {
  ------------------
  |  Branch (607:7): [True: 0, False: 8.41k]
  ------------------
  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|  8.41k|  if (cached_has_bits & 0x00ff0000u) {
  ------------------
  |  Branch (612:7): [True: 0, False: 8.41k]
  ------------------
  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|  8.41k|  if (cached_has_bits & 0xff000000u) {
  ------------------
  |  Branch (617:7): [True: 0, False: 8.41k]
  ------------------
  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|  8.41k|  cached_has_bits = _has_bits_[1];
  628|  8.41k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (628:7): [True: 0, False: 8.41k]
  ------------------
  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|  8.41k|  if (cached_has_bits & 0x00000300u) {
  ------------------
  |  Branch (638:7): [True: 0, False: 8.41k]
  ------------------
  639|      0|    eos_id_ = 2;
  640|      0|    pad_id_ = -1;
  641|      0|  }
  642|  8.41k|  _has_bits_.Clear();
  643|  8.41k|  _internal_metadata_.Clear<std::string>();
  644|  8.41k|}
_ZNK13sentencepiece11TrainerSpec18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 1074|  4.30k|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 1075|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.TrainerSpec)
 1076|  4.30k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 1077|  4.30k|  (void) cached_has_bits;
 1078|       |
 1079|       |  // repeated string input = 1;
 1080|  4.30k|  for (int i = 0, n = this->_internal_input_size(); i < n; i++) {
  ------------------
  |  Branch (1080:53): [True: 0, False: 4.30k]
  ------------------
 1081|      0|    const auto& s = this->_internal_input(i);
 1082|      0|    target = stream->WriteString(1, s, target);
 1083|      0|  }
 1084|       |
 1085|  4.30k|  cached_has_bits = _has_bits_[0];
 1086|       |  // optional string model_prefix = 2;
 1087|  4.30k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1087:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x01000000u) {
  ------------------
  |  Branch (1093:7): [True: 4.30k, False: 0]
  ------------------
 1094|  4.30k|    target = stream->EnsureSpace(target);
 1095|  4.30k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
 1096|  4.30k|      3, this->_internal_model_type(), target);
 1097|  4.30k|  }
 1098|       |
 1099|       |  // optional int32 vocab_size = 4 [default = 8000];
 1100|  4.30k|  if (cached_has_bits & 0x02000000u) {
  ------------------
  |  Branch (1100:7): [True: 4.30k, False: 0]
  ------------------
 1101|  4.30k|    target = stream->EnsureSpace(target);
 1102|  4.30k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(4, this->_internal_vocab_size(), target);
 1103|  4.30k|  }
 1104|       |
 1105|       |  // repeated string accept_language = 5;
 1106|  4.30k|  for (int i = 0, n = this->_internal_accept_language_size(); i < n; i++) {
  ------------------
  |  Branch (1106:63): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000400u) {
  ------------------
  |  Branch (1112:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1118:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x04000000u) {
  ------------------
  |  Branch (1124:7): [True: 1.41k, False: 2.89k]
  ------------------
 1125|  1.41k|    target = stream->EnsureSpace(target);
 1126|  1.41k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(10, this->_internal_character_coverage(), target);
 1127|  1.41k|  }
 1128|       |
 1129|       |  // optional uint64 input_sentence_size = 11 [default = 0];
 1130|  4.30k|  if (cached_has_bits & 0x00001000u) {
  ------------------
  |  Branch (1130:7): [True: 1.04k, False: 3.26k]
  ------------------
 1131|  1.04k|    target = stream->EnsureSpace(target);
 1132|  1.04k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(11, this->_internal_input_sentence_size(), target);
 1133|  1.04k|  }
 1134|       |
 1135|       |  // optional int32 mining_sentence_size = 12 [deprecated = true];
 1136|  4.30k|  if (cached_has_bits & 0x00000800u) {
  ------------------
  |  Branch (1136:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00002000u) {
  ------------------
  |  Branch (1142:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x08000000u) {
  ------------------
  |  Branch (1148:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x10000000u) {
  ------------------
  |  Branch (1154:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x20000000u) {
  ------------------
  |  Branch (1160:7): [True: 4.30k, False: 0]
  ------------------
 1161|  4.30k|    target = stream->EnsureSpace(target);
 1162|  4.30k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(16, this->_internal_num_threads(), target);
 1163|  4.30k|  }
 1164|       |
 1165|       |  // optional int32 num_sub_iterations = 17 [default = 2];
 1166|  4.30k|  if (cached_has_bits & 0x40000000u) {
  ------------------
  |  Branch (1166:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x80000000u) {
  ------------------
  |  Branch (1172:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  cached_has_bits = _has_bits_[1];
 1178|       |  // optional bool shuffle_input_sentence = 19 [default = true];
 1179|  4.30k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1179:7): [True: 1.23k, False: 3.07k]
  ------------------
 1180|  1.23k|    target = stream->EnsureSpace(target);
 1181|  1.23k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(19, this->_internal_shuffle_input_sentence(), target);
 1182|  1.23k|  }
 1183|       |
 1184|       |  // optional int32 max_sentencepiece_length = 20 [default = 16];
 1185|  4.30k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1185:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1191:7): [True: 2.09k, False: 2.21k]
  ------------------
 1192|  2.09k|    target = stream->EnsureSpace(target);
 1193|  2.09k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(21, this->_internal_split_by_unicode_script(), target);
 1194|  2.09k|  }
 1195|       |
 1196|       |  // optional bool split_by_whitespace = 22 [default = true];
 1197|  4.30k|  if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1197:7): [True: 1.32k, False: 2.98k]
  ------------------
 1198|  1.32k|    target = stream->EnsureSpace(target);
 1199|  1.32k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(22, this->_internal_split_by_whitespace(), target);
 1200|  1.32k|  }
 1201|       |
 1202|       |  // optional bool split_by_number = 23 [default = true];
 1203|  4.30k|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1203:7): [True: 1.30k, False: 3.00k]
  ------------------
 1204|  1.30k|    target = stream->EnsureSpace(target);
 1205|  1.30k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(23, this->_internal_split_by_number(), target);
 1206|  1.30k|  }
 1207|       |
 1208|  4.30k|  cached_has_bits = _has_bits_[0];
 1209|       |  // optional bool treat_whitespace_as_suffix = 24 [default = false];
 1210|  4.30k|  if (cached_has_bits & 0x00008000u) {
  ------------------
  |  Branch (1210:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00020000u) {
  ------------------
  |  Branch (1216:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00010000u) {
  ------------------
  |  Branch (1222:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  for (int i = 0, n = this->_internal_control_symbols_size(); i < n; i++) {
  ------------------
  |  Branch (1228:63): [True: 0, False: 4.30k]
  ------------------
 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.30k|  for (int i = 0, n = this->_internal_user_defined_symbols_size(); i < n; i++) {
  ------------------
  |  Branch (1234:68): [True: 0, False: 4.30k]
  ------------------
 1235|      0|    const auto& s = this->_internal_user_defined_symbols(i);
 1236|      0|    target = stream->WriteString(31, s, target);
 1237|      0|  }
 1238|       |
 1239|  4.30k|  cached_has_bits = _has_bits_[1];
 1240|       |  // optional bool vocabulary_output_piece_score = 32 [default = true];
 1241|  4.30k|  if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1241:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1247:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  cached_has_bits = _has_bits_[0];
 1253|       |  // optional bool use_all_vocab = 34 [default = false];
 1254|  4.30k|  if (cached_has_bits & 0x00080000u) {
  ------------------
  |  Branch (1254:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00040000u) {
  ------------------
  |  Branch (1260:7): [True: 865, False: 3.44k]
  ------------------
 1261|    865|    target = stream->EnsureSpace(target);
 1262|    865|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(35, this->_internal_byte_fallback(), target);
 1263|    865|  }
 1264|       |
 1265|       |  // optional string required_chars = 36;
 1266|  4.30k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1266:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00200000u) {
  ------------------
  |  Branch (1272:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  cached_has_bits = _has_bits_[1];
 1278|       |  // optional int32 bos_id = 41 [default = 1];
 1279|  4.30k|  if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1279:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1285:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1291:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  cached_has_bits = _has_bits_[0];
 1297|       |  // optional string unk_surface = 44 [default = " \342\201\207 "];
 1298|  4.30k|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1298:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1304:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1310:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1316:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1322:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00100000u) {
  ------------------
  |  Branch (1328:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00004000u) {
  ------------------
  |  Branch (1334:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00400000u) {
  ------------------
  |  Branch (1340:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00800000u) {
  ------------------
  |  Branch (1346:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1352:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1358:7): [True: 0, False: 4.30k]
  ------------------
 1359|      0|    target = stream->WriteStringMaybeAliased(
 1360|      0|        54, this->_internal_seed_sentencepieces_file(), target);
 1361|      0|  }
 1362|       |
 1363|       |  // Extension range [200, 536870912)
 1364|  4.30k|  target = _extensions_._InternalSerialize(
 1365|  4.30k|      200, 536870912, target, stream);
 1366|       |
 1367|  4.30k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.30k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.30k]
  |  |  ------------------
  ------------------
 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.30k|  return target;
 1373|  4.30k|}
_ZNK13sentencepiece11TrainerSpec12ByteSizeLongEv:
 1375|  4.30k|size_t TrainerSpec::ByteSizeLong() const {
 1376|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.TrainerSpec)
 1377|  4.30k|  size_t total_size = 0;
 1378|       |
 1379|  4.30k|  total_size += _extensions_.ByteSize();
 1380|       |
 1381|  4.30k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 1382|       |  // Prevent compiler warnings about cached_has_bits being unused
 1383|  4.30k|  (void) cached_has_bits;
 1384|       |
 1385|       |  // repeated string input = 1;
 1386|  4.30k|  total_size += 1 *
 1387|  4.30k|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(input_.size());
 1388|  4.30k|  for (int i = 0, n = input_.size(); i < n; i++) {
  ------------------
  |  Branch (1388:38): [True: 0, False: 4.30k]
  ------------------
 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.30k|  total_size += 1 *
 1395|  4.30k|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(accept_language_.size());
 1396|  4.30k|  for (int i = 0, n = accept_language_.size(); i < n; i++) {
  ------------------
  |  Branch (1396:48): [True: 0, False: 4.30k]
  ------------------
 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.30k|  total_size += 2 *
 1403|  4.30k|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(control_symbols_.size());
 1404|  4.30k|  for (int i = 0, n = control_symbols_.size(); i < n; i++) {
  ------------------
  |  Branch (1404:48): [True: 0, False: 4.30k]
  ------------------
 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.30k|  total_size += 2 *
 1411|  4.30k|      ::PROTOBUF_NAMESPACE_ID::internal::FromIntSize(user_defined_symbols_.size());
 1412|  4.30k|  for (int i = 0, n = user_defined_symbols_.size(); i < n; i++) {
  ------------------
  |  Branch (1412:53): [True: 0, False: 4.30k]
  ------------------
 1413|      0|    total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 1414|      0|      user_defined_symbols_.Get(i));
 1415|      0|  }
 1416|       |
 1417|  4.30k|  cached_has_bits = _has_bits_[0];
 1418|  4.30k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (1418:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x0000ff00u) {
  ------------------
  |  Branch (1476:7): [True: 1.04k, False: 3.26k]
  ------------------
 1477|       |    // optional string pretokenization_delimiter = 53 [default = ""];
 1478|  1.04k|    if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1478:9): [True: 0, False: 1.04k]
  ------------------
 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.04k|    if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1485:9): [True: 0, False: 1.04k]
  ------------------
 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.04k|    if (cached_has_bits & 0x00000400u) {
  ------------------
  |  Branch (1492:9): [True: 0, False: 1.04k]
  ------------------
 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.04k|    if (cached_has_bits & 0x00000800u) {
  ------------------
  |  Branch (1499:9): [True: 0, False: 1.04k]
  ------------------
 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.04k|    if (cached_has_bits & 0x00001000u) {
  ------------------
  |  Branch (1506:9): [True: 1.04k, False: 0]
  ------------------
 1507|  1.04k|      total_size += 1 +
 1508|  1.04k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64Size(
 1509|  1.04k|          this->_internal_input_sentence_size());
 1510|  1.04k|    }
 1511|       |
 1512|       |    // optional int32 training_sentence_size = 13 [deprecated = true];
 1513|  1.04k|    if (cached_has_bits & 0x00002000u) {
  ------------------
  |  Branch (1513:9): [True: 0, False: 1.04k]
  ------------------
 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.04k|    if (cached_has_bits & 0x00004000u) {
  ------------------
  |  Branch (1520:9): [True: 0, False: 1.04k]
  ------------------
 1521|      0|      total_size += 2 + 1;
 1522|      0|    }
 1523|       |
 1524|       |    // optional bool treat_whitespace_as_suffix = 24 [default = false];
 1525|  1.04k|    if (cached_has_bits & 0x00008000u) {
  ------------------
  |  Branch (1525:9): [True: 0, False: 1.04k]
  ------------------
 1526|      0|      total_size += 2 + 1;
 1527|      0|    }
 1528|       |
 1529|  1.04k|  }
 1530|  4.30k|  if (cached_has_bits & 0x00ff0000u) {
  ------------------
  |  Branch (1530:7): [True: 865, False: 3.44k]
  ------------------
 1531|       |    // optional bool allow_whitespace_only_pieces = 26 [default = false];
 1532|    865|    if (cached_has_bits & 0x00010000u) {
  ------------------
  |  Branch (1532:9): [True: 0, False: 865]
  ------------------
 1533|      0|      total_size += 2 + 1;
 1534|      0|    }
 1535|       |
 1536|       |    // optional bool split_digits = 25 [default = false];
 1537|    865|    if (cached_has_bits & 0x00020000u) {
  ------------------
  |  Branch (1537:9): [True: 0, False: 865]
  ------------------
 1538|      0|      total_size += 2 + 1;
 1539|      0|    }
 1540|       |
 1541|       |    // optional bool byte_fallback = 35 [default = false];
 1542|    865|    if (cached_has_bits & 0x00040000u) {
  ------------------
  |  Branch (1542:9): [True: 865, False: 0]
  ------------------
 1543|    865|      total_size += 2 + 1;
 1544|    865|    }
 1545|       |
 1546|       |    // optional bool use_all_vocab = 34 [default = false];
 1547|    865|    if (cached_has_bits & 0x00080000u) {
  ------------------
  |  Branch (1547:9): [True: 0, False: 865]
  ------------------
 1548|      0|      total_size += 2 + 1;
 1549|      0|    }
 1550|       |
 1551|       |    // optional bool train_extremely_large_corpus = 49 [default = false];
 1552|    865|    if (cached_has_bits & 0x00100000u) {
  ------------------
  |  Branch (1552:9): [True: 0, False: 865]
  ------------------
 1553|      0|      total_size += 2 + 1;
 1554|      0|    }
 1555|       |
 1556|       |    // optional int32 unk_id = 40 [default = 0];
 1557|    865|    if (cached_has_bits & 0x00200000u) {
  ------------------
  |  Branch (1557:9): [True: 0, False: 865]
  ------------------
 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|    865|    if (cached_has_bits & 0x00400000u) {
  ------------------
  |  Branch (1564:9): [True: 0, False: 865]
  ------------------
 1565|      0|      total_size += 2 + 4;
 1566|      0|    }
 1567|       |
 1568|       |    // optional uint64 differential_privacy_clipping_threshold = 52 [default = 0];
 1569|    865|    if (cached_has_bits & 0x00800000u) {
  ------------------
  |  Branch (1569:9): [True: 0, False: 865]
  ------------------
 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|    865|  }
 1576|  4.30k|  if (cached_has_bits & 0xff000000u) {
  ------------------
  |  Branch (1576:7): [True: 4.30k, False: 0]
  ------------------
 1577|       |    // optional .sentencepiece.TrainerSpec.ModelType model_type = 3 [default = UNIGRAM];
 1578|  4.30k|    if (cached_has_bits & 0x01000000u) {
  ------------------
  |  Branch (1578:9): [True: 4.30k, False: 0]
  ------------------
 1579|  4.30k|      total_size += 1 +
 1580|  4.30k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_model_type());
 1581|  4.30k|    }
 1582|       |
 1583|       |    // optional int32 vocab_size = 4 [default = 8000];
 1584|  4.30k|    if (cached_has_bits & 0x02000000u) {
  ------------------
  |  Branch (1584:9): [True: 4.30k, False: 0]
  ------------------
 1585|  4.30k|      total_size += 1 +
 1586|  4.30k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1587|  4.30k|          this->_internal_vocab_size());
 1588|  4.30k|    }
 1589|       |
 1590|       |    // optional float character_coverage = 10 [default = 0.9995];
 1591|  4.30k|    if (cached_has_bits & 0x04000000u) {
  ------------------
  |  Branch (1591:9): [True: 1.41k, False: 2.89k]
  ------------------
 1592|  1.41k|      total_size += 1 + 4;
 1593|  1.41k|    }
 1594|       |
 1595|       |    // optional int32 seed_sentencepiece_size = 14 [default = 1000000];
 1596|  4.30k|    if (cached_has_bits & 0x08000000u) {
  ------------------
  |  Branch (1596:9): [True: 0, False: 4.30k]
  ------------------
 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.30k|    if (cached_has_bits & 0x10000000u) {
  ------------------
  |  Branch (1603:9): [True: 0, False: 4.30k]
  ------------------
 1604|      0|      total_size += 1 + 4;
 1605|      0|    }
 1606|       |
 1607|       |    // optional int32 num_threads = 16 [default = 16];
 1608|  4.30k|    if (cached_has_bits & 0x20000000u) {
  ------------------
  |  Branch (1608:9): [True: 4.30k, False: 0]
  ------------------
 1609|  4.30k|      total_size += 2 +
 1610|  4.30k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1611|  4.30k|          this->_internal_num_threads());
 1612|  4.30k|    }
 1613|       |
 1614|       |    // optional int32 num_sub_iterations = 17 [default = 2];
 1615|  4.30k|    if (cached_has_bits & 0x40000000u) {
  ------------------
  |  Branch (1615:9): [True: 0, False: 4.30k]
  ------------------
 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.30k|    if (cached_has_bits & 0x80000000u) {
  ------------------
  |  Branch (1622:9): [True: 0, False: 4.30k]
  ------------------
 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.30k|  }
 1629|  4.30k|  cached_has_bits = _has_bits_[1];
 1630|  4.30k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (1630:7): [True: 3.18k, False: 1.12k]
  ------------------
 1631|       |    // optional int32 max_sentencepiece_length = 20 [default = 16];
 1632|  3.18k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1632:9): [True: 0, False: 3.18k]
  ------------------
 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.18k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1639:9): [True: 1.23k, False: 1.95k]
  ------------------
 1640|  1.23k|      total_size += 2 + 1;
 1641|  1.23k|    }
 1642|       |
 1643|       |    // optional bool split_by_unicode_script = 21 [default = true];
 1644|  3.18k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1644:9): [True: 2.09k, False: 1.09k]
  ------------------
 1645|  2.09k|      total_size += 2 + 1;
 1646|  2.09k|    }
 1647|       |
 1648|       |    // optional bool split_by_number = 23 [default = true];
 1649|  3.18k|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1649:9): [True: 1.30k, False: 1.88k]
  ------------------
 1650|  1.30k|      total_size += 2 + 1;
 1651|  1.30k|    }
 1652|       |
 1653|       |    // optional bool split_by_whitespace = 22 [default = true];
 1654|  3.18k|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1654:9): [True: 1.32k, False: 1.86k]
  ------------------
 1655|  1.32k|      total_size += 2 + 1;
 1656|  1.32k|    }
 1657|       |
 1658|       |    // optional bool vocabulary_output_piece_score = 32 [default = true];
 1659|  3.18k|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1659:9): [True: 0, False: 3.18k]
  ------------------
 1660|      0|      total_size += 2 + 1;
 1661|      0|    }
 1662|       |
 1663|       |    // optional bool hard_vocab_limit = 33 [default = true];
 1664|  3.18k|    if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1664:9): [True: 0, False: 3.18k]
  ------------------
 1665|      0|      total_size += 2 + 1;
 1666|      0|    }
 1667|       |
 1668|       |    // optional int32 bos_id = 41 [default = 1];
 1669|  3.18k|    if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1669:9): [True: 0, False: 3.18k]
  ------------------
 1670|      0|      total_size += 2 +
 1671|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
 1672|      0|          this->_internal_bos_id());
 1673|      0|    }
 1674|       |
 1675|  3.18k|  }
 1676|  4.30k|  if (cached_has_bits & 0x00000300u) {
  ------------------
  |  Branch (1676:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.30k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.30k]
  |  |  ------------------
  ------------------
 1693|      0|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 1694|      0|  }
 1695|  4.30k|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 1696|  4.30k|  SetCachedSize(cached_size);
 1697|  4.30k|  return total_size;
 1698|  4.30k|}
_ZN13sentencepiece11TrainerSpec9MergeFromERKS0_:
 1706|  8.41k|void TrainerSpec::MergeFrom(const TrainerSpec& from) {
 1707|       |// @@protoc_insertion_point(class_specific_merge_from_start:sentencepiece.TrainerSpec)
 1708|  8.41k|  GOOGLE_DCHECK_NE(&from, this);
  ------------------
  |  |  184|  8.41k|#define GOOGLE_DCHECK_NE(A, B) GOOGLE_DCHECK((A) != (B))
  |  |  ------------------
  |  |  |  |  181|  8.41k|#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.41k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1709|  8.41k|  _extensions_.MergeFrom(from._extensions_);
 1710|  8.41k|  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
 1711|  8.41k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 1712|  8.41k|  (void) cached_has_bits;
 1713|       |
 1714|  8.41k|  input_.MergeFrom(from.input_);
 1715|  8.41k|  accept_language_.MergeFrom(from.accept_language_);
 1716|  8.41k|  control_symbols_.MergeFrom(from.control_symbols_);
 1717|  8.41k|  user_defined_symbols_.MergeFrom(from.user_defined_symbols_);
 1718|  8.41k|  cached_has_bits = from._has_bits_[0];
 1719|  8.41k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (1719:7): [True: 0, False: 8.41k]
  ------------------
 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|  8.41k|  if (cached_has_bits & 0x0000ff00u) {
  ------------------
  |  Branch (1745:7): [True: 1.72k, False: 6.69k]
  ------------------
 1746|  1.72k|    if (cached_has_bits & 0x00000100u) {
  ------------------
  |  Branch (1746:9): [True: 0, False: 1.72k]
  ------------------
 1747|      0|      _internal_set_pretokenization_delimiter(from._internal_pretokenization_delimiter());
 1748|      0|    }
 1749|  1.72k|    if (cached_has_bits & 0x00000200u) {
  ------------------
  |  Branch (1749:9): [True: 0, False: 1.72k]
  ------------------
 1750|      0|      _internal_set_seed_sentencepieces_file(from._internal_seed_sentencepieces_file());
 1751|      0|    }
 1752|  1.72k|    if (cached_has_bits & 0x00000400u) {
  ------------------
  |  Branch (1752:9): [True: 0, False: 1.72k]
  ------------------
 1753|      0|      self_test_sample_size_ = from.self_test_sample_size_;
 1754|      0|    }
 1755|  1.72k|    if (cached_has_bits & 0x00000800u) {
  ------------------
  |  Branch (1755:9): [True: 0, False: 1.72k]
  ------------------
 1756|      0|      mining_sentence_size_ = from.mining_sentence_size_;
 1757|      0|    }
 1758|  1.72k|    if (cached_has_bits & 0x00001000u) {
  ------------------
  |  Branch (1758:9): [True: 1.72k, False: 0]
  ------------------
 1759|  1.72k|      input_sentence_size_ = from.input_sentence_size_;
 1760|  1.72k|    }
 1761|  1.72k|    if (cached_has_bits & 0x00002000u) {
  ------------------
  |  Branch (1761:9): [True: 0, False: 1.72k]
  ------------------
 1762|      0|      training_sentence_size_ = from.training_sentence_size_;
 1763|      0|    }
 1764|  1.72k|    if (cached_has_bits & 0x00004000u) {
  ------------------
  |  Branch (1764:9): [True: 0, False: 1.72k]
  ------------------
 1765|      0|      enable_differential_privacy_ = from.enable_differential_privacy_;
 1766|      0|    }
 1767|  1.72k|    if (cached_has_bits & 0x00008000u) {
  ------------------
  |  Branch (1767:9): [True: 0, False: 1.72k]
  ------------------
 1768|      0|      treat_whitespace_as_suffix_ = from.treat_whitespace_as_suffix_;
 1769|      0|    }
 1770|  1.72k|    _has_bits_[0] |= cached_has_bits;
 1771|  1.72k|  }
 1772|  8.41k|  if (cached_has_bits & 0x00ff0000u) {
  ------------------
  |  Branch (1772:7): [True: 1.40k, False: 7.00k]
  ------------------
 1773|  1.40k|    if (cached_has_bits & 0x00010000u) {
  ------------------
  |  Branch (1773:9): [True: 0, False: 1.40k]
  ------------------
 1774|      0|      allow_whitespace_only_pieces_ = from.allow_whitespace_only_pieces_;
 1775|      0|    }
 1776|  1.40k|    if (cached_has_bits & 0x00020000u) {
  ------------------
  |  Branch (1776:9): [True: 0, False: 1.40k]
  ------------------
 1777|      0|      split_digits_ = from.split_digits_;
 1778|      0|    }
 1779|  1.40k|    if (cached_has_bits & 0x00040000u) {
  ------------------
  |  Branch (1779:9): [True: 1.40k, False: 0]
  ------------------
 1780|  1.40k|      byte_fallback_ = from.byte_fallback_;
 1781|  1.40k|    }
 1782|  1.40k|    if (cached_has_bits & 0x00080000u) {
  ------------------
  |  Branch (1782:9): [True: 0, False: 1.40k]
  ------------------
 1783|      0|      use_all_vocab_ = from.use_all_vocab_;
 1784|      0|    }
 1785|  1.40k|    if (cached_has_bits & 0x00100000u) {
  ------------------
  |  Branch (1785:9): [True: 0, False: 1.40k]
  ------------------
 1786|      0|      train_extremely_large_corpus_ = from.train_extremely_large_corpus_;
 1787|      0|    }
 1788|  1.40k|    if (cached_has_bits & 0x00200000u) {
  ------------------
  |  Branch (1788:9): [True: 0, False: 1.40k]
  ------------------
 1789|      0|      unk_id_ = from.unk_id_;
 1790|      0|    }
 1791|  1.40k|    if (cached_has_bits & 0x00400000u) {
  ------------------
  |  Branch (1791:9): [True: 0, False: 1.40k]
  ------------------
 1792|      0|      differential_privacy_noise_level_ = from.differential_privacy_noise_level_;
 1793|      0|    }
 1794|  1.40k|    if (cached_has_bits & 0x00800000u) {
  ------------------
  |  Branch (1794:9): [True: 0, False: 1.40k]
  ------------------
 1795|      0|      differential_privacy_clipping_threshold_ = from.differential_privacy_clipping_threshold_;
 1796|      0|    }
 1797|  1.40k|    _has_bits_[0] |= cached_has_bits;
 1798|  1.40k|  }
 1799|  8.41k|  if (cached_has_bits & 0xff000000u) {
  ------------------
  |  Branch (1799:7): [True: 8.41k, False: 0]
  ------------------
 1800|  8.41k|    if (cached_has_bits & 0x01000000u) {
  ------------------
  |  Branch (1800:9): [True: 8.41k, False: 0]
  ------------------
 1801|  8.41k|      model_type_ = from.model_type_;
 1802|  8.41k|    }
 1803|  8.41k|    if (cached_has_bits & 0x02000000u) {
  ------------------
  |  Branch (1803:9): [True: 8.41k, False: 0]
  ------------------
 1804|  8.41k|      vocab_size_ = from.vocab_size_;
 1805|  8.41k|    }
 1806|  8.41k|    if (cached_has_bits & 0x04000000u) {
  ------------------
  |  Branch (1806:9): [True: 2.12k, False: 6.28k]
  ------------------
 1807|  2.12k|      character_coverage_ = from.character_coverage_;
 1808|  2.12k|    }
 1809|  8.41k|    if (cached_has_bits & 0x08000000u) {
  ------------------
  |  Branch (1809:9): [True: 0, False: 8.41k]
  ------------------
 1810|      0|      seed_sentencepiece_size_ = from.seed_sentencepiece_size_;
 1811|      0|    }
 1812|  8.41k|    if (cached_has_bits & 0x10000000u) {
  ------------------
  |  Branch (1812:9): [True: 0, False: 8.41k]
  ------------------
 1813|      0|      shrinking_factor_ = from.shrinking_factor_;
 1814|      0|    }
 1815|  8.41k|    if (cached_has_bits & 0x20000000u) {
  ------------------
  |  Branch (1815:9): [True: 8.41k, False: 0]
  ------------------
 1816|  8.41k|      num_threads_ = from.num_threads_;
 1817|  8.41k|    }
 1818|  8.41k|    if (cached_has_bits & 0x40000000u) {
  ------------------
  |  Branch (1818:9): [True: 0, False: 8.41k]
  ------------------
 1819|      0|      num_sub_iterations_ = from.num_sub_iterations_;
 1820|      0|    }
 1821|  8.41k|    if (cached_has_bits & 0x80000000u) {
  ------------------
  |  Branch (1821:9): [True: 0, False: 8.41k]
  ------------------
 1822|      0|      max_sentence_length_ = from.max_sentence_length_;
 1823|      0|    }
 1824|  8.41k|    _has_bits_[0] |= cached_has_bits;
 1825|  8.41k|  }
 1826|  8.41k|  cached_has_bits = from._has_bits_[1];
 1827|  8.41k|  if (cached_has_bits & 0x000000ffu) {
  ------------------
  |  Branch (1827:7): [True: 5.35k, False: 3.06k]
  ------------------
 1828|  5.35k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (1828:9): [True: 0, False: 5.35k]
  ------------------
 1829|      0|      max_sentencepiece_length_ = from.max_sentencepiece_length_;
 1830|      0|    }
 1831|  5.35k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (1831:9): [True: 2.03k, False: 3.31k]
  ------------------
 1832|  2.03k|      shuffle_input_sentence_ = from.shuffle_input_sentence_;
 1833|  2.03k|    }
 1834|  5.35k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (1834:9): [True: 3.05k, False: 2.29k]
  ------------------
 1835|  3.05k|      split_by_unicode_script_ = from.split_by_unicode_script_;
 1836|  3.05k|    }
 1837|  5.35k|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (1837:9): [True: 2.25k, False: 3.09k]
  ------------------
 1838|  2.25k|      split_by_number_ = from.split_by_number_;
 1839|  2.25k|    }
 1840|  5.35k|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (1840:9): [True: 2.25k, False: 3.09k]
  ------------------
 1841|  2.25k|      split_by_whitespace_ = from.split_by_whitespace_;
 1842|  2.25k|    }
 1843|  5.35k|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (1843:9): [True: 0, False: 5.35k]
  ------------------
 1844|      0|      vocabulary_output_piece_score_ = from.vocabulary_output_piece_score_;
 1845|      0|    }
 1846|  5.35k|    if (cached_has_bits & 0x00000040u) {
  ------------------
  |  Branch (1846:9): [True: 0, False: 5.35k]
  ------------------
 1847|      0|      hard_vocab_limit_ = from.hard_vocab_limit_;
 1848|      0|    }
 1849|  5.35k|    if (cached_has_bits & 0x00000080u) {
  ------------------
  |  Branch (1849:9): [True: 0, False: 5.35k]
  ------------------
 1850|      0|      bos_id_ = from.bos_id_;
 1851|      0|    }
 1852|  5.35k|    _has_bits_[1] |= cached_has_bits;
 1853|  5.35k|  }
 1854|  8.41k|  if (cached_has_bits & 0x00000300u) {
  ------------------
  |  Branch (1854:7): [True: 0, False: 8.41k]
  ------------------
 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|  8.41k|}
_ZN13sentencepiece11TrainerSpec8CopyFromERKS0_:
 1865|  8.41k|void TrainerSpec::CopyFrom(const TrainerSpec& from) {
 1866|       |// @@protoc_insertion_point(class_specific_copy_from_start:sentencepiece.TrainerSpec)
 1867|  8.41k|  if (&from == this) return;
  ------------------
  |  Branch (1867:7): [True: 0, False: 8.41k]
  ------------------
 1868|  8.41k|  Clear();
 1869|  8.41k|  MergeFrom(from);
 1870|  8.41k|}
_ZN13sentencepiece11TrainerSpec12InternalSwapEPS0_:
 1880|  8.54k|void TrainerSpec::InternalSwap(TrainerSpec* other) {
 1881|  8.54k|  using std::swap;
 1882|  8.54k|  _extensions_.Swap(&other->_extensions_);
 1883|  8.54k|  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
 1884|  8.54k|  swap(_has_bits_[0], other->_has_bits_[0]);
 1885|  8.54k|  swap(_has_bits_[1], other->_has_bits_[1]);
 1886|  8.54k|  input_.InternalSwap(&other->input_);
 1887|  8.54k|  accept_language_.InternalSwap(&other->accept_language_);
 1888|  8.54k|  control_symbols_.InternalSwap(&other->control_symbols_);
 1889|  8.54k|  user_defined_symbols_.InternalSwap(&other->user_defined_symbols_);
 1890|  8.54k|  model_prefix_.Swap(&other->model_prefix_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 1891|  8.54k|  input_format_.Swap(&other->input_format_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 1892|  8.54k|  required_chars_.Swap(&other->required_chars_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 1893|  8.54k|  unk_surface_.Swap(&other->unk_surface_, nullptr, GetArena());
 1894|  8.54k|  unk_piece_.Swap(&other->unk_piece_, nullptr, GetArena());
 1895|  8.54k|  bos_piece_.Swap(&other->bos_piece_, nullptr, GetArena());
 1896|  8.54k|  eos_piece_.Swap(&other->eos_piece_, nullptr, GetArena());
 1897|  8.54k|  pad_piece_.Swap(&other->pad_piece_, nullptr, GetArena());
 1898|  8.54k|  pretokenization_delimiter_.Swap(&other->pretokenization_delimiter_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 1899|  8.54k|  seed_sentencepieces_file_.Swap(&other->seed_sentencepieces_file_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 1900|  8.54k|  ::PROTOBUF_NAMESPACE_ID::internal::memswap<
 1901|  8.54k|      PROTOBUF_FIELD_OFFSET(TrainerSpec, differential_privacy_clipping_threshold_)
 1902|  8.54k|      + sizeof(TrainerSpec::differential_privacy_clipping_threshold_)
 1903|  8.54k|      - PROTOBUF_FIELD_OFFSET(TrainerSpec, self_test_sample_size_)>(
 1904|  8.54k|          reinterpret_cast<char*>(&self_test_sample_size_),
 1905|  8.54k|          reinterpret_cast<char*>(&other->self_test_sample_size_));
 1906|  8.54k|  swap(model_type_, other->model_type_);
 1907|  8.54k|  swap(vocab_size_, other->vocab_size_);
 1908|  8.54k|  swap(character_coverage_, other->character_coverage_);
 1909|  8.54k|  swap(seed_sentencepiece_size_, other->seed_sentencepiece_size_);
 1910|  8.54k|  swap(shrinking_factor_, other->shrinking_factor_);
 1911|  8.54k|  swap(num_threads_, other->num_threads_);
 1912|  8.54k|  swap(num_sub_iterations_, other->num_sub_iterations_);
 1913|  8.54k|  swap(max_sentence_length_, other->max_sentence_length_);
 1914|  8.54k|  swap(max_sentencepiece_length_, other->max_sentencepiece_length_);
 1915|  8.54k|  swap(shuffle_input_sentence_, other->shuffle_input_sentence_);
 1916|  8.54k|  swap(split_by_unicode_script_, other->split_by_unicode_script_);
 1917|  8.54k|  swap(split_by_number_, other->split_by_number_);
 1918|  8.54k|  swap(split_by_whitespace_, other->split_by_whitespace_);
 1919|  8.54k|  swap(vocabulary_output_piece_score_, other->vocabulary_output_piece_score_);
 1920|  8.54k|  swap(hard_vocab_limit_, other->hard_vocab_limit_);
 1921|  8.54k|  swap(bos_id_, other->bos_id_);
 1922|  8.54k|  swap(eos_id_, other->eos_id_);
 1923|  8.54k|  swap(pad_id_, other->pad_id_);
 1924|  8.54k|}
_ZN13sentencepiece14NormalizerSpecC2EPN6google8protobuf5ArenaE:
 1957|  51.1k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 1958|  51.1k|  _extensions_(arena) {
 1959|  51.1k|  SharedCtor();
 1960|  51.1k|  RegisterArenaDtor(arena);
 1961|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.NormalizerSpec)
 1962|  51.1k|}
_ZN13sentencepiece14NormalizerSpecC2ERKS0_:
 1964|  40.0k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(),
 1965|  40.0k|      _has_bits_(from._has_bits_) {
 1966|  40.0k|  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
 1967|  40.0k|  _extensions_.MergeFrom(from._extensions_);
 1968|  40.0k|  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1969|  40.0k|  if (from._internal_has_name()) {
  ------------------
  |  Branch (1969:7): [True: 14.4k, False: 25.6k]
  ------------------
 1970|  14.4k|    name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_name(), 
 1971|  14.4k|      GetArena());
 1972|  14.4k|  }
 1973|  40.0k|  precompiled_charsmap_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1974|  40.0k|  if (from._internal_has_precompiled_charsmap()) {
  ------------------
  |  Branch (1974:7): [True: 14.4k, False: 25.6k]
  ------------------
 1975|  14.4k|    precompiled_charsmap_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_precompiled_charsmap(), 
 1976|  14.4k|      GetArena());
 1977|  14.4k|  }
 1978|  40.0k|  normalization_rule_tsv_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1979|  40.0k|  if (from._internal_has_normalization_rule_tsv()) {
  ------------------
  |  Branch (1979:7): [True: 0, False: 40.0k]
  ------------------
 1980|      0|    normalization_rule_tsv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_normalization_rule_tsv(), 
 1981|      0|      GetArena());
 1982|      0|  }
 1983|  40.0k|  ::memcpy(&add_dummy_prefix_, &from.add_dummy_prefix_,
 1984|  40.0k|    static_cast<size_t>(reinterpret_cast<char*>(&escape_whitespaces_) -
 1985|  40.0k|    reinterpret_cast<char*>(&add_dummy_prefix_)) + sizeof(escape_whitespaces_));
 1986|       |  // @@protoc_insertion_point(copy_constructor:sentencepiece.NormalizerSpec)
 1987|  40.0k|}
_ZN13sentencepiece14NormalizerSpecD2Ev:
 1999|  91.2k|NormalizerSpec::~NormalizerSpec() {
 2000|       |  // @@protoc_insertion_point(destructor:sentencepiece.NormalizerSpec)
 2001|  91.2k|  SharedDtor();
 2002|  91.2k|  _internal_metadata_.Delete<std::string>();
 2003|  91.2k|}
_ZNK13sentencepiece14NormalizerSpec13SetCachedSizeEi:
 2018|  4.30k|void NormalizerSpec::SetCachedSize(int size) const {
 2019|  4.30k|  _cached_size_.Set(size);
 2020|  4.30k|}
_ZN13sentencepiece14NormalizerSpec5ClearEv:
 2027|  8.41k|void NormalizerSpec::Clear() {
 2028|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.NormalizerSpec)
 2029|  8.41k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2030|       |  // Prevent compiler warnings about cached_has_bits being unused
 2031|  8.41k|  (void) cached_has_bits;
 2032|       |
 2033|  8.41k|  _extensions_.Clear();
 2034|  8.41k|  cached_has_bits = _has_bits_[0];
 2035|  8.41k|  if (cached_has_bits & 0x0000003fu) {
  ------------------
  |  Branch (2035:7): [True: 0, False: 8.41k]
  ------------------
 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|  8.41k|  _has_bits_.Clear();
 2050|  8.41k|  _internal_metadata_.Clear<std::string>();
 2051|  8.41k|}
_ZNK13sentencepiece14NormalizerSpec18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 2139|  4.30k|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 2140|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.NormalizerSpec)
 2141|  4.30k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2142|  4.30k|  (void) cached_has_bits;
 2143|       |
 2144|  4.30k|  cached_has_bits = _has_bits_[0];
 2145|       |  // optional string name = 1;
 2146|  4.30k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2146:7): [True: 4.30k, False: 0]
  ------------------
 2147|  4.30k|    target = stream->WriteStringMaybeAliased(
 2148|  4.30k|        1, this->_internal_name(), target);
 2149|  4.30k|  }
 2150|       |
 2151|       |  // optional bytes precompiled_charsmap = 2;
 2152|  4.30k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2152:7): [True: 4.30k, False: 0]
  ------------------
 2153|  4.30k|    target = stream->WriteBytesMaybeAliased(
 2154|  4.30k|        2, this->_internal_precompiled_charsmap(), target);
 2155|  4.30k|  }
 2156|       |
 2157|       |  // optional bool add_dummy_prefix = 3 [default = true];
 2158|  4.30k|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (2158:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (2164:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (2170:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2176:7): [True: 0, False: 4.30k]
  ------------------
 2177|      0|    target = stream->WriteStringMaybeAliased(
 2178|      0|        6, this->_internal_normalization_rule_tsv(), target);
 2179|      0|  }
 2180|       |
 2181|       |  // Extension range [200, 536870912)
 2182|  4.30k|  target = _extensions_._InternalSerialize(
 2183|  4.30k|      200, 536870912, target, stream);
 2184|       |
 2185|  4.30k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.30k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.30k]
  |  |  ------------------
  ------------------
 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.30k|  return target;
 2191|  4.30k|}
_ZNK13sentencepiece14NormalizerSpec12ByteSizeLongEv:
 2193|  4.30k|size_t NormalizerSpec::ByteSizeLong() const {
 2194|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.NormalizerSpec)
 2195|  4.30k|  size_t total_size = 0;
 2196|       |
 2197|  4.30k|  total_size += _extensions_.ByteSize();
 2198|       |
 2199|  4.30k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2200|       |  // Prevent compiler warnings about cached_has_bits being unused
 2201|  4.30k|  (void) cached_has_bits;
 2202|       |
 2203|  4.30k|  cached_has_bits = _has_bits_[0];
 2204|  4.30k|  if (cached_has_bits & 0x0000003fu) {
  ------------------
  |  Branch (2204:7): [True: 4.30k, False: 0]
  ------------------
 2205|       |    // optional string name = 1;
 2206|  4.30k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2206:9): [True: 4.30k, False: 0]
  ------------------
 2207|  4.30k|      total_size += 1 +
 2208|  4.30k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 2209|  4.30k|          this->_internal_name());
 2210|  4.30k|    }
 2211|       |
 2212|       |    // optional bytes precompiled_charsmap = 2;
 2213|  4.30k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2213:9): [True: 4.30k, False: 0]
  ------------------
 2214|  4.30k|      total_size += 1 +
 2215|  4.30k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::BytesSize(
 2216|  4.30k|          this->_internal_precompiled_charsmap());
 2217|  4.30k|    }
 2218|       |
 2219|       |    // optional string normalization_rule_tsv = 6;
 2220|  4.30k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2220:9): [True: 0, False: 4.30k]
  ------------------
 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.30k|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (2227:9): [True: 0, False: 4.30k]
  ------------------
 2228|      0|      total_size += 1 + 1;
 2229|      0|    }
 2230|       |
 2231|       |    // optional bool remove_extra_whitespaces = 4 [default = true];
 2232|  4.30k|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (2232:9): [True: 0, False: 4.30k]
  ------------------
 2233|      0|      total_size += 1 + 1;
 2234|      0|    }
 2235|       |
 2236|       |    // optional bool escape_whitespaces = 5 [default = true];
 2237|  4.30k|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (2237:9): [True: 0, False: 4.30k]
  ------------------
 2238|      0|      total_size += 1 + 1;
 2239|      0|    }
 2240|       |
 2241|  4.30k|  }
 2242|  4.30k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.30k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.30k]
  |  |  ------------------
  ------------------
 2243|      0|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 2244|      0|  }
 2245|  4.30k|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 2246|  4.30k|  SetCachedSize(cached_size);
 2247|  4.30k|  return total_size;
 2248|  4.30k|}
_ZN13sentencepiece14NormalizerSpec9MergeFromERKS0_:
 2256|  8.41k|void NormalizerSpec::MergeFrom(const NormalizerSpec& from) {
 2257|       |// @@protoc_insertion_point(class_specific_merge_from_start:sentencepiece.NormalizerSpec)
 2258|  8.41k|  GOOGLE_DCHECK_NE(&from, this);
  ------------------
  |  |  184|  8.41k|#define GOOGLE_DCHECK_NE(A, B) GOOGLE_DCHECK((A) != (B))
  |  |  ------------------
  |  |  |  |  181|  8.41k|#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.41k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2259|  8.41k|  _extensions_.MergeFrom(from._extensions_);
 2260|  8.41k|  _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
 2261|  8.41k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2262|  8.41k|  (void) cached_has_bits;
 2263|       |
 2264|  8.41k|  cached_has_bits = from._has_bits_[0];
 2265|  8.41k|  if (cached_has_bits & 0x0000003fu) {
  ------------------
  |  Branch (2265:7): [True: 8.41k, False: 0]
  ------------------
 2266|  8.41k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2266:9): [True: 8.41k, False: 0]
  ------------------
 2267|  8.41k|      _internal_set_name(from._internal_name());
 2268|  8.41k|    }
 2269|  8.41k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2269:9): [True: 8.41k, False: 0]
  ------------------
 2270|  8.41k|      _internal_set_precompiled_charsmap(from._internal_precompiled_charsmap());
 2271|  8.41k|    }
 2272|  8.41k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2272:9): [True: 0, False: 8.41k]
  ------------------
 2273|      0|      _internal_set_normalization_rule_tsv(from._internal_normalization_rule_tsv());
 2274|      0|    }
 2275|  8.41k|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (2275:9): [True: 0, False: 8.41k]
  ------------------
 2276|      0|      add_dummy_prefix_ = from.add_dummy_prefix_;
 2277|      0|    }
 2278|  8.41k|    if (cached_has_bits & 0x00000010u) {
  ------------------
  |  Branch (2278:9): [True: 0, False: 8.41k]
  ------------------
 2279|      0|      remove_extra_whitespaces_ = from.remove_extra_whitespaces_;
 2280|      0|    }
 2281|  8.41k|    if (cached_has_bits & 0x00000020u) {
  ------------------
  |  Branch (2281:9): [True: 0, False: 8.41k]
  ------------------
 2282|      0|      escape_whitespaces_ = from.escape_whitespaces_;
 2283|      0|    }
 2284|  8.41k|    _has_bits_[0] |= cached_has_bits;
 2285|  8.41k|  }
 2286|  8.41k|}
_ZN13sentencepiece14NormalizerSpec8CopyFromERKS0_:
 2288|  8.41k|void NormalizerSpec::CopyFrom(const NormalizerSpec& from) {
 2289|       |// @@protoc_insertion_point(class_specific_copy_from_start:sentencepiece.NormalizerSpec)
 2290|  8.41k|  if (&from == this) return;
  ------------------
  |  Branch (2290:7): [True: 0, False: 8.41k]
  ------------------
 2291|  8.41k|  Clear();
 2292|  8.41k|  MergeFrom(from);
 2293|  8.41k|}
_ZN13sentencepiece14NormalizerSpec12InternalSwapEPS0_:
 2303|  17.0k|void NormalizerSpec::InternalSwap(NormalizerSpec* other) {
 2304|  17.0k|  using std::swap;
 2305|  17.0k|  _extensions_.Swap(&other->_extensions_);
 2306|  17.0k|  _internal_metadata_.Swap<std::string>(&other->_internal_metadata_);
 2307|  17.0k|  swap(_has_bits_[0], other->_has_bits_[0]);
 2308|  17.0k|  name_.Swap(&other->name_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 2309|  17.0k|  precompiled_charsmap_.Swap(&other->precompiled_charsmap_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 2310|  17.0k|  normalization_rule_tsv_.Swap(&other->normalization_rule_tsv_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
 2311|  17.0k|  swap(add_dummy_prefix_, other->add_dummy_prefix_);
 2312|  17.0k|  swap(remove_extra_whitespaces_, other->remove_extra_whitespaces_);
 2313|  17.0k|  swap(escape_whitespaces_, other->escape_whitespaces_);
 2314|  17.0k|}
_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.30M|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 2786|  2.30M|  _extensions_(arena) {
 2787|  2.30M|  SharedCtor();
 2788|  2.30M|  RegisterArenaDtor(arena);
 2789|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.ModelProto.SentencePiece)
 2790|  2.30M|}
_ZN13sentencepiece24ModelProto_SentencePieceD2Ev:
 2814|  2.30M|ModelProto_SentencePiece::~ModelProto_SentencePiece() {
 2815|       |  // @@protoc_insertion_point(destructor:sentencepiece.ModelProto.SentencePiece)
 2816|  2.30M|  SharedDtor();
 2817|  2.30M|  _internal_metadata_.Delete<std::string>();
 2818|  2.30M|}
_ZNK13sentencepiece24ModelProto_SentencePiece13SetCachedSizeEi:
 2831|   256k|void ModelProto_SentencePiece::SetCachedSize(int size) const {
 2832|   256k|  _cached_size_.Set(size);
 2833|   256k|}
_ZN13sentencepiece24ModelProto_SentencePiece5ClearEv:
 2840|  7.17M|void ModelProto_SentencePiece::Clear() {
 2841|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.ModelProto.SentencePiece)
 2842|  7.17M|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2843|       |  // Prevent compiler warnings about cached_has_bits being unused
 2844|  7.17M|  (void) cached_has_bits;
 2845|       |
 2846|  7.17M|  _extensions_.Clear();
 2847|  7.17M|  cached_has_bits = _has_bits_[0];
 2848|  7.17M|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2848:7): [True: 7.17M, False: 0]
  ------------------
 2849|  7.17M|    piece_.ClearNonDefaultToEmpty();
 2850|  7.17M|  }
 2851|  7.17M|  if (cached_has_bits & 0x00000006u) {
  ------------------
  |  Branch (2851:7): [True: 7.17M, False: 0]
  ------------------
 2852|  7.17M|    score_ = 0;
 2853|  7.17M|    type_ = 1;
 2854|  7.17M|  }
 2855|  7.17M|  _has_bits_.Clear();
 2856|  7.17M|  _internal_metadata_.Clear<std::string>();
 2857|  7.17M|}
_ZNK13sentencepiece24ModelProto_SentencePiece18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 2925|   256k|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 2926|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.ModelProto.SentencePiece)
 2927|   256k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2928|   256k|  (void) cached_has_bits;
 2929|       |
 2930|   256k|  cached_has_bits = _has_bits_[0];
 2931|       |  // optional string piece = 1;
 2932|   256k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2932:7): [True: 256k, False: 0]
  ------------------
 2933|   256k|    target = stream->WriteStringMaybeAliased(
 2934|   256k|        1, this->_internal_piece(), target);
 2935|   256k|  }
 2936|       |
 2937|       |  // optional float score = 2;
 2938|   256k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2938:7): [True: 256k, False: 0]
  ------------------
 2939|   256k|    target = stream->EnsureSpace(target);
 2940|   256k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_score(), target);
 2941|   256k|  }
 2942|       |
 2943|       |  // optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
 2944|   256k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2944:7): [True: 12.9k, False: 243k]
  ------------------
 2945|  12.9k|    target = stream->EnsureSpace(target);
 2946|  12.9k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteEnumToArray(
 2947|  12.9k|      3, this->_internal_type(), target);
 2948|  12.9k|  }
 2949|       |
 2950|       |  // Extension range [200, 536870912)
 2951|   256k|  target = _extensions_._InternalSerialize(
 2952|   256k|      200, 536870912, target, stream);
 2953|       |
 2954|   256k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|   256k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 256k]
  |  |  ------------------
  ------------------
 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|   256k|  return target;
 2960|   256k|}
_ZNK13sentencepiece24ModelProto_SentencePiece12ByteSizeLongEv:
 2962|   256k|size_t ModelProto_SentencePiece::ByteSizeLong() const {
 2963|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.ModelProto.SentencePiece)
 2964|   256k|  size_t total_size = 0;
 2965|       |
 2966|   256k|  total_size += _extensions_.ByteSize();
 2967|       |
 2968|   256k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 2969|       |  // Prevent compiler warnings about cached_has_bits being unused
 2970|   256k|  (void) cached_has_bits;
 2971|       |
 2972|   256k|  cached_has_bits = _has_bits_[0];
 2973|   256k|  if (cached_has_bits & 0x00000007u) {
  ------------------
  |  Branch (2973:7): [True: 256k, False: 0]
  ------------------
 2974|       |    // optional string piece = 1;
 2975|   256k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (2975:9): [True: 256k, False: 0]
  ------------------
 2976|   256k|      total_size += 1 +
 2977|   256k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
 2978|   256k|          this->_internal_piece());
 2979|   256k|    }
 2980|       |
 2981|       |    // optional float score = 2;
 2982|   256k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (2982:9): [True: 256k, False: 0]
  ------------------
 2983|   256k|      total_size += 1 + 4;
 2984|   256k|    }
 2985|       |
 2986|       |    // optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
 2987|   256k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (2987:9): [True: 12.9k, False: 243k]
  ------------------
 2988|  12.9k|      total_size += 1 +
 2989|  12.9k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::EnumSize(this->_internal_type());
 2990|  12.9k|    }
 2991|       |
 2992|   256k|  }
 2993|   256k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|   256k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 256k]
  |  |  ------------------
  ------------------
 2994|      0|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 2995|      0|  }
 2996|   256k|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 2997|   256k|  SetCachedSize(cached_size);
 2998|   256k|  return total_size;
 2999|   256k|}
_ZN13sentencepiece10ModelProto9_Internal12trainer_specEPKS0_:
 3084|  4.30k|ModelProto::_Internal::trainer_spec(const ModelProto* msg) {
 3085|  4.30k|  return *msg->trainer_spec_;
 3086|  4.30k|}
_ZN13sentencepiece10ModelProto9_Internal15normalizer_specEPKS0_:
 3088|  4.30k|ModelProto::_Internal::normalizer_spec(const ModelProto* msg) {
 3089|  4.30k|  return *msg->normalizer_spec_;
 3090|  4.30k|}
_ZN13sentencepiece10ModelProtoC2EPN6google8protobuf5ArenaE:
 3100|  14.4k|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 3101|  14.4k|  _extensions_(arena),
 3102|  14.4k|  pieces_(arena) {
 3103|  14.4k|  SharedCtor();
 3104|  14.4k|  RegisterArenaDtor(arena);
 3105|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.ModelProto)
 3106|  14.4k|}
_ZN13sentencepiece10ModelProtoD2Ev:
 3144|  14.4k|ModelProto::~ModelProto() {
 3145|       |  // @@protoc_insertion_point(destructor:sentencepiece.ModelProto)
 3146|  14.4k|  SharedDtor();
 3147|  14.4k|  _internal_metadata_.Delete<std::string>();
 3148|  14.4k|}
_ZNK13sentencepiece10ModelProto13SetCachedSizeEi:
 3164|  4.30k|void ModelProto::SetCachedSize(int size) const {
 3165|  4.30k|  _cached_size_.Set(size);
 3166|  4.30k|}
_ZN13sentencepiece10ModelProto5ClearEv:
 3173|  55.5k|void ModelProto::Clear() {
 3174|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.ModelProto)
 3175|  55.5k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 3176|       |  // Prevent compiler warnings about cached_has_bits being unused
 3177|  55.5k|  (void) cached_has_bits;
 3178|       |
 3179|  55.5k|  _extensions_.Clear();
 3180|  55.5k|  pieces_.Clear();
 3181|  55.5k|  cached_has_bits = _has_bits_[0];
 3182|  55.5k|  if (cached_has_bits & 0x0000000fu) {
  ------------------
  |  Branch (3182:7): [True: 0, False: 55.5k]
  ------------------
 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|  55.5k|  _has_bits_.Clear();
 3201|  55.5k|  _internal_metadata_.Clear<std::string>();
 3202|  55.5k|}
_ZNK13sentencepiece10ModelProto18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
 3282|  4.30k|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
 3283|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.ModelProto)
 3284|  4.30k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 3285|  4.30k|  (void) cached_has_bits;
 3286|       |
 3287|       |  // repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
 3288|  4.30k|  for (unsigned int i = 0,
 3289|   260k|      n = static_cast<unsigned int>(this->_internal_pieces_size()); i < n; i++) {
  ------------------
  |  Branch (3289:69): [True: 256k, False: 4.30k]
  ------------------
 3290|   256k|    target = stream->EnsureSpace(target);
 3291|   256k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3292|   256k|      InternalWriteMessage(1, this->_internal_pieces(i), target, stream);
 3293|   256k|  }
 3294|       |
 3295|  4.30k|  cached_has_bits = _has_bits_[0];
 3296|       |  // optional .sentencepiece.TrainerSpec trainer_spec = 2;
 3297|  4.30k|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (3297:7): [True: 4.30k, False: 0]
  ------------------
 3298|  4.30k|    target = stream->EnsureSpace(target);
 3299|  4.30k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3300|  4.30k|      InternalWriteMessage(
 3301|  4.30k|        2, _Internal::trainer_spec(this), target, stream);
 3302|  4.30k|  }
 3303|       |
 3304|       |  // optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
 3305|  4.30k|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (3305:7): [True: 4.30k, False: 0]
  ------------------
 3306|  4.30k|    target = stream->EnsureSpace(target);
 3307|  4.30k|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
 3308|  4.30k|      InternalWriteMessage(
 3309|  4.30k|        3, _Internal::normalizer_spec(this), target, stream);
 3310|  4.30k|  }
 3311|       |
 3312|       |  // optional .sentencepiece.SelfTestData self_test_data = 4;
 3313|  4.30k|  if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (3313:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (3321:7): [True: 0, False: 4.30k]
  ------------------
 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.30k|  target = _extensions_._InternalSerialize(
 3330|  4.30k|      200, 536870912, target, stream);
 3331|       |
 3332|  4.30k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.30k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.30k]
  |  |  ------------------
  ------------------
 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.30k|  return target;
 3338|  4.30k|}
_ZNK13sentencepiece10ModelProto12ByteSizeLongEv:
 3340|  4.30k|size_t ModelProto::ByteSizeLong() const {
 3341|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.ModelProto)
 3342|  4.30k|  size_t total_size = 0;
 3343|       |
 3344|  4.30k|  total_size += _extensions_.ByteSize();
 3345|       |
 3346|  4.30k|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 3347|       |  // Prevent compiler warnings about cached_has_bits being unused
 3348|  4.30k|  (void) cached_has_bits;
 3349|       |
 3350|       |  // repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
 3351|  4.30k|  total_size += 1UL * this->_internal_pieces_size();
 3352|   256k|  for (const auto& msg : this->pieces_) {
  ------------------
  |  Branch (3352:24): [True: 256k, False: 4.30k]
  ------------------
 3353|   256k|    total_size +=
 3354|   256k|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
 3355|   256k|  }
 3356|       |
 3357|  4.30k|  cached_has_bits = _has_bits_[0];
 3358|  4.30k|  if (cached_has_bits & 0x0000000fu) {
  ------------------
  |  Branch (3358:7): [True: 4.30k, False: 0]
  ------------------
 3359|       |    // optional .sentencepiece.TrainerSpec trainer_spec = 2;
 3360|  4.30k|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (3360:9): [True: 4.30k, False: 0]
  ------------------
 3361|  4.30k|      total_size += 1 +
 3362|  4.30k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 3363|  4.30k|          *trainer_spec_);
 3364|  4.30k|    }
 3365|       |
 3366|       |    // optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
 3367|  4.30k|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (3367:9): [True: 4.30k, False: 0]
  ------------------
 3368|  4.30k|      total_size += 1 +
 3369|  4.30k|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 3370|  4.30k|          *normalizer_spec_);
 3371|  4.30k|    }
 3372|       |
 3373|       |    // optional .sentencepiece.SelfTestData self_test_data = 4;
 3374|  4.30k|    if (cached_has_bits & 0x00000004u) {
  ------------------
  |  Branch (3374:9): [True: 0, False: 4.30k]
  ------------------
 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.30k|    if (cached_has_bits & 0x00000008u) {
  ------------------
  |  Branch (3381:9): [True: 0, False: 4.30k]
  ------------------
 3382|      0|      total_size += 1 +
 3383|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
 3384|      0|          *denormalizer_spec_);
 3385|      0|    }
 3386|       |
 3387|  4.30k|  }
 3388|  4.30k|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|  4.30k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 4.30k]
  |  |  ------------------
  ------------------
 3389|      0|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
 3390|      0|  }
 3391|  4.30k|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
 3392|  4.30k|  SetCachedSize(cached_size);
 3393|  4.30k|  return total_size;
 3394|  4.30k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece11TrainerSpecEJEEEPT_PS1_DpOT0_:
 3478|  8.41k|template<> PROTOBUF_NOINLINE ::sentencepiece::TrainerSpec* Arena::CreateMaybeMessage< ::sentencepiece::TrainerSpec >(Arena* arena) {
 3479|  8.41k|  return Arena::CreateMessageInternal< ::sentencepiece::TrainerSpec >(arena);
 3480|  8.41k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece14NormalizerSpecEJEEEPT_PS1_DpOT0_:
 3481|  8.41k|template<> PROTOBUF_NOINLINE ::sentencepiece::NormalizerSpec* Arena::CreateMaybeMessage< ::sentencepiece::NormalizerSpec >(Arena* arena) {
 3482|  8.41k|  return Arena::CreateMessageInternal< ::sentencepiece::NormalizerSpec >(arena);
 3483|  8.41k|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece24ModelProto_SentencePieceEJEEEPT_PS1_DpOT0_:
 3490|  2.30M|template<> PROTOBUF_NOINLINE ::sentencepiece::ModelProto_SentencePiece* Arena::CreateMaybeMessage< ::sentencepiece::ModelProto_SentencePiece >(Arena* arena) {
 3491|  2.30M|  return Arena::CreateMessageInternal< ::sentencepiece::ModelProto_SentencePiece >(arena);
 3492|  2.30M|}
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|  25.5k|void TrainerSpec::SharedCtor() {
  491|  25.5k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TrainerSpec_sentencepiece_5fmodel_2eproto.base);
  492|  25.5k|  model_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  493|  25.5k|  input_format_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  494|  25.5k|  required_chars_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  495|  25.5k|  unk_surface_.UnsafeSetDefault(nullptr);
  496|  25.5k|  unk_piece_.UnsafeSetDefault(nullptr);
  497|  25.5k|  bos_piece_.UnsafeSetDefault(nullptr);
  498|  25.5k|  eos_piece_.UnsafeSetDefault(nullptr);
  499|  25.5k|  pad_piece_.UnsafeSetDefault(nullptr);
  500|  25.5k|  pretokenization_delimiter_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  501|  25.5k|  seed_sentencepieces_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  502|  25.5k|  ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
  503|  25.5k|      reinterpret_cast<char*>(&self_test_sample_size_) - reinterpret_cast<char*>(this)),
  504|  25.5k|      0, static_cast<size_t>(reinterpret_cast<char*>(&differential_privacy_clipping_threshold_) -
  505|  25.5k|      reinterpret_cast<char*>(&self_test_sample_size_)) + sizeof(differential_privacy_clipping_threshold_));
  506|  25.5k|  model_type_ = 1;
  507|  25.5k|  vocab_size_ = 8000;
  508|  25.5k|  character_coverage_ = 0.9995f;
  509|  25.5k|  seed_sentencepiece_size_ = 1000000;
  510|  25.5k|  shrinking_factor_ = 0.75f;
  511|  25.5k|  num_threads_ = 16;
  512|  25.5k|  num_sub_iterations_ = 2;
  513|  25.5k|  max_sentence_length_ = 4192;
  514|  25.5k|  max_sentencepiece_length_ = 16;
  515|  25.5k|  shuffle_input_sentence_ = true;
  516|  25.5k|  split_by_unicode_script_ = true;
  517|  25.5k|  split_by_number_ = true;
  518|  25.5k|  split_by_whitespace_ = true;
  519|  25.5k|  vocabulary_output_piece_score_ = true;
  520|  25.5k|  hard_vocab_limit_ = true;
  521|  25.5k|  bos_id_ = 1;
  522|  25.5k|  eos_id_ = 2;
  523|  25.5k|  pad_id_ = -1;
  524|  25.5k|}
_ZN13sentencepiece11TrainerSpec10SharedDtorEv:
  532|  39.9k|void TrainerSpec::SharedDtor() {
  533|  39.9k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  39.9k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 39.9k]
  |  |  ------------------
  ------------------
  534|  39.9k|  model_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  535|  39.9k|  input_format_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  536|  39.9k|  required_chars_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  537|  39.9k|  unk_surface_.DestroyNoArena(nullptr);
  538|  39.9k|  unk_piece_.DestroyNoArena(nullptr);
  539|  39.9k|  bos_piece_.DestroyNoArena(nullptr);
  540|  39.9k|  eos_piece_.DestroyNoArena(nullptr);
  541|  39.9k|  pad_piece_.DestroyNoArena(nullptr);
  542|  39.9k|  pretokenization_delimiter_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  543|  39.9k|  seed_sentencepieces_file_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  544|  39.9k|}
_ZN13sentencepiece11TrainerSpec17RegisterArenaDtorEPN6google8protobuf5ArenaE:
  550|  25.5k|void TrainerSpec::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  551|  25.5k|}
_ZN13sentencepiece14NormalizerSpec10SharedCtorEv:
 1989|  51.1k|void NormalizerSpec::SharedCtor() {
 1990|  51.1k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NormalizerSpec_sentencepiece_5fmodel_2eproto.base);
 1991|  51.1k|  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1992|  51.1k|  precompiled_charsmap_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1993|  51.1k|  normalization_rule_tsv_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1994|  51.1k|  add_dummy_prefix_ = true;
 1995|  51.1k|  remove_extra_whitespaces_ = true;
 1996|  51.1k|  escape_whitespaces_ = true;
 1997|  51.1k|}
_ZN13sentencepiece14NormalizerSpec10SharedDtorEv:
 2005|  91.2k|void NormalizerSpec::SharedDtor() {
 2006|  91.2k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  91.2k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 91.2k]
  |  |  ------------------
  ------------------
 2007|  91.2k|  name_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2008|  91.2k|  precompiled_charsmap_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2009|  91.2k|  normalization_rule_tsv_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2010|  91.2k|}
_ZN13sentencepiece14NormalizerSpec17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2016|  51.1k|void NormalizerSpec::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2017|  51.1k|}
_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.30M|void ModelProto_SentencePiece::SharedCtor() {
 2808|  2.30M|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ModelProto_SentencePiece_sentencepiece_5fmodel_2eproto.base);
 2809|  2.30M|  piece_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2810|  2.30M|  score_ = 0;
 2811|  2.30M|  type_ = 1;
 2812|  2.30M|}
_ZN13sentencepiece24ModelProto_SentencePiece10SharedDtorEv:
 2820|  2.30M|void ModelProto_SentencePiece::SharedDtor() {
 2821|  2.30M|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  2.30M|#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.30M]
  |  |  ------------------
  ------------------
 2822|  2.30M|  piece_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2823|  2.30M|}
_ZN13sentencepiece24ModelProto_SentencePiece17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2829|  2.30M|void ModelProto_SentencePiece::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2830|  2.30M|}
_ZN13sentencepiece10ModelProto10SharedCtorEv:
 3136|  14.4k|void ModelProto::SharedCtor() {
 3137|  14.4k|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ModelProto_sentencepiece_5fmodel_2eproto.base);
 3138|  14.4k|  ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 3139|  14.4k|      reinterpret_cast<char*>(&trainer_spec_) - reinterpret_cast<char*>(this)),
 3140|  14.4k|      0, static_cast<size_t>(reinterpret_cast<char*>(&denormalizer_spec_) -
 3141|  14.4k|      reinterpret_cast<char*>(&trainer_spec_)) + sizeof(denormalizer_spec_));
 3142|  14.4k|}
_ZN13sentencepiece10ModelProto10SharedDtorEv:
 3150|  14.4k|void ModelProto::SharedDtor() {
 3151|  14.4k|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|  14.4k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 14.4k]
  |  |  ------------------
  ------------------
 3152|  14.4k|  if (this != internal_default_instance()) delete trainer_spec_;
  ------------------
  |  Branch (3152:7): [True: 14.4k, False: 0]
  ------------------
 3153|  14.4k|  if (this != internal_default_instance()) delete normalizer_spec_;
  ------------------
  |  Branch (3153:7): [True: 14.4k, False: 0]
  ------------------
 3154|  14.4k|  if (this != internal_default_instance()) delete self_test_data_;
  ------------------
  |  Branch (3154:7): [True: 14.4k, False: 0]
  ------------------
 3155|  14.4k|  if (this != internal_default_instance()) delete denormalizer_spec_;
  ------------------
  |  Branch (3155:7): [True: 14.4k, False: 0]
  ------------------
 3156|  14.4k|}
_ZN13sentencepiece10ModelProto17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 3162|  14.4k|void ModelProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 3163|  14.4k|}

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

_ZN13sentencepiece9character7Trainer5TrainEv:
   26|    260|absl::Status Trainer::Train() {
   27|    260|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|    260|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|    260|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|    520|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|    520|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|    520|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 260, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|    260|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 260]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|    520|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 258, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|    520|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|    520|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|    258|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|    520|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   28|       |
   29|    258|  RET_CHECK(normalizer_spec_.escape_whitespaces());
  ------------------
  |  |  285|    258|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 258, False: 0]
  |  |  ------------------
  |  |  286|    258|  } else /* NOLINT */                                         \
  |  |  287|    258|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   30|    258|  RET_CHECK_EQ(TrainerSpec::CHAR, trainer_spec_.model_type());
  ------------------
  |  |  290|    258|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  285|    258|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 258, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|    258|  } else /* NOLINT */                                         \
  |  |  |  |  287|    258|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   31|       |
   32|    258|  RETURN_IF_ERROR(LoadSentences());
  ------------------
  |  |   44|    258|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|    258|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|    774|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|    516|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|    516|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 258, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|    258|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 258]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|    774|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 256, False: 2]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|    774|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|    774|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|    256|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|    774|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   33|       |
   34|    256|  const int vocab_size = trainer_spec_.vocab_size() - meta_pieces_.size();
   35|    256|  RET_CHECK_GE(vocab_size, 0);
  ------------------
  |  |  292|    256|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  285|    256|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 243, False: 13]
  |  |  |  |  ------------------
  |  |  |  |  286|    243|  } else /* NOLINT */                                         \
  |  |  |  |  287|    256|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|     13|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   36|       |
   37|    243|  uint64_t sum = 0;
   38|  33.3k|  for (const auto& it : required_chars_) {
  ------------------
  |  Branch (38:23): [True: 33.3k, False: 243]
  ------------------
   39|  33.3k|    sum += it.second;
   40|  33.3k|  }
   41|       |
   42|    243|  const auto logsum = std::log(static_cast<float>(sum));
   43|       |
   44|    243|  RET_CHECK(final_pieces_.empty());
  ------------------
  |  |  285|    243|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 243, False: 0]
  |  |  ------------------
  |  |  286|    243|  } else /* NOLINT */                                         \
  |  |  287|    243|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   45|  6.43k|  for (const auto& it : Sorted(required_chars_)) {
  ------------------
  |  Branch (45:23): [True: 6.43k, False: 96]
  ------------------
   46|  6.43k|    if (!trainer_spec_.use_all_vocab() &&
  ------------------
  |  Branch (46:9): [True: 6.43k, False: 0]
  ------------------
   47|  6.43k|        final_pieces_.size() == static_cast<size_t>(vocab_size)) {
  ------------------
  |  Branch (47:9): [True: 147, False: 6.28k]
  ------------------
   48|    147|      break;
   49|    147|    }
   50|  6.28k|    final_pieces_.emplace_back(
   51|  6.28k|        string_util::UnicodeCharToUTF8(it.first),
   52|  6.28k|        std::log(static_cast<float>(it.second)) - logsum);
   53|  6.28k|  }
   54|       |
   55|    243|  if (trainer_spec_.use_all_vocab()) {
  ------------------
  |  Branch (55:7): [True: 0, False: 243]
  ------------------
   56|      0|    trainer_spec_.set_vocab_size(final_pieces_.size() + meta_pieces_.size());
   57|      0|  }
   58|       |
   59|    243|  return Save();
   60|    243|}

_ZN13sentencepiece9character7TrainerC2ERKNS_11TrainerSpecERKNS_14NormalizerSpecES7_:
   31|    260|      : TrainerInterface::TrainerInterface(trainer_spec, normalizer_spec,
   32|    260|                                           denormalizer_spec) {}

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

_ZN13sentencepiece14ModelInterfaceD2Ev:
   29|  5.90k|ModelInterface::~ModelInterface() {}
_ZN13sentencepiece14SplitIntoWordsENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEbb:
  168|  4.13M|                                              bool allow_ws_only_pieces) {
  169|  4.13M|  const char* begin = text.data();
  170|  4.13M|  const char* end = text.data() + text.size();
  171|       |
  172|       |  // Space symbol (U+2581)
  173|  4.13M|  constexpr absl::string_view kSpaceSymbol = "\xe2\x96\x81";
  174|  4.13M|  bool in_ws_sequence = false;
  175|       |
  176|  4.13M|  std::vector<absl::string_view> result;
  177|  4.13M|  if (treat_ws_as_suffix) {  // put ws tokens at the end of non-ws sequences.
  ------------------
  |  Branch (177:7): [True: 0, False: 4.13M]
  ------------------
  178|      0|    if (begin < end) {
  ------------------
  |  Branch (178:9): [True: 0, False: 0]
  ------------------
  179|      0|      result.emplace_back(begin, 0);
  180|      0|    }
  181|      0|    while (begin < end) {
  ------------------
  |  Branch (181:12): [True: 0, False: 0]
  ------------------
  182|      0|      const int mblen =
  183|      0|          std::min<int>(string_util::OneCharLen(begin), end - begin);
  184|      0|      const bool is_ws = absl::string_view(begin, mblen) == kSpaceSymbol;
  185|       |
  186|      0|      if (is_ws) {  // keep track of sequences consecutive ws tokens.
  ------------------
  |  Branch (186:11): [True: 0, False: 0]
  ------------------
  187|      0|        in_ws_sequence = true;
  188|      0|      } else if (in_ws_sequence) {
  ------------------
  |  Branch (188:18): [True: 0, False: 0]
  ------------------
  189|      0|        if (allow_ws_only_pieces) {
  ------------------
  |  Branch (189:13): [True: 0, False: 0]
  ------------------
  190|      0|          result.emplace_back(begin, 0);
  191|      0|        }
  192|       |
  193|      0|        in_ws_sequence = false;
  194|      0|      }
  195|       |
  196|      0|      result.back() =
  197|      0|          absl::string_view(result.back().data(), result.back().size() + mblen);
  198|      0|      begin += mblen;
  199|       |
  200|      0|      if (begin < end && is_ws && !allow_ws_only_pieces) {
  ------------------
  |  Branch (200:11): [True: 0, False: 0]
  |  Branch (200:26): [True: 0, False: 0]
  |  Branch (200:35): [True: 0, False: 0]
  ------------------
  201|      0|        result.emplace_back(begin, 0);
  202|      0|      }
  203|      0|    }
  204|  4.13M|  } else {
  205|   225M|    while (begin < end) {
  ------------------
  |  Branch (205:12): [True: 220M, False: 4.13M]
  ------------------
  206|   220M|      const int mblen =
  207|   220M|          std::min<int>(string_util::OneCharLen(begin), end - begin);
  208|   220M|      bool is_ws = absl::string_view(begin, mblen) == kSpaceSymbol;
  209|       |
  210|       |      // if is whitespace (and not in sequence if allow_ws_only_pieces is True)
  211|   220M|      if (begin == text.data() ||
  ------------------
  |  Branch (211:11): [True: 4.13M, False: 216M]
  ------------------
  212|   216M|          (is_ws && (!in_ws_sequence || !allow_ws_only_pieces))) {
  ------------------
  |  Branch (212:12): [True: 7.23M, False: 209M]
  |  Branch (212:22): [True: 7.23M, False: 0]
  |  Branch (212:41): [True: 0, False: 0]
  ------------------
  213|  11.3M|        result.emplace_back(begin, 0);  // add empty string piece.
  214|  11.3M|        in_ws_sequence = true;
  215|  11.3M|      }
  216|       |
  217|   220M|      if (in_ws_sequence && !is_ws) {
  ------------------
  |  Branch (217:11): [True: 19.4M, False: 201M]
  |  Branch (217:29): [True: 11.2M, False: 8.14M]
  ------------------
  218|  11.2M|        in_ws_sequence = false;
  219|  11.2M|      }
  220|       |
  221|   220M|      result.back() =
  222|   220M|          absl::string_view(result.back().data(), result.back().size() + mblen);
  223|   220M|      begin += mblen;
  224|   220M|    }
  225|  4.13M|  }
  226|       |
  227|  4.13M|  return result;
  228|  4.13M|}
_ZN13sentencepiece11ByteToPieceEh:
  230|  17.4k|const std::string& ByteToPiece(unsigned char c) {
  231|  17.4k|  static const std::vector<std::string>* const kBytePieces = [] {
  232|  17.4k|    auto* v = new std::vector<std::string>(256);
  233|  17.4k|    for (int i = 0; i < 256; ++i) {
  234|  17.4k|      (*v)[i] = absl::StrFormat("<0x%02X>", i);
  235|  17.4k|    }
  236|  17.4k|    return v;
  237|  17.4k|  }();
  238|  17.4k|  return (*kBytePieces)[c];
  239|  17.4k|}
model_interface.cc:_ZZN13sentencepiece11ByteToPieceEhENK3$_0clEv:
  231|      1|  static const std::vector<std::string>* const kBytePieces = [] {
  232|      1|    auto* v = new std::vector<std::string>(256);
  233|    257|    for (int i = 0; i < 256; ++i) {
  ------------------
  |  Branch (233:21): [True: 256, False: 1]
  ------------------
  234|    256|      (*v)[i] = absl::StrFormat("<0x%02X>", i);
  235|    256|    }
  236|      1|    return v;
  237|      1|  }();

_ZNK13sentencepiece14ModelInterface6statusEv:
   72|   100k|  virtual absl::Status status() const { return status_; }
_ZNK13sentencepiece14ModelInterface12GetPieceSizeEv:
  160|   109k|  [[nodiscard]] virtual int GetPieceSize() const {
  161|   109k|    if (model_proto_ == nullptr) {
  ------------------
  |  Branch (161:9): [True: 0, False: 109k]
  ------------------
  162|      0|      return 0;
  163|      0|    }
  164|   109k|    return model_proto_->pieces_size();
  165|   109k|  }
_ZNK13sentencepiece14ModelInterface15GetScoreInlinedEi:
  239|   211M|  [[nodiscard]] float GetScoreInlined(int id) const {
  240|   211M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|   211M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|   211M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   211M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 211M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   211M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  241|   211M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|   211M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|   211M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   211M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 211M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   211M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  242|   211M|    return model_proto_->pieces(id).score();
  243|   211M|  }
_ZNK13sentencepiece14ModelInterface15IsUnusedInlinedEi:
  259|   211M|  [[nodiscard]] bool IsUnusedInlined(int id) const {
  260|   211M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|   211M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|   211M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   211M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 211M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   211M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  261|   211M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|   211M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|   211M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   211M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 211M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   211M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  262|   211M|    return (model_proto_->pieces(id).type() ==
  263|   211M|            ModelProto::SentencePiece::UNUSED);
  264|   211M|  }
_ZNK13sentencepiece14ModelInterface20IsUserDefinedInlinedEi:
  266|   211M|  [[nodiscard]] bool IsUserDefinedInlined(int id) const {
  267|   211M|    DCHECK_GE(id, 0);
  ------------------
  |  |  150|   211M|  ABSL_LOG_INTERNAL_DCHECK_GE_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   95|   211M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   211M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 211M]
  |  |  |  |  |  |  |  Branch (63:19): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   211M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  268|   211M|    DCHECK_LT(id, model_proto_->pieces_size());
  ------------------
  |  |  148|   211M|  ABSL_LOG_INTERNAL_DCHECK_LT_IMPL((val1), #val1, (val2), #val2)
  |  |  ------------------
  |  |  |  |   93|   211M|  ABSL_LOG_INTERNAL_DCHECK_NOP(val1, val2)
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|   211M|  while (false && ((void)(x), (void)(y), 0)) \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (63:10): [Folded, False: 211M]
  |  |  |  |  |  |  |  Branch (63:19): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |   64|   211M|  ::absl::log_internal::NullStream().InternalStream()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  269|   211M|    return (model_proto_->pieces(id).type() ==
  270|   211M|            ModelProto::SentencePiece::USER_DEFINED);
  271|   211M|  }
_ZN13sentencepiece14ModelInterfaceC2Ev:
   66|  5.90k|  ModelInterface() = default;

_ZN13sentencepiece10normalizer10NormalizerC2ERKNS_14NormalizerSpecERKNS_11TrainerSpecE:
   36|  8.53k|    : spec_(&spec),
   37|  8.53k|      treat_whitespace_as_suffix_(trainer_spec.treat_whitespace_as_suffix()),
   38|  8.53k|      status_(absl::OkStatus()) {
   39|  8.53k|  Init();
   40|  8.53k|}
_ZN13sentencepiece10normalizer10NormalizerC2ERKNS_14NormalizerSpecE:
   43|  8.54k|    : spec_(&spec), status_(absl::OkStatus()) {
   44|  8.54k|  Init();
   45|  8.54k|}
_ZN13sentencepiece10normalizer10NormalizerD2Ev:
   47|  17.0k|Normalizer::~Normalizer() {}
_ZN13sentencepiece10normalizer10Normalizer4InitEv:
   49|  17.0k|void Normalizer::Init() {
   50|  17.0k|  absl::string_view index = spec_->precompiled_charsmap();
   51|       |
   52|  17.0k|  if (!index.empty()) {
  ------------------
  |  Branch (52:7): [True: 17.0k, False: 0]
  ------------------
   53|  17.0k|    absl::string_view trie_blob;
   54|  17.0k|    status_ = DecodePrecompiledCharsMap(index, &trie_blob, &normalized_,
   55|  17.0k|                                        &precompiled_charsmap_buffer_);
   56|       |
   57|  17.0k|    if (!status_.ok()) return;
  ------------------
  |  Branch (57:9): [True: 0, False: 17.0k]
  ------------------
   58|       |
   59|       |    // Reads the body of double array.
   60|  17.0k|    trie_ = std::make_unique<Darts::DoubleArray>();
   61|       |
   62|       |    // copy_array ensures correct alignment even if the trie_blob is
   63|       |    // mis-aligned. Although standard proto parsing copies data to the heap
   64|       |    // (guaranteeing alignment), zero-copy parsing or custom buffers might
   65|       |    // pass misaligned data.
   66|  17.0k|    if (reinterpret_cast<uintptr_t>(trie_blob.data()) % 4 == 0) {
  ------------------
  |  Branch (66:9): [True: 17.0k, False: 0]
  ------------------
   67|  17.0k|      trie_->set_array(const_cast<char*>(trie_blob.data()),
   68|  17.0k|                       trie_blob.size() / trie_->unit_size());
   69|  17.0k|    } else {
   70|      0|      trie_->copy_array(reinterpret_cast<const char*>(trie_blob.data()),
   71|      0|                        trie_blob.size());
   72|      0|    }
   73|       |
   74|  17.0k|    if (!trie_->validate(normalized_.size())) {
  ------------------
  |  Branch (74:9): [True: 0, False: 17.0k]
  ------------------
   75|      0|      status_ = absl::InternalError("precompiled_charsmap is invalid.");
   76|      0|      trie_.reset();
   77|      0|      return;
   78|      0|    }
   79|  17.0k|  }
   80|  17.0k|}
_ZNK13sentencepiece10normalizer10Normalizer9NormalizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEEPNS2_6vectorImNS8_ImEEEE:
   84|  58.9k|                                   std::vector<size_t>* norm_to_orig) const {
   85|  58.9k|  if (norm_to_orig) norm_to_orig->clear();
  ------------------
  |  Branch (85:7): [True: 0, False: 58.9k]
  ------------------
   86|  58.9k|  normalized->clear();
   87|       |
   88|  58.9k|  if (input.empty()) {
  ------------------
  |  Branch (88:7): [True: 0, False: 58.9k]
  ------------------
   89|      0|    return absl::OkStatus();
   90|      0|  }
   91|       |
   92|  58.9k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  58.9k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  58.9k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|   176k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|   117k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|   117k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 58.9k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  58.9k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 58.9k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|   176k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 58.9k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|   176k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|   176k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  58.9k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|   176k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   93|       |
   94|  58.9k|  size_t consumed = 0;
   95|       |
   96|       |  // Ignores heading space.
   97|  58.9k|  if (spec_->remove_extra_whitespaces()) {
  ------------------
  |  Branch (97:7): [True: 58.9k, False: 0]
  ------------------
   98|  66.7k|    while (!input.empty()) {
  ------------------
  |  Branch (98:12): [True: 66.1k, False: 644]
  ------------------
   99|  66.1k|      const auto p = NormalizePrefix(input);
  100|  66.1k|      if (p.first != " ") {
  ------------------
  |  Branch (100:11): [True: 58.3k, False: 7.79k]
  ------------------
  101|  58.3k|        break;
  102|  58.3k|      }
  103|  7.79k|      input.remove_prefix(p.second);
  104|  7.79k|      consumed += p.second;
  105|  7.79k|    }
  106|  58.9k|  }
  107|       |
  108|       |  // all chars are whitespace.
  109|  58.9k|  if (input.empty()) {
  ------------------
  |  Branch (109:7): [True: 644, False: 58.3k]
  ------------------
  110|    644|    return absl::OkStatus();
  111|    644|  }
  112|       |
  113|       |  // Reserves the output buffer to avoid re-allocations.
  114|  58.3k|  const size_t kReservedSize = input.size() * 1.5;
  115|  58.3k|  normalized->reserve(kReservedSize);
  116|  58.3k|  if (norm_to_orig) norm_to_orig->reserve(kReservedSize);
  ------------------
  |  Branch (116:7): [True: 0, False: 58.3k]
  ------------------
  117|       |
  118|       |  // Replaces white space with U+2581 (LOWER ONE EIGHT BLOCK)
  119|       |  // if escape_whitespaces() is set (default = true).
  120|  58.3k|  const absl::string_view kSpaceSymbol =
  121|  58.3k|      spec_->escape_whitespaces() ? "\xe2\x96\x81" : " ";
  ------------------
  |  Branch (121:7): [True: 58.3k, False: 0]
  ------------------
  122|       |
  123|       |  // adds kSpaceSymbol to the current context.
  124|  58.3k|  auto add_ws = [&consumed, &normalized, &norm_to_orig, &kSpaceSymbol]() {
  125|  58.3k|    normalized->append(kSpaceSymbol.data(), kSpaceSymbol.size());
  126|  58.3k|    if (norm_to_orig) {
  127|  58.3k|      norm_to_orig->insert(norm_to_orig->end(), kSpaceSymbol.size(), consumed);
  128|  58.3k|    }
  129|  58.3k|  };
  130|       |
  131|       |  // Adds a space symbol as a prefix (default is true)
  132|       |  // With this prefix, "world" and "hello world" are converted into
  133|       |  // "_world" and "_hello_world", which help the trainer to extract
  134|       |  // "_world" as one symbol.
  135|  58.3k|  if (!treat_whitespace_as_suffix_ && spec_->add_dummy_prefix()) add_ws();
  ------------------
  |  Branch (135:7): [True: 58.3k, False: 0]
  |  Branch (135:39): [True: 58.3k, False: 0]
  ------------------
  136|       |
  137|  58.3k|  bool is_prev_space = spec_->remove_extra_whitespaces();
  138|  9.21M|  while (!input.empty()) {
  ------------------
  |  Branch (138:10): [True: 9.15M, False: 58.3k]
  ------------------
  139|  9.15M|    auto p = NormalizePrefix(input);
  140|  9.15M|    absl::string_view sp = p.first;
  141|       |
  142|       |    // Removes heading spaces in sentence piece,
  143|       |    // if the previous sentence piece ends with whitespace.
  144|  9.27M|    while (is_prev_space && absl::ConsumePrefix(&sp, " ")) {
  ------------------
  |  Branch (144:12): [True: 684k, False: 8.58M]
  |  Branch (144:29): [True: 115k, False: 569k]
  ------------------
  145|   115k|    }
  146|       |
  147|  9.15M|    if (!sp.empty()) {
  ------------------
  |  Branch (147:9): [True: 8.76M, False: 386k]
  ------------------
  148|  8.76M|      const char* data = sp.data();
  149|  22.8M|      for (size_t n = 0; n < sp.size(); ++n) {
  ------------------
  |  Branch (149:26): [True: 14.0M, False: 8.76M]
  ------------------
  150|  14.0M|        if (data[n] == ' ') {
  ------------------
  |  Branch (150:13): [True: 417k, False: 13.6M]
  ------------------
  151|   417k|          add_ws();
  152|  13.6M|        } else {
  153|  13.6M|          *normalized += data[n];
  154|  13.6M|          if (norm_to_orig) norm_to_orig->push_back(consumed);
  ------------------
  |  Branch (154:15): [True: 0, False: 13.6M]
  ------------------
  155|  13.6M|        }
  156|  14.0M|      }
  157|       |      // Checks whether the last character of sp is whitespace.
  158|  8.76M|      is_prev_space = absl::EndsWith(sp, " ");
  159|  8.76M|    }
  160|       |
  161|  9.15M|    consumed += p.second;
  162|  9.15M|    input.remove_prefix(p.second);
  163|  9.15M|    if (!spec_->remove_extra_whitespaces()) {
  ------------------
  |  Branch (163:9): [True: 0, False: 9.15M]
  ------------------
  164|      0|      is_prev_space = false;
  165|      0|    }
  166|  9.15M|  }
  167|       |
  168|       |  // Ignores trailing space.
  169|  58.3k|  if (spec_->remove_extra_whitespaces()) {
  ------------------
  |  Branch (169:7): [True: 58.3k, False: 0]
  ------------------
  170|  62.3k|    while (absl::EndsWith(*normalized, kSpaceSymbol)) {
  ------------------
  |  Branch (170:12): [True: 4.06k, False: 58.3k]
  ------------------
  171|  4.06k|      const int length = normalized->size() - kSpaceSymbol.size();
  172|  4.06k|      RET_CHECK_GE(length, 0);
  ------------------
  |  |  292|  4.06k|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  285|  4.06k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 4.06k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  4.06k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  4.06k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  173|  4.06k|      normalized->resize(length);
  174|  4.06k|      if (norm_to_orig) {
  ------------------
  |  Branch (174:11): [True: 0, False: 4.06k]
  ------------------
  175|      0|        consumed = (*norm_to_orig)[length];
  176|      0|        norm_to_orig->resize(length);
  177|      0|      }
  178|  4.06k|    }
  179|  58.3k|  }
  180|       |
  181|       |  // Adds a space symbol as a suffix (default is false)
  182|  58.3k|  if (treat_whitespace_as_suffix_ && spec_->add_dummy_prefix()) add_ws();
  ------------------
  |  Branch (182:7): [True: 0, False: 58.3k]
  |  Branch (182:38): [True: 0, False: 0]
  ------------------
  183|       |
  184|  58.3k|  if (norm_to_orig) {
  ------------------
  |  Branch (184:7): [True: 0, False: 58.3k]
  ------------------
  185|      0|    norm_to_orig->push_back(consumed);
  186|      0|    RET_CHECK_EQ(norm_to_orig->size(), normalized->size() + 1);
  ------------------
  |  |  290|      0|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  285|      0|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|      0|  } else /* NOLINT */                                         \
  |  |  |  |  287|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  187|      0|  }
  188|       |
  189|  58.3k|  return absl::OkStatus();
  190|  58.3k|}
_ZNK13sentencepiece10normalizer10Normalizer9NormalizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  192|  58.9k|std::string Normalizer::Normalize(absl::string_view input) const {
  193|  58.9k|  std::string normalized;
  194|  58.9k|  Normalize(input, &normalized, nullptr).IgnoreError();
  195|  58.9k|  return normalized;
  196|  58.9k|}
_ZNK13sentencepiece10normalizer10Normalizer15NormalizePrefixENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  199|  9.22M|    absl::string_view input) const {
  200|  9.22M|  if (input.empty()) return {};
  ------------------
  |  Branch (200:7): [True: 0, False: 9.22M]
  ------------------
  201|       |
  202|  9.22M|  if (matcher_ != nullptr) {
  ------------------
  |  Branch (202:7): [True: 0, False: 9.22M]
  ------------------
  203|      0|    bool found = false;
  204|      0|    const int mblen = matcher_->PrefixMatch(input, &found);
  205|      0|    if (found) return {input.substr(0, mblen), mblen};
  ------------------
  |  Branch (205:9): [True: 0, False: 0]
  ------------------
  206|      0|  }
  207|       |
  208|  9.22M|  size_t longest_length = 0;
  209|  9.22M|  size_t longest_value = 0;
  210|       |
  211|  9.22M|  if (trie_ != nullptr) {
  ------------------
  |  Branch (211:7): [True: 9.22M, False: 0]
  ------------------
  212|       |    // Allocates trie_results in stack, which makes the encoding speed 36%
  213|       |    // faster. (38k sentences/sec => 60k sentences/sec). Builder checks that the
  214|       |    // result size never exceeds kMaxTrieResultsSize. This array consumes
  215|       |    // 0.5kByte in stack, which is less than default stack frames (16kByte).
  216|  9.22M|    Darts::DoubleArray::result_pair_type
  217|  9.22M|        trie_results[Normalizer::kMaxTrieResultsSize];
  218|       |
  219|       |    // commonPrefixSearch returns the total number of matches, which can be
  220|       |    // larger than the buffer size (see darts.h). A precompiled charsmap loaded
  221|       |    // from an untrusted model is not subject to the build-time
  222|       |    // kMaxTrieResultsSize check, so cap the count to the buffer capacity before
  223|       |    // indexing trie_results.
  224|  9.22M|    const size_t num_nodes =
  225|  9.22M|        std::min<size_t>(trie_->commonPrefixSearch(
  226|  9.22M|                             input.data(), trie_results,
  227|  9.22M|                             Normalizer::kMaxTrieResultsSize, input.size()),
  228|  9.22M|                         Normalizer::kMaxTrieResultsSize);
  229|       |
  230|       |    // Finds the longest rule.
  231|  9.59M|    for (size_t k = 0; k < num_nodes; ++k) {
  ------------------
  |  Branch (231:24): [True: 377k, False: 9.22M]
  ------------------
  232|   377k|      if (longest_length == 0 || trie_results[k].length > longest_length) {
  ------------------
  |  Branch (232:11): [True: 377k, False: 139]
  |  Branch (232:34): [True: 139, False: 0]
  ------------------
  233|   377k|        longest_length = trie_results[k].length;  // length of prefix
  234|   377k|        longest_value = trie_results[k].value;    // pointer to |normalized_|.
  235|   377k|      }
  236|   377k|    }
  237|  9.22M|  }
  238|       |
  239|  9.22M|  std::pair<absl::string_view, int> result;
  240|  9.22M|  if (longest_length == 0 || longest_length > input.size() ||
  ------------------
  |  Branch (240:7): [True: 8.84M, False: 377k]
  |  Branch (240:30): [True: 0, False: 377k]
  ------------------
  241|  8.84M|      longest_value >= normalized_.size()) {
  ------------------
  |  Branch (241:7): [True: 0, False: 377k]
  ------------------
  242|  8.84M|    size_t length = 0;
  243|  8.84M|    if (!string_util::IsValidDecodeUTF8(input, &length)) {
  ------------------
  |  Branch (243:9): [True: 2.32M, False: 6.51M]
  ------------------
  244|       |      // Found a malformed utf8.
  245|       |      // The rune is set to be 0xFFFD (REPLACEMENT CHARACTER),
  246|       |      // which is a valid Unicode of three bytes in utf8,
  247|       |      // but here we only consume one byte.
  248|  2.32M|      result.second = 1;
  249|  2.32M|      static constexpr absl::string_view kReplacementChar = "\xEF\xBF\xBD";
  250|  2.32M|      result.first = kReplacementChar;
  251|  6.51M|    } else {
  252|  6.51M|      result.second = length;
  253|  6.51M|      result.first = absl::string_view(input.data(), result.second);
  254|  6.51M|    }
  255|  8.84M|  } else {
  256|   377k|    result.second = longest_length;
  257|       |    // No need to pass the size of normalized sentence,
  258|       |    // since |normalized| is delimitered by "\0".
  259|   377k|    result.first = normalized_.data() + longest_value;
  260|   377k|  }
  261|       |
  262|  9.22M|  return result;
  263|  9.22M|}
_ZN13sentencepiece10normalizer10Normalizer25DecodePrecompiledCharsMapENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPS6_S7_PNS2_12basic_stringIcS5_NS2_9allocatorIcEEEE:
  286|  17.0k|    absl::string_view* normalized, std::string* buffer) {
  287|  17.0k|  uint32_t trie_blob_size = 0;
  288|  17.0k|  if (blob.size() <= sizeof(trie_blob_size) ||
  ------------------
  |  Branch (288:7): [True: 0, False: 17.0k]
  ------------------
  289|  17.0k|      !string_util::DecodePOD<uint32_t>(
  ------------------
  |  Branch (289:7): [True: 0, False: 17.0k]
  ------------------
  290|  17.0k|          absl::string_view(blob.data(), sizeof(trie_blob_size)),
  291|  17.0k|          &trie_blob_size)) {
  292|      0|    return absl::InternalError("Blob for normalization rule is broken.");
  293|      0|  }
  294|       |
  295|       |  if constexpr (util::is_bigendian()) {
  296|       |    trie_blob_size = util::Swap32(trie_blob_size);
  297|       |  }
  298|       |
  299|  17.0k|  if (trie_blob_size >= blob.size() - sizeof(trie_blob_size)) {
  ------------------
  |  Branch (299:7): [True: 0, False: 17.0k]
  ------------------
  300|      0|    return absl::InternalError("Trie data size exceeds the input blob size.");
  301|      0|  }
  302|       |
  303|       |  // Dart unit_size is 4 and blob size in units must be a multiple of 256.
  304|  17.0k|  if (trie_blob_size < 1024 || (trie_blob_size & 0x3FF) != 0) {
  ------------------
  |  Branch (304:7): [True: 0, False: 17.0k]
  |  Branch (304:32): [True: 0, False: 17.0k]
  ------------------
  305|      0|    return absl::InternalError("Trie data size is not divisible by 1024.");
  306|      0|  }
  307|       |
  308|  17.0k|  blob.remove_prefix(sizeof(trie_blob_size));
  309|       |
  310|       |  if constexpr (util::is_bigendian()) {
  311|       |    RET_CHECK(buffer);
  312|       |    buffer->assign(blob.data(), trie_blob_size);
  313|       |    uint32_t* data =
  314|       |        reinterpret_cast<uint32_t*>(const_cast<char*>(buffer->data()));
  315|       |    for (int i = 0; i < buffer->size() / 4; ++i)
  316|       |      data[i] = util::Swap32(data[i]);
  317|       |    *trie_blob = absl::string_view(buffer->data(), trie_blob_size);
  318|  17.0k|  } else {
  319|  17.0k|    *trie_blob = absl::string_view(blob.data(), trie_blob_size);
  320|  17.0k|  }
  321|       |
  322|  17.0k|  blob.remove_prefix(trie_blob_size);
  323|  17.0k|  *normalized = absl::string_view(blob.data(), blob.size());
  324|       |
  325|  17.0k|  if (normalized->empty() || normalized->back() != '\0') {
  ------------------
  |  Branch (325:7): [True: 0, False: 17.0k]
  |  Branch (325:30): [True: 0, False: 17.0k]
  ------------------
  326|      0|    return absl::InternalError("normalized block must be null terminated.");
  327|      0|  }
  328|       |
  329|  17.0k|  return absl::OkStatus();
  330|  17.0k|}
_ZN13sentencepiece10normalizer13PrefixMatcherC2ERKNSt3__13setINS2_17basic_string_viewIcNS2_11char_traitsIcEEEENS2_4lessIS7_EENS2_9allocatorIS7_EEEE:
  332|  8.53k|PrefixMatcher::PrefixMatcher(const std::set<absl::string_view>& dic) {
  333|  8.53k|  if (dic.empty()) return;
  ------------------
  |  Branch (333:7): [True: 0, False: 8.53k]
  ------------------
  334|  8.53k|  std::vector<const char*> key;
  335|  8.53k|  std::vector<size_t> lengths;
  336|  8.53k|  key.reserve(dic.size());
  337|  8.53k|  lengths.reserve(dic.size());
  338|  43.0k|  for (const auto& it : dic) {
  ------------------
  |  Branch (338:23): [True: 43.0k, False: 8.53k]
  ------------------
  339|  43.0k|    key.push_back(it.data());
  340|  43.0k|    lengths.push_back(it.size());
  341|  43.0k|  }
  342|  8.53k|  trie_ = std::make_unique<Darts::DoubleArray>();
  343|  8.53k|  if (trie_->build(key.size(), const_cast<char**>(key.data()),
  ------------------
  |  Branch (343:7): [True: 0, False: 8.53k]
  ------------------
  344|  8.53k|                   const_cast<size_t*>(lengths.data()), nullptr) != 0) {
  345|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  346|      0|    trie_.reset();
  347|      0|  }
  348|  8.53k|}
_ZNK13sentencepiece10normalizer13PrefixMatcher11PrefixMatchENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPb:
  350|  9.02M|int PrefixMatcher::PrefixMatch(absl::string_view w, bool* found) const {
  351|  9.02M|  if (trie_ == nullptr) {
  ------------------
  |  Branch (351:7): [True: 0, False: 9.02M]
  ------------------
  352|      0|    if (found) *found = false;
  ------------------
  |  Branch (352:9): [True: 0, False: 0]
  ------------------
  353|      0|    return std::min<int>(w.size(), string_util::OneCharLen(w.data()));
  354|      0|  }
  355|       |
  356|  9.02M|  constexpr int kResultSize = 64;
  357|  9.02M|  Darts::DoubleArray::result_pair_type trie_results[kResultSize];
  358|  9.02M|  const int num_nodes = std::min<int>(
  359|  9.02M|      trie_->commonPrefixSearch(w.data(), trie_results, kResultSize, w.size()),
  360|  9.02M|      kResultSize);
  361|       |
  362|  9.02M|  if (found) *found = (num_nodes > 0);
  ------------------
  |  Branch (362:7): [True: 9.02M, False: 0]
  ------------------
  363|  9.02M|  if (num_nodes == 0) {
  ------------------
  |  Branch (363:7): [True: 9.02M, False: 2.93k]
  ------------------
  364|  9.02M|    return std::min<int>(w.size(), string_util::OneCharLen(w.data()));
  365|  9.02M|  }
  366|       |
  367|  2.93k|  int mblen = 0;
  368|  5.86k|  for (int i = 0; i < num_nodes; ++i) {
  ------------------
  |  Branch (368:19): [True: 2.93k, False: 2.93k]
  ------------------
  369|  2.93k|    mblen = std::max<int>(trie_results[i].length, mblen);
  370|  2.93k|  }
  371|       |
  372|  2.93k|  return mblen;
  373|  9.02M|}
_ZNK13sentencepiece10normalizer13PrefixMatcher13GlobalReplaceENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEES6_:
  376|  58.9k|                                         absl::string_view out) const {
  377|  58.9k|  std::string result;
  378|  9.08M|  while (!w.empty()) {
  ------------------
  |  Branch (378:10): [True: 9.02M, False: 58.9k]
  ------------------
  379|  9.02M|    bool found = false;
  380|  9.02M|    const int mblen = PrefixMatch(w, &found);
  381|  9.02M|    if (found) {
  ------------------
  |  Branch (381:9): [True: 2.93k, False: 9.02M]
  ------------------
  382|  2.93k|      result.append(out.data(), out.size());
  383|  9.02M|    } else {
  384|  9.02M|      result.append(w.data(), mblen);
  385|  9.02M|    }
  386|  9.02M|    w.remove_prefix(mblen);
  387|  9.02M|  }
  388|  58.9k|  return result;
  389|  58.9k|}
normalizer.cc:_ZZNK13sentencepiece10normalizer10Normalizer9NormalizeENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS2_12basic_stringIcS5_NS2_9allocatorIcEEEEPNS2_6vectorImNS8_ImEEEEENK3$_0clEv:
  124|   476k|  auto add_ws = [&consumed, &normalized, &norm_to_orig, &kSpaceSymbol]() {
  125|   476k|    normalized->append(kSpaceSymbol.data(), kSpaceSymbol.size());
  126|   476k|    if (norm_to_orig) {
  ------------------
  |  Branch (126:9): [True: 0, False: 476k]
  ------------------
  127|      0|      norm_to_orig->insert(norm_to_orig->end(), kSpaceSymbol.size(), consumed);
  128|      0|    }
  129|   476k|  };

_ZNK13sentencepiece10normalizer10Normalizer6statusEv:
   78|  67.5k|  virtual absl::Status status() const { return status_; }

_ZN13sentencepiece20SentencePieceTrainer5TrainERKNS_11TrainerSpecERKNS_14NormalizerSpecES6_PNS_16SentenceIteratorEPNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEE:
   89|  8.54k|    SentenceIterator* sentence_iterator, std::string* serialized_model_proto) {
   90|  8.54k|  auto copied_normalizer_spec = normalizer_spec;
   91|  8.54k|  RETURN_IF_ERROR(PopulateNormalizerSpec(&copied_normalizer_spec, false));
  ------------------
  |  |   44|  8.54k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  8.54k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  17.0k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  17.0k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  17.0k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 8.54k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  8.54k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 8.54k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  17.0k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 8.54k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  17.0k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  17.0k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  8.54k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  17.0k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   92|  8.54k|  auto copied_denormalizer_spec = denormalizer_spec;
   93|  8.54k|  RETURN_IF_ERROR(PopulateNormalizerSpec(&copied_denormalizer_spec, true));
  ------------------
  |  |   44|  8.54k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  8.54k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  17.0k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  17.0k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  17.0k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 8.54k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  8.54k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 8.54k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  17.0k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 8.54k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  17.0k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  17.0k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  8.54k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  17.0k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   94|  8.54k|  auto trainer = TrainerFactory::Create(trainer_spec, copied_normalizer_spec,
   95|  8.54k|                                        copied_denormalizer_spec);
   96|  8.54k|  std::string info =
   97|  8.54k|      absl::StrCat(PrintProto(trainer_spec, "trainer_spec"),
   98|  8.54k|                   PrintProto(copied_normalizer_spec, "normalizer_spec"));
   99|  8.54k|  if (!copied_denormalizer_spec.precompiled_charsmap().empty()) {
  ------------------
  |  Branch (99:7): [True: 0, False: 8.54k]
  ------------------
  100|      0|    info += PrintProto(copied_denormalizer_spec, "denormalizer_spec");
  101|  8.54k|  } else {
  102|  8.54k|    info += "denormalizer_spec {}";
  103|  8.54k|  }
  104|       |
  105|  25.6k|  LOG(INFO) << "Starts training with : \n" << info;
  ------------------
  |  |  218|  8.54k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  8.54k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  8.54k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  17.0k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  17.0k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 8.54k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  8.54k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 8.54k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  8.54k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 8.54k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  8.54k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  25.6k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  25.6k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  106|       |
  107|  8.54k|  if (serialized_model_proto) {
  ------------------
  |  Branch (107:7): [True: 8.54k, False: 0]
  ------------------
  108|  8.54k|    ModelProto model_proto;
  109|  8.54k|    RETURN_IF_ERROR(trainer->Train(sentence_iterator, &model_proto));
  ------------------
  |  |   44|  8.54k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  8.54k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  17.0k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  17.0k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  17.0k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 8.54k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  8.54k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 8.54k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  17.0k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 4.30k, False: 4.23k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  17.0k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  17.0k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  4.30k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  17.0k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  110|  4.30k|    *serialized_model_proto = model_proto.SerializeAsString();
  111|  4.30k|  } else {
  112|      0|    RETURN_IF_ERROR(trainer->Train(sentence_iterator, nullptr));
  ------------------
  |  |   44|      0|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  113|      0|  }
  114|       |
  115|  4.30k|  return absl::OkStatus();
  116|  8.54k|}
_ZN13sentencepiece20SentencePieceTrainer18MergeSpecsFromArgsENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPNS_11TrainerSpecEPNS_14NormalizerSpecES9_:
  130|  8.54k|    NormalizerSpec* normalizer_spec, NormalizerSpec* denormalizer_spec) {
  131|  8.54k|  RET_CHECK(trainer_spec) << "`trainer_spec` must not be null.";
  ------------------
  |  |  285|  8.54k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  ------------------
  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  132|  8.54k|  RET_CHECK(normalizer_spec) << "`normalizer_spec` must not be null.";
  ------------------
  |  |  285|  8.54k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  ------------------
  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  133|  8.54k|  RET_CHECK(denormalizer_spec) << "`denormalizer_spec` must not be null.";
  ------------------
  |  |  285|  8.54k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  ------------------
  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  134|       |
  135|  8.54k|  if (args.empty()) return absl::OkStatus();
  ------------------
  |  Branch (135:7): [True: 0, False: 8.54k]
  ------------------
  136|       |
  137|  8.54k|  std::unordered_map<std::string, std::string> kwargs;
  138|  40.8k|  for (auto arg : absl::StrSplit(args, " ")) {
  ------------------
  |  Branch (138:17): [True: 40.8k, False: 8.54k]
  ------------------
  139|  40.8k|    absl::ConsumePrefix(&arg, "--");
  140|  40.8k|    std::string key, value;
  141|  40.8k|    const auto pos = arg.find('=');
  142|  40.8k|    if (pos == absl::string_view::npos) {
  ------------------
  |  Branch (142:9): [True: 0, False: 40.8k]
  ------------------
  143|      0|      key = std::string(arg);
  144|  40.8k|    } else {
  145|  40.8k|      key = std::string(arg.substr(0, pos));
  146|  40.8k|      value = std::string(arg.substr(pos + 1));
  147|  40.8k|    }
  148|  40.8k|    kwargs.emplace(key, value);
  149|  40.8k|  }
  150|       |
  151|  8.54k|  return MergeSpecsFromArgs(kwargs, trainer_spec, normalizer_spec,
  152|  8.54k|                            denormalizer_spec);
  153|  8.54k|}
_ZN13sentencepiece20SentencePieceTrainer18MergeSpecsFromArgsERKNSt3__113unordered_mapINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES8_NS1_4hashIS8_EENS1_8equal_toIS8_EENS6_INS1_4pairIKS8_S8_EEEEEEPNS_11TrainerSpecEPNS_14NormalizerSpecESN_:
  159|  8.54k|    NormalizerSpec* denormalizer_spec) {
  160|  8.54k|  RET_CHECK(trainer_spec) << "`trainer_spec` must not be null.";
  ------------------
  |  |  285|  8.54k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  ------------------
  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  161|  8.54k|  RET_CHECK(normalizer_spec) << "`normalizer_spec` must not be null.";
  ------------------
  |  |  285|  8.54k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  ------------------
  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  162|  8.54k|  RET_CHECK(denormalizer_spec) << "`denormalizer_spec` must not be null.";
  ------------------
  |  |  285|  8.54k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  ------------------
  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  163|       |
  164|  8.54k|  const auto it_spec = kwargs.find(kSerializedNormalizerSpecKey);
  165|  8.54k|  const bool has_serialized_normalizer = (it_spec != kwargs.end());
  166|       |
  167|  8.54k|  if (has_serialized_normalizer) {
  ------------------
  |  Branch (167:7): [True: 0, False: 8.54k]
  ------------------
  168|      0|    std::string conflicting_key;
  169|      0|    if (ContainsNormalizerKeys(kwargs, &conflicting_key)) {
  ------------------
  |  Branch (169:9): [True: 0, False: 0]
  ------------------
  170|      0|      return absl::InvalidArgumentError(absl::StrCat(
  171|      0|          "Cannot specify both ", kSerializedNormalizerSpecKey,
  172|      0|          " and normalizer-specific argument: ", conflicting_key));
  173|      0|    }
  174|      0|  }
  175|       |
  176|       |  // 1. Process serialized normalizer FIRST to load the base specs.
  177|       |  // This is used by the Python module to support the 'normalizer' parameter.
  178|  8.54k|  if (it_spec != kwargs.end()) {
  ------------------
  |  Branch (178:7): [True: 0, False: 8.54k]
  ------------------
  179|      0|    sentencepiece::NormalizerSpec spec;
  180|      0|    RET_CHECK(spec.ParseFromString(it_spec->second))
  ------------------
  |  |  285|      0|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|  } else /* NOLINT */                                         \
  |  |  287|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  181|      0|        << "Failed to parse " << kSerializedNormalizerSpecKey << ".";
  182|      0|    *normalizer_spec = spec;
  183|      0|  }
  184|       |
  185|  40.8k|  for (const auto& [key, value] : kwargs) {
  ------------------
  |  Branch (185:33): [True: 40.8k, False: 8.54k]
  ------------------
  186|  40.8k|    if (key == kSerializedNormalizerSpecKey) {
  ------------------
  |  Branch (186:9): [True: 0, False: 40.8k]
  ------------------
  187|      0|      continue;
  188|      0|    }
  189|       |    // Exceptions.
  190|  40.8k|    if (key == "normalization_rule_name") {
  ------------------
  |  Branch (190:9): [True: 0, False: 40.8k]
  ------------------
  191|      0|      normalizer_spec->set_name(value);
  192|      0|      continue;
  193|  40.8k|    } else if (key == "denormalization_rule_tsv") {
  ------------------
  |  Branch (193:16): [True: 0, False: 40.8k]
  ------------------
  194|      0|      denormalizer_spec->set_normalization_rule_tsv(value);
  195|      0|      denormalizer_spec->set_add_dummy_prefix(false);
  196|      0|      denormalizer_spec->set_remove_extra_whitespaces(false);
  197|      0|      denormalizer_spec->set_escape_whitespaces(false);
  198|      0|      continue;
  199|  40.8k|    } else if (key == "minloglevel") {
  ------------------
  |  Branch (199:16): [True: 0, False: 40.8k]
  ------------------
  200|      0|      int v = 0;
  201|      0|      RET_CHECK(absl::SimpleAtoi(value, &v));
  ------------------
  |  |  285|      0|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|  } else /* NOLINT */                                         \
  |  |  287|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  202|      0|      SetMinLogLevel(v);
  203|      0|      continue;
  204|      0|    }
  205|       |
  206|  40.8k|    const auto status_train = SetProtoField(key, value, trainer_spec);
  207|  40.8k|    if (status_train.ok()) continue;
  ------------------
  |  Branch (207:9): [True: 40.8k, False: 0]
  ------------------
  208|      0|    if (!absl::IsNotFound(status_train)) return status_train;
  ------------------
  |  Branch (208:9): [True: 0, False: 0]
  ------------------
  209|       |
  210|      0|    const auto status_norm = SetProtoField(key, value, normalizer_spec);
  211|      0|    if (status_norm.ok()) continue;
  ------------------
  |  Branch (211:9): [True: 0, False: 0]
  ------------------
  212|      0|    if (!absl::IsNotFound(status_norm)) return status_norm;
  ------------------
  |  Branch (212:9): [True: 0, False: 0]
  ------------------
  213|       |
  214|       |    // Not found both in trainer_spec and normalizer_spec.
  215|      0|    if (absl::IsNotFound(status_train) && absl::IsNotFound(status_norm)) {
  ------------------
  |  Branch (215:9): [True: 0, False: 0]
  |  Branch (215:43): [True: 0, False: 0]
  ------------------
  216|      0|      return status_train;
  217|      0|    }
  218|      0|  }
  219|       |
  220|  8.54k|  return absl::OkStatus();
  221|  8.54k|}
_ZN13sentencepiece20SentencePieceTrainer5TrainENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPNS_16SentenceIteratorEPNS1_12basic_stringIcS4_NS1_9allocatorIcEEEE:
  226|  8.54k|                                         std::string* serialized_model_proto) {
  227|  25.6k|  LOG(INFO) << "Running command: " << args.data();
  ------------------
  |  |  218|  8.54k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  8.54k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  8.54k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  17.0k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  17.0k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 8.54k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  8.54k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 8.54k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  8.54k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 8.54k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  8.54k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  25.6k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  25.6k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  228|  8.54k|  TrainerSpec trainer_spec;
  229|  8.54k|  NormalizerSpec normalizer_spec;
  230|  8.54k|  NormalizerSpec denormalizer_spec;
  231|  8.54k|  RETURN_IF_ERROR(MergeSpecsFromArgs(args, &trainer_spec, &normalizer_spec,
  ------------------
  |  |   44|  8.54k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  8.54k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  17.0k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  17.0k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  17.0k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 8.54k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  8.54k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 8.54k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  17.0k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 8.54k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  17.0k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  17.0k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  8.54k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  17.0k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  232|  8.54k|                                     &denormalizer_spec));
  233|  8.54k|  return Train(trainer_spec, normalizer_spec, denormalizer_spec,
  234|  8.54k|               sentence_iterator, serialized_model_proto);
  235|  8.54k|}
_ZN13sentencepiece20SentencePieceTrainer5TrainENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEERKNS1_6vectorINS1_12basic_stringIcS4_NS1_9allocatorIcEEEENS8_ISA_EEEEPSA_:
  270|  8.54k|    std::string* serialized_model_proto) {
  271|  8.54k|  VectorSentenceIterator iter(sentences);
  272|  8.54k|  return Train(args, &iter, serialized_model_proto);
  273|  8.54k|}
_ZN13sentencepiece20SentencePieceTrainer22PopulateNormalizerSpecEPNS_14NormalizerSpecEb:
  286|  17.0k|    NormalizerSpec* normalizer_spec, bool is_denormalizer) {
  287|  17.0k|  RET_CHECK(normalizer_spec);
  ------------------
  |  |  285|  17.0k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 17.0k, False: 0]
  |  |  ------------------
  |  |  286|  17.0k|  } else /* NOLINT */                                         \
  |  |  287|  17.0k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  288|       |
  289|  17.0k|  if (!normalizer_spec->normalization_rule_tsv().empty()) {
  ------------------
  |  Branch (289:7): [True: 0, False: 17.0k]
  ------------------
  290|      0|    RET_CHECK(normalizer_spec->precompiled_charsmap().empty())
  ------------------
  |  |  285|      0|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|  } else /* NOLINT */                                         \
  |  |  287|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  291|      0|        << "precompiled_charsmap is already defined.";
  292|      0|    normalizer::Builder::CharsMap chars_map;
  293|      0|    RETURN_IF_ERROR(normalizer::Builder::LoadCharsMap(
  ------------------
  |  |   44|      0|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  294|      0|        normalizer_spec->normalization_rule_tsv(), &chars_map));
  295|      0|    RETURN_IF_ERROR(normalizer::Builder::CompileCharsMap(
  ------------------
  |  |   44|      0|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  296|      0|        chars_map, normalizer_spec->mutable_precompiled_charsmap()));
  297|      0|    normalizer_spec->set_name("user_defined");
  298|  17.0k|  } else if (!is_denormalizer) {
  ------------------
  |  Branch (298:14): [True: 8.54k, False: 8.54k]
  ------------------
  299|  8.54k|    if (normalizer_spec->name().empty()) {
  ------------------
  |  Branch (299:9): [True: 8.54k, False: 0]
  ------------------
  300|  8.54k|      normalizer_spec->set_name(kDefaultNormalizerName);
  301|  8.54k|    }
  302|  8.54k|    if (normalizer_spec->precompiled_charsmap().empty()) {
  ------------------
  |  Branch (302:9): [True: 8.54k, False: 0]
  ------------------
  303|  8.54k|      RETURN_IF_ERROR(normalizer::Builder::GetPrecompiledCharsMap(
  ------------------
  |  |   44|  8.54k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  8.54k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  17.0k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  17.0k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  17.0k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 8.54k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  8.54k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 8.54k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  17.0k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 8.54k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  17.0k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  17.0k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  8.54k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  17.0k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  304|  8.54k|          normalizer_spec->name(),
  305|  8.54k|          normalizer_spec->mutable_precompiled_charsmap()));
  306|  8.54k|    }
  307|  8.54k|  }
  308|       |
  309|  17.0k|  return absl::OkStatus();
  310|  17.0k|}
_ZN13sentencepiece20SentencePieceTrainer26GetPretokenizerForTrainingEv:
  343|  15.8k|SentencePieceTrainer::GetPretokenizerForTraining() {
  344|  15.8k|  return g_pretokenizer;
  345|  15.8k|}
sentencepiece_trainer.cc:_ZN13sentencepiece12_GLOBAL__N_122VectorSentenceIteratorC2ERKNSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEE:
  254|  8.54k|      : iter_(values.begin()), end_(values.end()) {}
sentencepiece_trainer.cc:_ZNK13sentencepiece12_GLOBAL__N_122VectorSentenceIterator4doneEv:
  256|  67.7k|  virtual bool done() const { return iter_ == end_; }
sentencepiece_trainer.cc:_ZN13sentencepiece12_GLOBAL__N_122VectorSentenceIterator4NextEv:
  257|  59.2k|  void Next() override { ++iter_; }
sentencepiece_trainer.cc:_ZNK13sentencepiece12_GLOBAL__N_122VectorSentenceIterator5valueEv:
  258|  59.2k|  const std::string& value() const override { return *iter_; }
sentencepiece_trainer.cc:_ZNK13sentencepiece12_GLOBAL__N_122VectorSentenceIterator6statusEv:
  259|  8.53k|  absl::Status status() const override { return absl::OkStatus(); }

_ZN13sentencepiece16SentenceIteratorD2Ev:
   52|  8.54k|  virtual ~SentenceIterator() = default;

_ZN13sentencepiece20SentencePieceTrainer13SetProtoFieldENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEES5_PNS_11TrainerSpecE:
  200|  40.8k|                                                 TrainerSpec* message) {
  201|  40.8k|  RET_CHECK(message);
  ------------------
  |  |  285|  40.8k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 40.8k, False: 0]
  |  |  ------------------
  |  |  286|  40.8k|  } else /* NOLINT */                                         \
  |  |  287|  40.8k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  202|       |
  203|  40.8k|  PARSE_REPEATED_STRING(input);
  ------------------
  |  |   39|  40.8k|  if (name == #param_name) {                             \
  |  |  ------------------
  |  |  |  Branch (39:7): [True: 0, False: 40.8k]
  |  |  ------------------
  |  |   40|      0|    for (const auto& val : util::StrSplitAsCSV(value)) { \
  |  |  ------------------
  |  |  |  Branch (40:26): [True: 0, False: 0]
  |  |  ------------------
  |  |   41|      0|      message->add_##param_name(val);                    \
  |  |   42|      0|    }                                                    \
  |  |   43|      0|    return absl::OkStatus();                             \
  |  |   44|      0|  }
  ------------------
  204|  40.8k|  PARSE_STRING(input_format);
  ------------------
  |  |   33|  40.8k|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (33:7): [True: 0, False: 40.8k]
  |  |  ------------------
  |  |   34|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   35|      0|    return absl::OkStatus();                               \
  |  |   36|      0|  }
  ------------------
  205|  40.8k|  PARSE_STRING(model_prefix);
  ------------------
  |  |   33|  40.8k|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (33:7): [True: 0, False: 40.8k]
  |  |  ------------------
  |  |   34|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   35|      0|    return absl::OkStatus();                               \
  |  |   36|      0|  }
  ------------------
  206|       |
  207|  40.8k|  static const std::map<std::string, TrainerSpec::ModelType> kModelType_Map = {
  208|  40.8k|      {"UNIGRAM", TrainerSpec::UNIGRAM},
  209|  40.8k|      {"BPE", TrainerSpec::BPE},
  210|  40.8k|      {"WORD", TrainerSpec::WORD},
  211|  40.8k|      {"CHAR", TrainerSpec::CHAR},
  212|  40.8k|  };
  213|       |
  214|  40.8k|  PARSE_ENUM(model_type, kModelType_Map);
  ------------------
  |  |   93|  40.8k|  if (name == #param_name) {                                           \
  |  |  ------------------
  |  |  |  Branch (93:7): [True: 8.54k, False: 32.2k]
  |  |  ------------------
  |  |   94|  8.54k|    const auto it = map_name.find(absl::AsciiStrToUpper(value));       \
  |  |   95|  8.54k|    if (it == map_name.end())                                          \
  |  |  ------------------
  |  |  |  Branch (95:9): [True: 0, False: 8.54k]
  |  |  ------------------
  |  |   96|  8.54k|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument)   \
  |  |   97|      0|             << "unknown enumeration value of \"" << value << "\" as " \
  |  |   98|      0|             << #map_name;                                             \
  |  |   99|  8.54k|    message->set_##param_name(it->second);                             \
  |  |  100|  8.54k|    return absl::OkStatus();                                           \
  |  |  101|  8.54k|  }
  ------------------
  215|  32.2k|  PARSE_INT32(vocab_size);
  ------------------
  |  |   53|  32.2k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (53:7): [True: 8.54k, False: 23.7k]
  |  |  ------------------
  |  |   54|  8.54k|    int32_t v;                                                       \
  |  |   55|  8.54k|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (55:9): [True: 0, False: 8.54k]
  |  |  ------------------
  |  |   56|  8.54k|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   57|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   58|  8.54k|    message->set_##param_name(v);                                    \
  |  |   59|  8.54k|    return absl::OkStatus();                                         \
  |  |   60|  8.54k|  }
  ------------------
  216|  23.7k|  PARSE_REPEATED_STRING(accept_language);
  ------------------
  |  |   39|  23.7k|  if (name == #param_name) {                             \
  |  |  ------------------
  |  |  |  Branch (39:7): [True: 0, False: 23.7k]
  |  |  ------------------
  |  |   40|      0|    for (const auto& val : util::StrSplitAsCSV(value)) { \
  |  |  ------------------
  |  |  |  Branch (40:26): [True: 0, False: 0]
  |  |  ------------------
  |  |   41|      0|      message->add_##param_name(val);                    \
  |  |   42|      0|    }                                                    \
  |  |   43|      0|    return absl::OkStatus();                             \
  |  |   44|      0|  }
  ------------------
  217|  23.7k|  PARSE_INT32(self_test_sample_size);
  ------------------
  |  |   53|  23.7k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (53:7): [True: 0, False: 23.7k]
  |  |  ------------------
  |  |   54|      0|    int32_t v;                                                       \
  |  |   55|      0|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (55:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   56|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   57|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   58|      0|    message->set_##param_name(v);                                    \
  |  |   59|      0|    return absl::OkStatus();                                         \
  |  |   60|      0|  }
  ------------------
  218|  23.7k|  PARSE_DOUBLE(character_coverage);
  ------------------
  |  |   73|  23.7k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (73:7): [True: 2.17k, False: 21.5k]
  |  |  ------------------
  |  |   74|  2.17k|    double v;                                                        \
  |  |   75|  2.17k|    if (!absl::SimpleAtod(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (75:9): [True: 0, False: 2.17k]
  |  |  ------------------
  |  |   76|  2.17k|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   77|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   78|  2.17k|    message->set_##param_name(v);                                    \
  |  |   79|  2.17k|    return absl::OkStatus();                                         \
  |  |   80|  2.17k|  }
  ------------------
  219|  21.5k|  PARSE_UINT64(input_sentence_size);
  ------------------
  |  |   63|  21.5k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (63:7): [True: 1.76k, False: 19.8k]
  |  |  ------------------
  |  |   64|  1.76k|    uint64_t v;                                                      \
  |  |   65|  1.76k|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (65:9): [True: 0, False: 1.76k]
  |  |  ------------------
  |  |   66|  1.76k|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   67|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   68|  1.76k|    message->set_##param_name(v);                                    \
  |  |   69|  1.76k|    return absl::OkStatus();                                         \
  |  |   70|  1.76k|  }
  ------------------
  220|  19.8k|  PARSE_BOOL(shuffle_input_sentence);
  ------------------
  |  |   83|  19.8k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 2.06k, False: 17.7k]
  |  |  ------------------
  |  |   84|  2.06k|    bool v;                                                          \
  |  |   85|  2.06k|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 2.06k]
  |  |  |  Branch (85:27): [True: 0, False: 2.06k]
  |  |  ------------------
  |  |   86|  2.06k|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|  2.06k|    message->set_##param_name(v);                                    \
  |  |   89|  2.06k|    return absl::OkStatus();                                         \
  |  |   90|  2.06k|  }
  ------------------
  221|  17.7k|  PARSE_INT32(seed_sentencepiece_size);
  ------------------
  |  |   53|  17.7k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (53:7): [True: 0, False: 17.7k]
  |  |  ------------------
  |  |   54|      0|    int32_t v;                                                       \
  |  |   55|      0|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (55:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   56|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   57|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   58|      0|    message->set_##param_name(v);                                    \
  |  |   59|      0|    return absl::OkStatus();                                         \
  |  |   60|      0|  }
  ------------------
  222|  17.7k|  PARSE_DOUBLE(shrinking_factor);
  ------------------
  |  |   73|  17.7k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (73:7): [True: 0, False: 17.7k]
  |  |  ------------------
  |  |   74|      0|    double v;                                                        \
  |  |   75|      0|    if (!absl::SimpleAtod(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (75:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   76|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   77|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   78|      0|    message->set_##param_name(v);                                    \
  |  |   79|      0|    return absl::OkStatus();                                         \
  |  |   80|      0|  }
  ------------------
  223|  17.7k|  PARSE_INT32(max_sentence_length);
  ------------------
  |  |   53|  17.7k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (53:7): [True: 0, False: 17.7k]
  |  |  ------------------
  |  |   54|      0|    int32_t v;                                                       \
  |  |   55|      0|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (55:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   56|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   57|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   58|      0|    message->set_##param_name(v);                                    \
  |  |   59|      0|    return absl::OkStatus();                                         \
  |  |   60|      0|  }
  ------------------
  224|  17.7k|  PARSE_INT32(num_threads);
  ------------------
  |  |   53|  17.7k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (53:7): [True: 8.54k, False: 9.20k]
  |  |  ------------------
  |  |   54|  8.54k|    int32_t v;                                                       \
  |  |   55|  8.54k|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (55:9): [True: 0, False: 8.54k]
  |  |  ------------------
  |  |   56|  8.54k|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   57|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   58|  8.54k|    message->set_##param_name(v);                                    \
  |  |   59|  8.54k|    return absl::OkStatus();                                         \
  |  |   60|  8.54k|  }
  ------------------
  225|  9.20k|  PARSE_INT32(num_sub_iterations);
  ------------------
  |  |   53|  9.20k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (53:7): [True: 0, False: 9.20k]
  |  |  ------------------
  |  |   54|      0|    int32_t v;                                                       \
  |  |   55|      0|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (55:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   56|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   57|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   58|      0|    message->set_##param_name(v);                                    \
  |  |   59|      0|    return absl::OkStatus();                                         \
  |  |   60|      0|  }
  ------------------
  226|  9.20k|  PARSE_INT32(max_sentencepiece_length);
  ------------------
  |  |   53|  9.20k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (53:7): [True: 0, False: 9.20k]
  |  |  ------------------
  |  |   54|      0|    int32_t v;                                                       \
  |  |   55|      0|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (55:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   56|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   57|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   58|      0|    message->set_##param_name(v);                                    \
  |  |   59|      0|    return absl::OkStatus();                                         \
  |  |   60|      0|  }
  ------------------
  227|  9.20k|  PARSE_BOOL(split_by_unicode_script);
  ------------------
  |  |   83|  9.20k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 3.10k, False: 6.09k]
  |  |  ------------------
  |  |   84|  3.10k|    bool v;                                                          \
  |  |   85|  3.10k|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 3.10k]
  |  |  |  Branch (85:27): [True: 0, False: 3.10k]
  |  |  ------------------
  |  |   86|  3.10k|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|  3.10k|    message->set_##param_name(v);                                    \
  |  |   89|  3.10k|    return absl::OkStatus();                                         \
  |  |   90|  3.10k|  }
  ------------------
  228|  6.09k|  PARSE_BOOL(split_by_number);
  ------------------
  |  |   83|  6.09k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 2.31k, False: 3.78k]
  |  |  ------------------
  |  |   84|  2.31k|    bool v;                                                          \
  |  |   85|  2.31k|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 2.31k]
  |  |  |  Branch (85:27): [True: 0, False: 2.31k]
  |  |  ------------------
  |  |   86|  2.31k|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|  2.31k|    message->set_##param_name(v);                                    \
  |  |   89|  2.31k|    return absl::OkStatus();                                         \
  |  |   90|  2.31k|  }
  ------------------
  229|  3.78k|  PARSE_BOOL(split_by_whitespace);
  ------------------
  |  |   83|  3.78k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 2.30k, False: 1.48k]
  |  |  ------------------
  |  |   84|  2.30k|    bool v;                                                          \
  |  |   85|  2.30k|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 2.30k]
  |  |  |  Branch (85:27): [True: 0, False: 2.30k]
  |  |  ------------------
  |  |   86|  2.30k|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|  2.30k|    message->set_##param_name(v);                                    \
  |  |   89|  2.30k|    return absl::OkStatus();                                         \
  |  |   90|  2.30k|  }
  ------------------
  230|  1.48k|  PARSE_BOOL(split_digits);
  ------------------
  |  |   83|  1.48k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 0, False: 1.48k]
  |  |  ------------------
  |  |   84|      0|    bool v;                                                          \
  |  |   85|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 0]
  |  |  |  Branch (85:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   86|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|      0|    message->set_##param_name(v);                                    \
  |  |   89|      0|    return absl::OkStatus();                                         \
  |  |   90|      0|  }
  ------------------
  231|  1.48k|  PARSE_STRING(pretokenization_delimiter);
  ------------------
  |  |   33|  1.48k|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (33:7): [True: 0, False: 1.48k]
  |  |  ------------------
  |  |   34|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   35|      0|    return absl::OkStatus();                               \
  |  |   36|      0|  }
  ------------------
  232|  1.48k|  PARSE_BOOL(treat_whitespace_as_suffix);
  ------------------
  |  |   83|  1.48k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 0, False: 1.48k]
  |  |  ------------------
  |  |   84|      0|    bool v;                                                          \
  |  |   85|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 0]
  |  |  |  Branch (85:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   86|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|      0|    message->set_##param_name(v);                                    \
  |  |   89|      0|    return absl::OkStatus();                                         \
  |  |   90|      0|  }
  ------------------
  233|  1.48k|  PARSE_BOOL(allow_whitespace_only_pieces);
  ------------------
  |  |   83|  1.48k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 0, False: 1.48k]
  |  |  ------------------
  |  |   84|      0|    bool v;                                                          \
  |  |   85|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 0]
  |  |  |  Branch (85:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   86|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|      0|    message->set_##param_name(v);                                    \
  |  |   89|      0|    return absl::OkStatus();                                         \
  |  |   90|      0|  }
  ------------------
  234|  1.48k|  PARSE_REPEATED_STRING(control_symbols);
  ------------------
  |  |   39|  1.48k|  if (name == #param_name) {                             \
  |  |  ------------------
  |  |  |  Branch (39:7): [True: 0, False: 1.48k]
  |  |  ------------------
  |  |   40|      0|    for (const auto& val : util::StrSplitAsCSV(value)) { \
  |  |  ------------------
  |  |  |  Branch (40:26): [True: 0, False: 0]
  |  |  ------------------
  |  |   41|      0|      message->add_##param_name(val);                    \
  |  |   42|      0|    }                                                    \
  |  |   43|      0|    return absl::OkStatus();                             \
  |  |   44|      0|  }
  ------------------
  235|  1.48k|  PARSE_REPEATED_STRING(user_defined_symbols);
  ------------------
  |  |   39|  1.48k|  if (name == #param_name) {                             \
  |  |  ------------------
  |  |  |  Branch (39:7): [True: 0, False: 1.48k]
  |  |  ------------------
  |  |   40|      0|    for (const auto& val : util::StrSplitAsCSV(value)) { \
  |  |  ------------------
  |  |  |  Branch (40:26): [True: 0, False: 0]
  |  |  ------------------
  |  |   41|      0|      message->add_##param_name(val);                    \
  |  |   42|      0|    }                                                    \
  |  |   43|      0|    return absl::OkStatus();                             \
  |  |   44|      0|  }
  ------------------
  236|  1.48k|  PARSE_STRING(required_chars);
  ------------------
  |  |   33|  1.48k|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (33:7): [True: 0, False: 1.48k]
  |  |  ------------------
  |  |   34|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   35|      0|    return absl::OkStatus();                               \
  |  |   36|      0|  }
  ------------------
  237|  1.48k|  PARSE_BOOL(byte_fallback);
  ------------------
  |  |   83|  1.48k|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 1.48k, False: 0]
  |  |  ------------------
  |  |   84|  1.48k|    bool v;                                                          \
  |  |   85|  1.48k|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 1.48k]
  |  |  |  Branch (85:27): [True: 0, False: 1.48k]
  |  |  ------------------
  |  |   86|  1.48k|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|  1.48k|    message->set_##param_name(v);                                    \
  |  |   89|  1.48k|    return absl::OkStatus();                                         \
  |  |   90|  1.48k|  }
  ------------------
  238|      0|  PARSE_BOOL(hard_vocab_limit);
  ------------------
  |  |   83|      0|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   84|      0|    bool v;                                                          \
  |  |   85|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 0]
  |  |  |  Branch (85:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   86|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|      0|    message->set_##param_name(v);                                    \
  |  |   89|      0|    return absl::OkStatus();                                         \
  |  |   90|      0|  }
  ------------------
  239|      0|  PARSE_BOOL(vocabulary_output_piece_score);
  ------------------
  |  |   83|      0|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   84|      0|    bool v;                                                          \
  |  |   85|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 0]
  |  |  |  Branch (85:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   86|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|      0|    message->set_##param_name(v);                                    \
  |  |   89|      0|    return absl::OkStatus();                                         \
  |  |   90|      0|  }
  ------------------
  240|      0|  PARSE_BOOL(train_extremely_large_corpus);
  ------------------
  |  |   83|      0|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   84|      0|    bool v;                                                          \
  |  |   85|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 0]
  |  |  |  Branch (85:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   86|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|      0|    message->set_##param_name(v);                                    \
  |  |   89|      0|    return absl::OkStatus();                                         \
  |  |   90|      0|  }
  ------------------
  241|      0|  PARSE_STRING(seed_sentencepieces_file);
  ------------------
  |  |   33|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (33:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   34|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   35|      0|    return absl::OkStatus();                               \
  |  |   36|      0|  }
  ------------------
  242|      0|  PARSE_BOOL(use_all_vocab);
  ------------------
  |  |   83|      0|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   84|      0|    bool v;                                                          \
  |  |   85|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 0]
  |  |  |  Branch (85:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   86|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|      0|    message->set_##param_name(v);                                    \
  |  |   89|      0|    return absl::OkStatus();                                         \
  |  |   90|      0|  }
  ------------------
  243|      0|  PARSE_INT32(unk_id);
  ------------------
  |  |   53|      0|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (53:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   54|      0|    int32_t v;                                                       \
  |  |   55|      0|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (55:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   56|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   57|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   58|      0|    message->set_##param_name(v);                                    \
  |  |   59|      0|    return absl::OkStatus();                                         \
  |  |   60|      0|  }
  ------------------
  244|      0|  PARSE_INT32(bos_id);
  ------------------
  |  |   53|      0|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (53:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   54|      0|    int32_t v;                                                       \
  |  |   55|      0|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (55:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   56|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   57|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   58|      0|    message->set_##param_name(v);                                    \
  |  |   59|      0|    return absl::OkStatus();                                         \
  |  |   60|      0|  }
  ------------------
  245|      0|  PARSE_INT32(eos_id);
  ------------------
  |  |   53|      0|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (53:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   54|      0|    int32_t v;                                                       \
  |  |   55|      0|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (55:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   56|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   57|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   58|      0|    message->set_##param_name(v);                                    \
  |  |   59|      0|    return absl::OkStatus();                                         \
  |  |   60|      0|  }
  ------------------
  246|      0|  PARSE_INT32(pad_id);
  ------------------
  |  |   53|      0|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (53:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   54|      0|    int32_t v;                                                       \
  |  |   55|      0|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (55:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   56|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   57|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   58|      0|    message->set_##param_name(v);                                    \
  |  |   59|      0|    return absl::OkStatus();                                         \
  |  |   60|      0|  }
  ------------------
  247|      0|  PARSE_STRING(unk_piece);
  ------------------
  |  |   33|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (33:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   34|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   35|      0|    return absl::OkStatus();                               \
  |  |   36|      0|  }
  ------------------
  248|      0|  PARSE_STRING(bos_piece);
  ------------------
  |  |   33|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (33:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   34|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   35|      0|    return absl::OkStatus();                               \
  |  |   36|      0|  }
  ------------------
  249|      0|  PARSE_STRING(eos_piece);
  ------------------
  |  |   33|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (33:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   34|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   35|      0|    return absl::OkStatus();                               \
  |  |   36|      0|  }
  ------------------
  250|      0|  PARSE_STRING(pad_piece);
  ------------------
  |  |   33|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (33:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   34|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   35|      0|    return absl::OkStatus();                               \
  |  |   36|      0|  }
  ------------------
  251|      0|  PARSE_STRING(unk_surface);
  ------------------
  |  |   33|      0|  if (name == #param_name) {                               \
  |  |  ------------------
  |  |  |  Branch (33:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   34|      0|    message->set_##param_name(value.data(), value.size()); \
  |  |   35|      0|    return absl::OkStatus();                               \
  |  |   36|      0|  }
  ------------------
  252|      0|  PARSE_BOOL(enable_differential_privacy);
  ------------------
  |  |   83|      0|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (83:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   84|      0|    bool v;                                                          \
  |  |   85|      0|    if (!absl::SimpleAtob(value.empty() ? "true" : value, &v))       \
  |  |  ------------------
  |  |  |  Branch (85:9): [True: 0, False: 0]
  |  |  |  Branch (85:27): [True: 0, False: 0]
  |  |  ------------------
  |  |   86|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   87|      0|             << "cannot parse \"" << value << "\" as bool.";         \
  |  |   88|      0|    message->set_##param_name(v);                                    \
  |  |   89|      0|    return absl::OkStatus();                                         \
  |  |   90|      0|  }
  ------------------
  253|      0|  PARSE_DOUBLE(differential_privacy_noise_level);
  ------------------
  |  |   73|      0|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (73:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   74|      0|    double v;                                                        \
  |  |   75|      0|    if (!absl::SimpleAtod(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (75:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   76|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   77|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   78|      0|    message->set_##param_name(v);                                    \
  |  |   79|      0|    return absl::OkStatus();                                         \
  |  |   80|      0|  }
  ------------------
  254|      0|  PARSE_UINT64(differential_privacy_clipping_threshold);
  ------------------
  |  |   63|      0|  if (name == #param_name) {                                         \
  |  |  ------------------
  |  |  |  Branch (63:7): [True: 0, False: 0]
  |  |  ------------------
  |  |   64|      0|    uint64_t v;                                                      \
  |  |   65|      0|    if (!absl::SimpleAtoi(value, &v))                                \
  |  |  ------------------
  |  |  |  Branch (65:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   66|      0|      return absl::StatusBuilder(absl::StatusCode::kInvalidArgument) \
  |  |   67|      0|             << "cannot parse \"" << value << "\" as int.";          \
  |  |   68|      0|    message->set_##param_name(v);                                    \
  |  |   69|      0|    return absl::OkStatus();                                         \
  |  |   70|      0|  }
  ------------------
  255|       |
  256|      0|  return absl::StatusBuilder(absl::StatusCode::kNotFound)
  257|      0|         << "unknown field name \"" << name << "\" in TrainerSpec.";
  258|      0|}
_ZN13sentencepiece10PrintProtoERKNS_11TrainerSpecENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  118|  8.54k|                              absl::string_view name) {
  119|  8.54k|  std::ostringstream os;
  120|       |
  121|  8.54k|  os << name << " {\n";
  122|       |
  123|  8.54k|  PRINT_REPEATED_STRING(input);
  ------------------
  |  |  107|  8.54k|  for (const auto& v : message.param_name()) \
  |  |  ------------------
  |  |  |  Branch (107:22): [True: 0, False: 8.54k]
  |  |  ------------------
  |  |  108|  8.54k|    os << "  " << #param_name << ": " << v << "\n";
  ------------------
  124|  8.54k|  PRINT_PARAM(input_format);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  125|  8.54k|  PRINT_PARAM(model_prefix);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  126|       |
  127|  8.54k|  static const std::map<TrainerSpec::ModelType, std::string> kModelType_Map = {
  128|  8.54k|      {TrainerSpec::UNIGRAM, "UNIGRAM"},
  129|  8.54k|      {TrainerSpec::BPE, "BPE"},
  130|  8.54k|      {TrainerSpec::WORD, "WORD"},
  131|  8.54k|      {TrainerSpec::CHAR, "CHAR"},
  132|  8.54k|  };
  133|       |
  134|  8.54k|  PRINT_ENUM(model_type, kModelType_Map);
  ------------------
  |  |  111|  8.54k|  const auto it = map_name.find(message.param_name()); \
  |  |  112|  8.54k|  if (it == map_name.end())                            \
  |  |  ------------------
  |  |  |  Branch (112:7): [True: 0, False: 8.54k]
  |  |  ------------------
  |  |  113|  8.54k|    os << "  " << #param_name << ": unknown\n";        \
  |  |  114|  8.54k|  else                                                 \
  |  |  115|  8.54k|    os << "  " << #param_name << ": " << it->second << "\n";
  ------------------
  135|  8.54k|  PRINT_PARAM(vocab_size);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  136|  8.54k|  PRINT_REPEATED_STRING(accept_language);
  ------------------
  |  |  107|  8.54k|  for (const auto& v : message.param_name()) \
  |  |  ------------------
  |  |  |  Branch (107:22): [True: 0, False: 8.54k]
  |  |  ------------------
  |  |  108|  8.54k|    os << "  " << #param_name << ": " << v << "\n";
  ------------------
  137|  8.54k|  PRINT_PARAM(self_test_sample_size);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  138|  8.54k|  PRINT_PARAM(character_coverage);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  139|  8.54k|  PRINT_PARAM(input_sentence_size);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  140|  8.54k|  PRINT_PARAM(shuffle_input_sentence);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  141|  8.54k|  PRINT_PARAM(seed_sentencepiece_size);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  142|  8.54k|  PRINT_PARAM(shrinking_factor);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  143|  8.54k|  PRINT_PARAM(max_sentence_length);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  144|  8.54k|  PRINT_PARAM(num_threads);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  145|  8.54k|  PRINT_PARAM(num_sub_iterations);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  146|  8.54k|  PRINT_PARAM(max_sentencepiece_length);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  147|  8.54k|  PRINT_PARAM(split_by_unicode_script);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  148|  8.54k|  PRINT_PARAM(split_by_number);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  149|  8.54k|  PRINT_PARAM(split_by_whitespace);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  150|  8.54k|  PRINT_PARAM(split_digits);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  151|  8.54k|  PRINT_PARAM(pretokenization_delimiter);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  152|  8.54k|  PRINT_PARAM(treat_whitespace_as_suffix);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  153|  8.54k|  PRINT_PARAM(allow_whitespace_only_pieces);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  154|  8.54k|  PRINT_REPEATED_STRING(control_symbols);
  ------------------
  |  |  107|  8.54k|  for (const auto& v : message.param_name()) \
  |  |  ------------------
  |  |  |  Branch (107:22): [True: 0, False: 8.54k]
  |  |  ------------------
  |  |  108|  8.54k|    os << "  " << #param_name << ": " << v << "\n";
  ------------------
  155|  8.54k|  PRINT_REPEATED_STRING(user_defined_symbols);
  ------------------
  |  |  107|  8.54k|  for (const auto& v : message.param_name()) \
  |  |  ------------------
  |  |  |  Branch (107:22): [True: 0, False: 8.54k]
  |  |  ------------------
  |  |  108|  8.54k|    os << "  " << #param_name << ": " << v << "\n";
  ------------------
  156|  8.54k|  PRINT_PARAM(required_chars);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  157|  8.54k|  PRINT_PARAM(byte_fallback);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  158|  8.54k|  PRINT_PARAM(vocabulary_output_piece_score);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  159|  8.54k|  PRINT_PARAM(train_extremely_large_corpus);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  160|  8.54k|  PRINT_PARAM(seed_sentencepieces_file);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  161|  8.54k|  PRINT_PARAM(hard_vocab_limit);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  162|  8.54k|  PRINT_PARAM(use_all_vocab);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  163|  8.54k|  PRINT_PARAM(unk_id);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  164|  8.54k|  PRINT_PARAM(bos_id);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  165|  8.54k|  PRINT_PARAM(eos_id);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  166|  8.54k|  PRINT_PARAM(pad_id);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  167|  8.54k|  PRINT_PARAM(unk_piece);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  168|  8.54k|  PRINT_PARAM(bos_piece);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  169|  8.54k|  PRINT_PARAM(eos_piece);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  170|  8.54k|  PRINT_PARAM(pad_piece);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  171|  8.54k|  PRINT_PARAM(unk_surface);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  172|  8.54k|  PRINT_PARAM(enable_differential_privacy);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  173|  8.54k|  PRINT_PARAM(differential_privacy_noise_level);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  174|  8.54k|  PRINT_PARAM(differential_privacy_clipping_threshold);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  175|       |
  176|  8.54k|  os << "}\n";
  177|       |
  178|  8.54k|  return os.str();
  179|  8.54k|}
_ZN13sentencepiece10PrintProtoERKNS_14NormalizerSpecENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
  182|  8.54k|                              absl::string_view name) {
  183|  8.54k|  std::ostringstream os;
  184|       |
  185|  8.54k|  os << name << " {\n";
  186|       |
  187|  8.54k|  PRINT_PARAM(name);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  188|  8.54k|  PRINT_PARAM(add_dummy_prefix);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  189|  8.54k|  PRINT_PARAM(remove_extra_whitespaces);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  190|  8.54k|  PRINT_PARAM(escape_whitespaces);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  191|  8.54k|  PRINT_PARAM(normalization_rule_tsv);
  ------------------
  |  |  104|  8.54k|  os << "  " << #param_name << ": " << message.param_name() << "\n";
  ------------------
  192|       |
  193|  8.54k|  os << "}\n";
  194|       |
  195|  8.54k|  return os.str();
  196|  8.54k|}

_ZN13sentencepiece14TrainerFactory6CreateERKNS_11TrainerSpecERKNS_14NormalizerSpecES6_:
   27|  8.54k|    const NormalizerSpec &denormalizer_spec) {
   28|  8.54k|  switch (trainer_spec.model_type()) {
   29|  5.91k|    case TrainerSpec::UNIGRAM:
  ------------------
  |  Branch (29:5): [True: 5.91k, False: 2.63k]
  ------------------
   30|  5.91k|      return std::make_unique<unigram::Trainer>(trainer_spec, normalizer_spec,
   31|  5.91k|                                                denormalizer_spec);
   32|      0|      break;
   33|  1.44k|    case TrainerSpec::BPE:
  ------------------
  |  Branch (33:5): [True: 1.44k, False: 7.10k]
  ------------------
   34|  1.44k|      return std::make_unique<bpe::Trainer>(trainer_spec, normalizer_spec,
   35|  1.44k|                                            denormalizer_spec);
   36|      0|      break;
   37|    933|    case TrainerSpec::WORD:
  ------------------
  |  Branch (37:5): [True: 933, False: 7.61k]
  ------------------
   38|    933|      return std::make_unique<word::Trainer>(trainer_spec, normalizer_spec,
   39|    933|                                             denormalizer_spec);
   40|      0|      break;
   41|    260|    case TrainerSpec::CHAR:
  ------------------
  |  Branch (41:5): [True: 260, False: 8.28k]
  ------------------
   42|    260|      return std::make_unique<character::Trainer>(trainer_spec, normalizer_spec,
   43|    260|                                                  denormalizer_spec);
   44|      0|      break;
   45|      0|    default:
  ------------------
  |  Branch (45:5): [True: 0, False: 8.54k]
  ------------------
   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|  8.54k|  }
   49|       |
   50|      0|  return std::make_unique<unigram::Trainer>(trainer_spec, normalizer_spec,
   51|      0|                                            denormalizer_spec);
   52|  8.54k|}

_ZN13sentencepiece16TrainerInterfaceC2ENS_11TrainerSpecENS_14NormalizerSpecES2_:
  211|  8.54k|    : trainer_spec_(std::move(trainer_spec)),
  212|  8.54k|      normalizer_spec_(std::move(normalizer_spec)),
  213|  8.54k|      denormalizer_spec_(std::move(denormalizer_spec)) {
  214|  8.54k|  status_ = VerifySpec(trainer_spec_);
  215|  8.54k|  if (status_.ok()) {
  ------------------
  |  Branch (215:7): [True: 8.53k, False: 6]
  ------------------
  216|  8.53k|    status_ = InitMetaPieces();
  217|  8.53k|  }
  218|  8.54k|}
_ZN13sentencepiece16TrainerInterfaceD2Ev:
  220|  8.54k|TrainerInterface::~TrainerInterface() = default;
_ZNK13sentencepiece16TrainerInterface20IsValidSentencePieceERKNSt3__16vectorIDiNS1_9allocatorIDiEEEE:
  223|  11.3M|    const string_util::UnicodeText& sentencepiece) const {
  224|       |  // Returns false if the length of piece is invalid.
  225|  11.3M|  if (sentencepiece.empty() ||
  ------------------
  |  Branch (225:7): [True: 0, False: 11.3M]
  ------------------
  226|  11.3M|      sentencepiece.size() >
  ------------------
  |  Branch (226:7): [True: 2.35M, False: 8.98M]
  ------------------
  227|  11.3M|          static_cast<size_t>(trainer_spec_.max_sentencepiece_length())) {
  228|  2.35M|    return false;
  229|  2.35M|  }
  230|       |
  231|  8.98M|  constexpr auto kAnyType = static_cast<unicode_script::ScriptType>(
  232|  8.98M|      std::numeric_limits<char32_t>::max());
  233|       |
  234|  8.98M|  unicode_script::ScriptType prev_script = kAnyType;
  235|  8.98M|  bool all_whitespace_piece =
  236|  8.98M|      std::all_of(sentencepiece.begin(), sentencepiece.end(),
  237|  8.98M|                  [](char32_t c) { return c == kWSChar; });
  238|       |
  239|  54.7M|  for (size_t pos = 0; pos < sentencepiece.size(); ++pos) {
  ------------------
  |  Branch (239:24): [True: 47.5M, False: 7.15M]
  ------------------
  240|  47.5M|    const char32_t c = sentencepiece[pos];
  241|  47.5M|    if (c == kUNKChar) {  // UNK must not be included
  ------------------
  |  Branch (241:9): [True: 813k, False: 46.7M]
  ------------------
  242|   813k|      return false;
  243|   813k|    }
  244|  46.7M|    if (c == 0x0000) {  // NULL is not allowed for Darts (TRIE).
  ------------------
  |  Branch (244:9): [True: 0, False: 46.7M]
  ------------------
  245|      0|      return false;
  246|      0|    }
  247|       |    // kUPPBoundaryChar is included when split_by_upp_for_training is true.
  248|  46.7M|    if (c == kUPPBoundaryChar) {
  ------------------
  |  Branch (248:9): [True: 0, False: 46.7M]
  ------------------
  249|      0|      return false;
  250|      0|    }
  251|  46.7M|    if (c == 0x0020) {
  ------------------
  |  Branch (251:9): [True: 0, False: 46.7M]
  ------------------
  252|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  253|      0|      return false;
  254|      0|    }
  255|  46.7M|    if (!string_util::IsValidCodepoint(c)) {
  ------------------
  |  Branch (255:9): [True: 0, False: 46.7M]
  ------------------
  256|      0|      return false;
  257|      0|    }
  258|       |
  259|  46.7M|    if (c == kWSChar) {
  ------------------
  |  Branch (259:9): [True: 6.41M, False: 40.3M]
  ------------------
  260|       |      // Only allows whitespace to appear as a prefix of piece unless
  261|       |      // allow_whitespace_only_pieces is True.
  262|       |      // When split_by_whitespace is false, we allow whitespaces to
  263|       |      // appear in the middle, "foo_bar", but do not allow them
  264|       |      // to appear as suffix, "foo_bar_".
  265|       |      // Regardless of the setting of split_by_whitespace,
  266|       |      // whitespace is treated as a prefix/infix of symbol or
  267|       |      // independent symbol, unless allow_whitespace_only_pieces() is true,
  268|       |      // in which case whitespace only pieces can occur.
  269|  6.41M|      if (!trainer_spec_.allow_whitespace_only_pieces() ||
  ------------------
  |  Branch (269:11): [True: 6.41M, False: 0]
  ------------------
  270|  6.41M|          !all_whitespace_piece) {
  ------------------
  |  Branch (270:11): [True: 0, False: 0]
  ------------------
  271|  6.41M|        if (trainer_spec_.treat_whitespace_as_suffix()) {
  ------------------
  |  Branch (271:13): [True: 0, False: 6.41M]
  ------------------
  272|      0|          if ((trainer_spec_.split_by_whitespace() &&
  ------------------
  |  Branch (272:16): [True: 0, False: 0]
  ------------------
  273|      0|               pos < sentencepiece.size() - 1) ||
  ------------------
  |  Branch (273:16): [True: 0, False: 0]
  ------------------
  274|      0|              (!trainer_spec_.split_by_whitespace() &&
  ------------------
  |  Branch (274:16): [True: 0, False: 0]
  ------------------
  275|      0|               pos < sentencepiece.size() - 1 && pos == 0)) {
  ------------------
  |  Branch (275:16): [True: 0, False: 0]
  |  Branch (275:50): [True: 0, False: 0]
  ------------------
  276|      0|            return false;
  277|      0|          }
  278|  6.41M|        } else {
  279|  6.41M|          if ((trainer_spec_.split_by_whitespace() && pos > 0) ||
  ------------------
  |  Branch (279:16): [True: 6.37M, False: 43.9k]
  |  Branch (279:55): [True: 0, False: 6.37M]
  ------------------
  280|  6.41M|              (!trainer_spec_.split_by_whitespace() && pos > 0 &&
  ------------------
  |  Branch (280:16): [True: 43.9k, False: 6.37M]
  |  Branch (280:56): [True: 32.7k, False: 11.2k]
  ------------------
  281|  32.7k|               pos == sentencepiece.size() - 1)) {
  ------------------
  |  Branch (281:16): [True: 25.4k, False: 7.23k]
  ------------------
  282|  25.4k|            return false;
  283|  25.4k|          }
  284|  6.41M|        }
  285|  6.41M|      }
  286|  40.3M|    } else {
  287|  40.3M|      auto s = unicode_script::GetScript(c);
  288|       |
  289|       |      // Merge Hiragana/Katakana into Han.
  290|  40.3M|      if (s == unicode_script::U_Hiragana || s == unicode_script::U_Katakana ||
  ------------------
  |  Branch (290:11): [True: 758, False: 40.3M]
  |  Branch (290:46): [True: 687, False: 40.3M]
  ------------------
  291|  40.3M|          c == 0x30FC) {  // long vowel sound (Katakana) should be Katakana
  ------------------
  |  Branch (291:11): [True: 1.15k, False: 40.3M]
  ------------------
  292|  2.60k|        s = unicode_script::U_Han;
  293|  40.3M|      } else if (s == unicode_script::U_Inherited) {
  ------------------
  |  Branch (293:18): [True: 8.75k, False: 40.3M]
  ------------------
  294|  8.75k|        s = prev_script;
  295|  8.75k|      }
  296|       |
  297|  40.3M|      if (!trainer_spec_.split_by_number() && is_unicode_decimal_number(c)) {
  ------------------
  |  Branch (297:11): [True: 7.36M, False: 32.9M]
  |  Branch (297:47): [True: 2.78M, False: 4.57M]
  ------------------
  298|  2.78M|        s = kAnyType;
  299|  2.78M|      }
  300|       |
  301|  40.3M|      if (trainer_spec_.split_digits() && is_unicode_decimal_number(c)) {
  ------------------
  |  Branch (301:11): [True: 0, False: 40.3M]
  |  Branch (301:43): [True: 0, False: 0]
  ------------------
  302|      0|        if (sentencepiece.size() > 1) {
  ------------------
  |  Branch (302:13): [True: 0, False: 0]
  ------------------
  303|      0|          return false;
  304|      0|        }
  305|      0|      }
  306|       |
  307|       |      // Do not allow a piece to include multiple Unicode scripts
  308|       |      // when split_by_unicode_script() is true (default = true).
  309|  40.3M|      if (trainer_spec_.split_by_unicode_script() && s != kAnyType &&
  ------------------
  |  Branch (309:11): [True: 19.0M, False: 21.2M]
  |  Branch (309:54): [True: 18.3M, False: 684k]
  ------------------
  310|  18.3M|          prev_script != kAnyType && prev_script != s) {
  ------------------
  |  Branch (310:11): [True: 13.9M, False: 4.44M]
  |  Branch (310:38): [True: 986k, False: 12.9M]
  ------------------
  311|   986k|        return false;
  312|   986k|      }
  313|       |
  314|  39.3M|      prev_script = s;
  315|  39.3M|    }
  316|  46.7M|  }
  317|  7.15M|  return true;
  318|  8.98M|}
_ZN13sentencepiece16TrainerInterface13LoadSentencesEv:
  335|  8.53k|absl::Status TrainerInterface::LoadSentences() {
  336|  8.53k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  8.53k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  8.53k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  17.0k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  17.0k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  17.0k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 8.53k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  8.53k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 8.53k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  17.0k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 8.53k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  17.0k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  17.0k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  8.53k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  17.0k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  337|  8.53k|  RET_CHECK(sentences_.empty());
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  338|  8.53k|  RET_CHECK(required_chars_.empty());
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  339|  8.53k|  RET_CHECK(trainer_spec_.input_format().empty() ||
  ------------------
  |  |  285|  25.6k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  340|      0|            trainer_spec_.input_format() == "text" ||
  341|      0|            trainer_spec_.input_format() == "tsv")
  342|      0|      << "Supported formats are 'text' and 'tsv'.";
  343|       |
  344|  8.53k|  RET_CHECK((sentence_iterator_ != nullptr && trainer_spec_.input().empty()) ||
  ------------------
  |  |  285|  34.1k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  345|      0|            (sentence_iterator_ == nullptr && !trainer_spec_.input().empty()))
  346|      0|      << "SentenceIterator and trainer_spec.input() must be exclusive.";
  347|       |
  348|  8.53k|  RET_CHECK(
  ------------------
  |  |  285|  34.1k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  349|      0|      (output_model_proto_ != nullptr &&
  350|      0|       trainer_spec_.model_prefix().empty()) ||
  351|      0|      (output_model_proto_ == nullptr && !trainer_spec_.model_prefix().empty()))
  352|      0|      << "ModelProto and trainer_spec.model_prefix() must be exclusive.";
  353|       |
  354|  8.53k|  const bool is_tsv = trainer_spec_.input_format() == "tsv";
  355|       |
  356|  8.53k|  SentenceSelector selector(&sentences_, trainer_spec_);
  357|  8.53k|  random::ReservoirSampler<std::string> test_sentence_sampler(
  358|  8.53k|      &self_test_samples_, trainer_spec_.self_test_sample_size());
  359|       |
  360|  8.53k|  int too_long_lines = 0;
  361|       |
  362|  8.53k|  std::unique_ptr<SentenceIterator> sentence_iterator_impl;
  363|  8.53k|  if (sentence_iterator_ == nullptr) {
  ------------------
  |  Branch (363:7): [True: 0, False: 8.53k]
  ------------------
  364|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  365|      0|                 "MultiFileSentenceIterator.";
  366|      0|    sentence_iterator_impl =
  367|      0|        std::make_unique<MultiFileSentenceIterator>(std::vector<std::string>(
  368|      0|            trainer_spec_.input().begin(), trainer_spec_.input().end()));
  369|      0|    sentence_iterator_ = sentence_iterator_impl.get();
  370|      0|  }
  371|       |
  372|  67.7k|  for (; !sentence_iterator_->done(); sentence_iterator_->Next()) {
  ------------------
  |  Branch (372:10): [True: 59.2k, False: 8.53k]
  ------------------
  373|  59.2k|    int64_t freq = 1;
  374|  59.2k|    std::string sentence = sentence_iterator_->value();
  375|       |
  376|  59.2k|    if (is_tsv) {
  ------------------
  |  Branch (376:9): [True: 0, False: 59.2k]
  ------------------
  377|      0|      const std::vector<std::string> v = absl::StrSplit(sentence, '\t');
  378|      0|      RET_CHECK_EQ(v.size(), 2)
  ------------------
  |  |  290|      0|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  285|      0|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|      0|  } else /* NOLINT */                                         \
  |  |  |  |  287|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  379|      0|          << "Input format must be: word <tab> freq. " << sentence;
  380|      0|      sentence = v[0];
  381|      0|      RET_CHECK(absl::SimpleAtoi(v[1], &freq))
  ------------------
  |  |  285|      0|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|  } else /* NOLINT */                                         \
  |  |  287|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  382|      0|          << "Could not parse the frequency";
  383|      0|      RET_CHECK_GE(freq, 1);
  ------------------
  |  |  292|      0|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  285|      0|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|      0|  } else /* NOLINT */                                         \
  |  |  |  |  287|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  384|      0|    }
  385|       |
  386|  59.2k|    if (sentence.empty()) {
  ------------------
  |  Branch (386:9): [True: 0, False: 59.2k]
  ------------------
  387|      0|      continue;
  388|      0|    }
  389|       |
  390|  59.2k|    if (static_cast<int>(sentence.size()) >
  ------------------
  |  Branch (390:9): [True: 0, False: 59.2k]
  ------------------
  391|  59.2k|        trainer_spec_.max_sentence_length()) {
  392|      0|      if (too_long_lines == 0) {
  ------------------
  |  Branch (392:11): [True: 0, False: 0]
  ------------------
  393|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  394|      0|                     << trainer_spec_.max_sentence_length() << ").";
  395|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  396|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  397|      0|                        "--max_sentence_length=<size> flag.";
  398|      0|      }
  399|      0|      ++too_long_lines;
  400|      0|      continue;
  401|      0|    }
  402|       |
  403|  59.2k|    if (sentence.find(kUNKStr) != std::string::npos) {
  ------------------
  |  Branch (403:9): [True: 270, False: 58.9k]
  ------------------
  404|    810|      LOG(INFO) << "Reserved chars are found. Skipped: " << sentence;
  ------------------
  |  |  218|    270|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|    270|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|    270|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|    540|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|    540|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 270, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|    270|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 270]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|    270|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 270]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|    270|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|    810|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|    810|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  405|    270|      continue;
  406|    270|    }
  407|       |
  408|  58.9k|    test_sentence_sampler.Add(sentence);
  409|       |
  410|  58.9k|    if (!selector.Add(std::make_pair(sentence, freq))) {
  ------------------
  |  Branch (410:9): [True: 0, False: 58.9k]
  ------------------
  411|      0|      goto END;
  412|      0|    }
  413|  58.9k|  }
  414|       |
  415|  8.53k|  RETURN_IF_ERROR(sentence_iterator_->status());
  ------------------
  |  |   44|  8.53k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  8.53k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  25.6k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  17.0k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  17.0k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 8.53k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  8.53k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 8.53k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  25.6k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 8.53k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  25.6k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  25.6k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  8.53k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  25.6k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  416|       |
  417|  8.53k|END:
  418|       |  // Emits error message if any.
  419|  8.53k|  selector.Finish();
  420|       |
  421|  8.53k|  if (sentences_.size() == selector.total_size()) {
  ------------------
  |  Branch (421:7): [True: 8.53k, False: 0]
  ------------------
  422|  25.6k|    LOG(INFO) << "Loaded all " << sentences_.size() << " sentences";
  ------------------
  |  |  218|  8.53k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  8.53k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  8.53k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  17.0k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  17.0k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 8.53k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  8.53k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 8.53k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  8.53k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 8.53k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  8.53k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  34.1k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  34.1k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  423|  8.53k|  } else {
  424|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  425|      0|              << selector.total_size() << " sentences.";
  426|      0|  }
  427|       |
  428|  8.53k|  if (too_long_lines > 0) {
  ------------------
  |  Branch (428:7): [True: 0, False: 8.53k]
  ------------------
  429|      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|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  430|      0|  }
  431|  8.53k|  if (!self_test_samples_.empty()) {
  ------------------
  |  Branch (431:7): [True: 0, False: 8.53k]
  ------------------
  432|      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|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  433|      0|  }
  434|       |
  435|       |  // Normalize and removes empty string.
  436|  8.53k|  {
  437|  8.53k|    const normalizer::Normalizer normalizer(normalizer_spec_, trainer_spec_);
  438|  8.53k|    std::set<absl::string_view> meta_pieces_set;
  439|  43.0k|    for (const auto& it : meta_pieces_) {
  ------------------
  |  Branch (439:25): [True: 43.0k, False: 8.53k]
  ------------------
  440|   129k|      LOG(INFO) << "Adding meta_piece: " << it.second.first;
  ------------------
  |  |  218|  43.0k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  43.0k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  43.0k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  86.0k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  86.0k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 43.0k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  43.0k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 43.0k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  43.0k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 43.0k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  43.0k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|   129k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|   129k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  441|  43.0k|      meta_pieces_set.insert(it.second.first);
  442|  43.0k|    }
  443|  8.53k|    const normalizer::PrefixMatcher meta_pieces_matcher(meta_pieces_set);
  444|       |
  445|  25.6k|    LOG(INFO) << "Normalizing sentences...";
  ------------------
  |  |  218|  8.53k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  8.53k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  8.53k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  17.0k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  17.0k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 8.53k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  8.53k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 8.53k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  8.53k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 8.53k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  8.53k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  17.0k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  17.0k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  446|  8.53k|    RET_CHECK(!sentences_.empty());
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.52k, False: 10]
  |  |  ------------------
  |  |  286|  8.52k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|     10|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  447|  8.52k|    {
  448|  8.52k|      auto pool = std::make_unique<ThreadPool>(trainer_spec_.num_threads());
  449|  17.0k|      for (int n = 0; n < trainer_spec_.num_threads(); ++n) {
  ------------------
  |  Branch (449:23): [True: 8.52k, False: 8.52k]
  ------------------
  450|  8.52k|        pool->Schedule([&, n] {
  451|  8.52k|          for (size_t i = n; i < sentences_.size();
  452|  8.52k|               i += trainer_spec_.num_threads()) {
  453|  8.52k|            auto* s = &sentences_[i].first;
  454|  8.52k|            *s = meta_pieces_matcher.GlobalReplace(normalizer.Normalize(*s),
  455|  8.52k|                                                   kUPPBoundaryStr);
  456|  8.52k|          }
  457|  8.52k|        });
  458|  8.52k|      }
  459|  8.52k|    }
  460|       |
  461|  66.9k|    for (size_t i = 0; i < sentences_.size(); ++i) {
  ------------------
  |  Branch (461:24): [True: 58.4k, False: 8.52k]
  ------------------
  462|  58.4k|      auto* s = &sentences_[i].first;
  463|  58.4k|      RET_CHECK(s->find(" ") == std::string::npos)
  ------------------
  |  |  285|  58.4k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 58.4k, False: 0]
  |  |  ------------------
  |  |  286|  58.4k|  } else /* NOLINT */                                         \
  |  |  287|  58.4k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  464|      0|          << "Normalized string must not include spaces";
  465|  58.4k|      if (s->empty()) {
  ------------------
  |  Branch (465:11): [True: 570, False: 57.8k]
  ------------------
  466|    570|        std::swap(sentences_[i], sentences_[sentences_.size() - 1]);
  467|    570|        sentences_.resize(sentences_.size() - 1);
  468|    570|      }
  469|  58.4k|    }
  470|  8.52k|  }
  471|       |
  472|       |  // If DP is required, add the noise/clip the input.
  473|  8.52k|  if (trainer_spec_.enable_differential_privacy()) {
  ------------------
  |  Branch (473:7): [True: 0, False: 8.52k]
  ------------------
  474|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  475|      0|    if (trainer_spec_.input_format() != "tsv") {
  ------------------
  |  Branch (475:9): [True: 0, False: 0]
  ------------------
  476|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  477|      0|          << "Dp version will not work correctly with text input format.";
  478|      0|    }
  479|      0|    if (trainer_spec_.differential_privacy_noise_level() <= 0) {
  ------------------
  |  Branch (479:9): [True: 0, False: 0]
  ------------------
  480|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  481|      0|                      "infinity epsilon guarantees.";
  482|      0|    }
  483|      0|    if (trainer_spec_.differential_privacy_clipping_threshold() <= 0) {
  ------------------
  |  Branch (483:9): [True: 0, False: 0]
  ------------------
  484|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  485|      0|                      "infinity epsilon guarantees.";
  486|      0|    }
  487|       |
  488|       |    // Add noise to all the sentences via threadpool.
  489|       |
  490|       |    // This line is mainly for tests with small num of sentences.
  491|      0|    const auto num_workers =
  492|      0|        std::min<uint64_t>(trainer_spec_.num_threads(), sentences_.size() - 1);
  493|       |
  494|      0|    {
  495|      0|      auto pool = std::make_unique<ThreadPool>(num_workers);
  496|      0|      for (size_t n = 0; n < num_workers; ++n) {
  ------------------
  |  Branch (496:26): [True: 0, False: 0]
  ------------------
  497|      0|        pool->Schedule([&, n] {
  498|       |          // One per thread generator.
  499|      0|          auto* generator = random::GetRandomGenerator();
  500|      0|          for (size_t i = n; i < sentences_.size(); i += num_workers) {
  501|      0|            AddDPNoise<int64_t>(trainer_spec_, generator,
  502|      0|                                &sentences_[i].second);
  503|      0|          }
  504|      0|        });
  505|      0|      }
  506|      0|    }
  507|       |
  508|       |    // Remove zero freq elements.
  509|      0|    const auto before_size = sentences_.size();
  510|      0|    auto it = std::remove_if(sentences_.begin(), sentences_.end(),
  511|      0|                             [](const Sentence& s) { return s.second <= 0; });
  512|      0|    const auto new_size = std::distance(sentences_.begin(), it);
  513|      0|    const int num_erased = before_size - new_size;
  514|      0|    sentences_.erase(it, sentences_.end());
  515|       |
  516|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  517|      0|              << " fraction of sentences removed.";
  518|      0|  }
  519|       |
  520|       |  // Count character frequencies.
  521|  8.52k|  int64_t all_chars_count = 0;
  522|       |  // A map from a character to {is_required_char, character count}.
  523|  8.52k|  absl::flat_hash_map<char32_t, std::pair<bool, int64_t>> chars_count;
  524|  8.52k|  for (const char32_t c :
  ------------------
  |  Branch (524:25): [True: 0, False: 8.52k]
  ------------------
  525|  8.52k|       string_util::UTF8ToUnicodeText(trainer_spec_.required_chars())) {
  526|      0|    RET_CHECK(string_util::IsValidCodepoint(c));
  ------------------
  |  |  285|      0|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|  } else /* NOLINT */                                         \
  |  |  287|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  527|      0|    if (c == 0x0000) {
  ------------------
  |  Branch (527:9): [True: 0, False: 0]
  ------------------
  528|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  529|      0|                   "encoded in utf-8.";
  530|      0|      continue;
  531|      0|    }
  532|      0|    chars_count[c].first = true;  // is_required_character.
  533|      0|  }
  534|  58.3k|  for (const auto& w : sentences_) {
  ------------------
  |  Branch (534:22): [True: 58.3k, False: 8.52k]
  ------------------
  535|  9.02M|    for (const char32_t c : string_util::UTF8ToUnicodeText(w.first)) {
  ------------------
  |  Branch (535:27): [True: 9.02M, False: 58.3k]
  ------------------
  536|  9.02M|      if (!string_util::IsValidCodepoint(c)) {
  ------------------
  |  Branch (536:11): [True: 0, False: 9.02M]
  ------------------
  537|      0|        continue;
  538|      0|      }
  539|  9.02M|      if (c == 0x0000) {
  ------------------
  |  Branch (539:11): [True: 428k, False: 8.59M]
  ------------------
  540|  1.28M|        LOG(INFO)
  ------------------
  |  |  218|   428k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|   428k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|   428k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|   857k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|   857k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 428k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|   428k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 428k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|   428k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 428k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|   428k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|   857k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|   857k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  541|  1.28M|            << "Found null character. The corpus must be encoded in utf-8.";
  542|   428k|        continue;
  543|   428k|      }
  544|  8.59M|      if (c == 0x0020) {
  ------------------
  |  Branch (544:11): [True: 0, False: 8.59M]
  ------------------
  545|       |        // UTF8ToUnicodeText returns a white space if the text
  546|       |        // contains an interchange-invalid character.
  547|      0|        RET_CHECK(w.first.find(" ") == std::string::npos)
  ------------------
  |  |  285|      0|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|  } else /* NOLINT */                                         \
  |  |  287|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  548|      0|            << "space must not be included in normalized string.";
  549|      0|        continue;
  550|      0|      }
  551|  8.59M|      chars_count[c].second += w.second;
  552|  8.59M|      all_chars_count += w.second;
  553|  8.59M|    }
  554|  58.3k|  }
  555|  25.5k|  LOG(INFO) << "all chars count=" << all_chars_count;
  ------------------
  |  |  218|  8.52k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  8.52k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  8.52k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  17.0k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  17.0k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 8.52k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  8.52k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 8.52k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  8.52k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 8.52k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  8.52k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  25.5k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  25.5k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  556|       |
  557|       |  // Determines required_chars which must be included in the vocabulary.
  558|  8.52k|  int64_t accumulated_chars_count = 0;
  559|       |  // Sorted() sorts the chars_count values in the decsending order of pair<>.
  560|       |  // I.e. characters are sorted in the order of required characters and then
  561|       |  // frequent characters.
  562|   274k|  for (const auto& w : Sorted(chars_count)) {
  ------------------
  |  Branch (562:22): [True: 274k, False: 6.27k]
  ------------------
  563|   274k|    const float coverage = 1.0 * accumulated_chars_count / all_chars_count;
  564|   274k|    if (!trainer_spec_.use_all_vocab() &&
  ------------------
  |  Branch (564:9): [True: 274k, False: 0]
  ------------------
  565|   274k|        coverage >= trainer_spec_.character_coverage()) {
  ------------------
  |  Branch (565:9): [True: 2.25k, False: 272k]
  ------------------
  566|  6.76k|      LOG(INFO) << "Done: " << 100.0 * coverage << "% characters are covered.";
  ------------------
  |  |  218|  2.25k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  2.25k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  2.25k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  4.50k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  4.50k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 2.25k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  2.25k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 2.25k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  2.25k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 2.25k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  2.25k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  9.01k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  9.01k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  567|  2.25k|      break;
  568|  2.25k|    }
  569|   272k|    accumulated_chars_count += w.second.second;
  570|   272k|    RET_CHECK_NE(w.first, 0x0020)
  ------------------
  |  |  291|   272k|#define RET_CHECK_NE(a, b) RET_CHECK((a) != (b))
  |  |  ------------------
  |  |  |  |  285|   272k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 272k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|   272k|  } else /* NOLINT */                                         \
  |  |  |  |  287|   272k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  571|      0|        << "space must not be included in normalized string.";
  572|   272k|    if (w.first == kUPPBoundaryChar) {
  ------------------
  |  Branch (572:9): [True: 288, False: 272k]
  ------------------
  573|    288|      continue;  // Tab is not included.
  574|    288|    }
  575|   272k|    required_chars_.emplace(w.first, w.second.second);
  576|   272k|  }
  577|       |
  578|  25.5k|  LOG(INFO) << "Alphabet size=" << required_chars_.size();
  ------------------
  |  |  218|  8.52k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  8.52k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  8.52k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  17.0k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  17.0k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 8.52k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  8.52k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 8.52k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  8.52k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 8.52k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  8.52k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  25.5k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  25.5k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  579|  25.5k|  LOG(INFO) << "Final character coverage="
  ------------------
  |  |  218|  8.52k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  8.52k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  8.52k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  17.0k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  17.0k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 8.52k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  8.52k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 8.52k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  8.52k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 8.52k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  8.52k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  25.5k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  25.5k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  580|  25.5k|            << 1.0 * accumulated_chars_count / all_chars_count;
  581|       |
  582|  8.52k|  RET_CHECK(!port::ContainsKey(required_chars_, kUNKChar));
  ------------------
  |  |  285|  8.52k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.52k, False: 0]
  |  |  ------------------
  |  |  286|  8.52k|  } else /* NOLINT */                                         \
  |  |  287|  8.52k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  583|       |
  584|       |  // Replaces rare characters (characters not included in required_chars_)
  585|       |  // with kUNKChar.
  586|  58.3k|  for (auto& w : sentences_) {
  ------------------
  |  Branch (586:16): [True: 58.3k, False: 8.52k]
  ------------------
  587|  58.3k|    string_util::UnicodeText uw2;
  588|  9.02M|    for (const char32_t c : string_util::UTF8ToUnicodeText(w.first)) {
  ------------------
  |  Branch (588:27): [True: 9.02M, False: 58.3k]
  ------------------
  589|  9.02M|      if (port::ContainsKey(required_chars_, c)) {
  ------------------
  |  Branch (589:11): [True: 8.54M, False: 478k]
  ------------------
  590|  8.54M|        uw2.push_back(c);
  591|  8.54M|      } else {
  592|   478k|        uw2.push_back(kUNKChar);
  593|   478k|      }
  594|  9.02M|    }
  595|  58.3k|    w.first = string_util::UnicodeTextToUTF8(uw2);
  596|  58.3k|  }
  597|       |
  598|  8.52k|  if (trainer_spec_.model_type() != TrainerSpec::WORD &&
  ------------------
  |  Branch (598:7): [True: 7.60k, False: 929]
  ------------------
  599|  7.60k|      trainer_spec_.model_type() != TrainerSpec::CHAR) {
  ------------------
  |  Branch (599:7): [True: 7.34k, False: 256]
  ------------------
  600|  7.34k|    RET_CHECK_LE(static_cast<int>(required_chars_.size() + meta_pieces_.size()),
  ------------------
  |  |  293|  7.34k|#define RET_CHECK_LE(a, b) RET_CHECK((a) <= (b))
  |  |  ------------------
  |  |  |  |  285|  7.83k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 7.27k, False: 70]
  |  |  |  |  ------------------
  |  |  |  |  286|  7.27k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  7.83k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|     70|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  601|     70|                 trainer_spec_.vocab_size())
  602|     70|        << "Vocabulary size is smaller than required_chars. "
  603|     70|        << trainer_spec_.vocab_size() << " vs "
  604|     70|        << required_chars_.size() + meta_pieces_.size() << ". "
  605|     70|        << "Increase vocab_size or decrease character_coverage with "
  606|     70|        << "--character_coverage option.";
  607|  7.34k|  }
  608|       |
  609|  25.3k|  LOG(INFO) << "Done! preprocessed " << sentences_.size() << " sentences.";
  ------------------
  |  |  218|  8.45k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  8.45k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  8.45k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  16.9k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  16.9k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 8.45k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  8.45k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 8.45k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  8.45k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 8.45k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  8.52k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  33.9k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  33.9k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  610|       |
  611|  8.45k|  return absl::OkStatus();
  612|  8.45k|}
_ZN13sentencepiece16TrainerInterface26SplitSentencesByWhitespaceEv:
  614|  6.33k|void TrainerInterface::SplitSentencesByWhitespace() {
  615|  19.0k|  LOG(INFO) << "Tokenizing input sentences with whitespace: "
  ------------------
  |  |  218|  6.33k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  6.33k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  6.33k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  12.6k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  12.6k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 6.33k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  6.33k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 6.33k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  6.33k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 6.33k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  6.33k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  19.0k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  19.0k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  616|  19.0k|            << sentences_.size();
  617|  6.33k|  absl::flat_hash_map<std::string, int64_t> tokens;
  618|  42.0k|  for (const auto& s : sentences_) {
  ------------------
  |  Branch (618:22): [True: 42.0k, False: 6.33k]
  ------------------
  619|  42.0k|    for (const auto& w :
  ------------------
  |  Branch (619:24): [True: 295k, False: 42.0k]
  ------------------
  620|  42.0k|         SplitIntoWords(s.first, trainer_spec_.treat_whitespace_as_suffix(),
  621|   295k|                        trainer_spec_.allow_whitespace_only_pieces())) {
  622|   295k|      tokens[w] += s.second;
  623|   295k|    }
  624|  42.0k|  }
  625|  6.33k|  sentences_ = Sorted(tokens);
  626|  19.0k|  LOG(INFO) << "Done! " << sentences_.size();
  ------------------
  |  |  218|  6.33k|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|  6.33k|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|  6.33k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|  12.6k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|  12.6k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 6.33k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|  6.33k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 6.33k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|  6.33k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 6.33k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|  6.33k|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  19.0k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  19.0k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  627|  6.33k|}
_ZNK13sentencepiece16TrainerInterface9SerializeEPNS_10ModelProtoE:
  629|  8.41k|absl::Status TrainerInterface::Serialize(ModelProto* model_proto) const {
  630|  8.41k|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|  8.41k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  8.41k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  16.8k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  16.8k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  16.8k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 8.41k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  8.41k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 8.41k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  16.8k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 8.41k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  16.8k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  16.8k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  8.41k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  16.8k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  631|       |
  632|       |  // Duplicated sentencepiece is not allowed.
  633|  8.41k|  absl::flat_hash_set<std::string> dup;
  634|       |
  635|  8.41k|  model_proto->Clear();
  636|       |
  637|  8.41k|#define CHECK_PIECE(piece)                            \
  638|  8.41k|  RET_CHECK(string_util::IsStructurallyValid(piece)); \
  639|  8.41k|  RET_CHECK(!piece.empty());                          \
  640|  8.41k|  RET_CHECK(dup.insert(piece).second) << piece << " is already defined";
  641|       |
  642|  8.41k|  size_t fid = 0;
  643|   497k|  for (int id = 0; id < trainer_spec_.vocab_size(); ++id) {
  ------------------
  |  Branch (643:20): [True: 488k, False: 8.41k]
  ------------------
  644|   488k|    const auto it = meta_pieces_.find(id);
  645|   488k|    if (it != meta_pieces_.end()) {
  ------------------
  |  Branch (645:9): [True: 25.2k, False: 463k]
  ------------------
  646|  25.2k|      auto* sp = model_proto->add_pieces();
  647|  25.2k|      sp->set_piece(it->second.first);
  648|  25.2k|      sp->set_type(it->second.second);
  649|  25.2k|      sp->set_score(0.0);
  650|  25.2k|      RET_CHECK_EQ(model_proto->pieces_size() - 1, it->first);
  ------------------
  |  |  290|  25.2k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  285|  25.2k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 25.2k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  25.2k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  25.2k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  651|  25.2k|      RET_CHECK_NE(ModelProto::SentencePiece::NORMAL, sp->type());
  ------------------
  |  |  291|  25.2k|#define RET_CHECK_NE(a, b) RET_CHECK((a) != (b))
  |  |  ------------------
  |  |  |  |  285|  25.2k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 25.2k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  25.2k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  25.2k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  652|  75.7k|      CHECK_PIECE(sp->piece());
  ------------------
  |  |  638|  25.2k|  RET_CHECK(string_util::IsStructurallyValid(piece)); \
  |  |  ------------------
  |  |  |  |  285|  25.2k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 25.2k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  25.2k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  25.2k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  639|  25.2k|  RET_CHECK(!piece.empty());                          \
  |  |  ------------------
  |  |  |  |  285|  25.2k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 25.2k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  25.2k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  25.2k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  640|  25.2k|  RET_CHECK(dup.insert(piece).second) << piece << " is already defined";
  |  |  ------------------
  |  |  |  |  285|  25.2k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 25.2k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  25.2k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  25.2k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  653|   463k|    } else if (fid < final_pieces_.size()) {
  ------------------
  |  Branch (653:16): [True: 331k, False: 132k]
  ------------------
  654|   331k|      const auto& w = final_pieces_[fid++];
  655|   331k|      auto* sp = model_proto->add_pieces();
  656|   331k|      sp->set_piece(w.first);
  657|   331k|      sp->set_score(w.second);
  658|   663k|      CHECK_PIECE(sp->piece());
  ------------------
  |  |  638|   331k|  RET_CHECK(string_util::IsStructurallyValid(piece)); \
  |  |  ------------------
  |  |  |  |  285|   331k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 331k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|   331k|  } else /* NOLINT */                                         \
  |  |  |  |  287|   331k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  639|   331k|  RET_CHECK(!piece.empty());                          \
  |  |  ------------------
  |  |  |  |  285|   331k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 331k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|   331k|  } else /* NOLINT */                                         \
  |  |  |  |  287|   331k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  640|   331k|  RET_CHECK(dup.insert(piece).second) << piece << " is already defined";
  |  |  ------------------
  |  |  |  |  285|   331k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 331k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|   331k|  } else /* NOLINT */                                         \
  |  |  |  |  287|   331k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  659|   331k|    }
  660|   488k|  }
  661|       |
  662|  8.41k|  RET_CHECK_EQ(fid, final_pieces_.size());
  ------------------
  |  |  290|  8.41k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  285|  8.41k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 8.41k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  8.41k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  8.41k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  663|       |
  664|  8.41k|  *model_proto->mutable_trainer_spec() = trainer_spec_;
  665|  8.41k|  *model_proto->mutable_normalizer_spec() = normalizer_spec_;
  666|       |
  667|  8.41k|  if (!denormalizer_spec_.normalization_rule_tsv().empty()) {
  ------------------
  |  Branch (667:7): [True: 0, False: 8.41k]
  ------------------
  668|      0|    *model_proto->mutable_denormalizer_spec() = denormalizer_spec_;
  669|      0|  }
  670|       |
  671|  8.41k|  if (!trainer_spec_.hard_vocab_limit() ||
  ------------------
  |  Branch (671:7): [True: 0, False: 8.41k]
  ------------------
  672|  8.41k|      trainer_spec_.model_type() == TrainerSpec::CHAR) {
  ------------------
  |  Branch (672:7): [True: 243, False: 8.17k]
  ------------------
  673|    243|    RET_CHECK_GE(trainer_spec_.vocab_size(), model_proto->pieces_size());
  ------------------
  |  |  292|    243|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  285|    243|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 243, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|    243|  } else /* NOLINT */                                         \
  |  |  |  |  287|    243|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  674|    243|    RET_CHECK_GE(trainer_spec_.vocab_size(), static_cast<int32_t>(dup.size()));
  ------------------
  |  |  292|    243|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  285|    243|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 243, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|    243|  } else /* NOLINT */                                         \
  |  |  |  |  287|    243|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  675|    243|    model_proto->mutable_trainer_spec()->set_vocab_size(
  676|    243|        model_proto->pieces_size());
  677|  8.17k|  } else {
  678|  8.17k|    RET_CHECK_EQ(trainer_spec_.vocab_size(), model_proto->pieces_size())
  ------------------
  |  |  290|  8.17k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  285|  12.2k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 4.06k, False: 4.10k]
  |  |  |  |  ------------------
  |  |  |  |  286|  4.06k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  12.2k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|  4.10k|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  679|  4.10k|        << absl::StrFormat(
  680|  4.10k|               "Vocabulary size too high (%d). Please set it to a value <= %d.",
  681|  4.10k|               trainer_spec_.vocab_size(), model_proto->pieces_size());
  682|  4.06k|    RET_CHECK_EQ(trainer_spec_.vocab_size(), static_cast<int32_t>(dup.size()));
  ------------------
  |  |  290|  4.06k|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  285|  4.06k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 4.06k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  4.06k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  4.06k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  683|  4.06k|  }
  684|       |
  685|       |  // Saves self-testing data.
  686|  4.30k|  if (!self_test_samples_.empty()) {
  ------------------
  |  Branch (686:7): [True: 0, False: 4.30k]
  ------------------
  687|      0|    SentencePieceProcessor sp;
  688|      0|    RETURN_IF_ERROR(sp.Load(*model_proto));
  ------------------
  |  |   44|      0|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  689|      0|    for (const auto& input : self_test_samples_) {
  ------------------
  |  Branch (689:28): [True: 0, False: 0]
  ------------------
  690|      0|      std::vector<std::string> sps;
  691|      0|      RETURN_IF_ERROR(sp.Encode(input, &sps));
  ------------------
  |  |   44|      0|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  692|      0|      auto* sample = model_proto->mutable_self_test_data()->add_samples();
  693|      0|      sample->set_input(input);
  694|      0|      sample->set_expected(absl::StrJoin(sps, " "));
  695|      0|    }
  696|      0|  }
  697|       |
  698|  4.30k|  return absl::OkStatus();
  699|  4.30k|}
_ZNK13sentencepiece16TrainerInterface4SaveEv:
  743|  8.41k|absl::Status TrainerInterface::Save() const {
  744|  8.41k|  if (output_model_proto_ != nullptr) {
  ------------------
  |  Branch (744:7): [True: 8.41k, False: 0]
  ------------------
  745|  8.41k|    RETURN_IF_ERROR(Serialize(output_model_proto_));
  ------------------
  |  |   44|  8.41k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  8.41k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  16.8k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  16.8k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  16.8k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 8.41k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  8.41k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 8.41k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  16.8k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 4.30k, False: 4.10k]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  16.8k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  16.8k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  4.30k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  16.8k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  746|  8.41k|  } else {
  747|      0|    RETURN_IF_ERROR(SaveModel(trainer_spec_.model_prefix() + ".model"));
  ------------------
  |  |   44|      0|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  748|      0|    RETURN_IF_ERROR(SaveVocab(trainer_spec_.model_prefix() + ".vocab"));
  ------------------
  |  |   44|      0|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  749|      0|  }
  750|  4.30k|  return absl::OkStatus();
  751|  8.41k|}
_ZN13sentencepiece16TrainerInterface14InitMetaPiecesEv:
  753|  8.53k|absl::Status TrainerInterface::InitMetaPieces() {
  754|  8.53k|  RET_CHECK(meta_pieces_.empty());
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  755|  8.53k|  bool has_unk = false;
  756|       |
  757|  8.53k|  auto insert_id = [&has_unk, this](int id, const std::string& w) -> bool {
  758|  8.53k|    if (id < 0) {
  759|  8.53k|      return true;
  760|  8.53k|    }
  761|  8.53k|    if (id >= trainer_spec_.vocab_size() ||
  762|  8.53k|        meta_pieces_.find(id) != meta_pieces_.end() ||
  763|  8.53k|        (has_unk && w == trainer_spec_.unk_piece())) {
  764|  8.53k|      return false;
  765|  8.53k|    }
  766|  8.53k|    if (w == trainer_spec_.unk_piece()) {
  767|  8.53k|      has_unk = true;
  768|  8.53k|    }
  769|  8.53k|    meta_pieces_[id] = std::make_pair(
  770|  8.53k|        w, w == trainer_spec_.unk_piece() ? ModelProto::SentencePiece::UNKNOWN
  771|  8.53k|                                          : ModelProto::SentencePiece::CONTROL);
  772|  8.53k|    return true;
  773|  8.53k|  };
  774|       |
  775|  8.53k|  RET_CHECK(insert_id(trainer_spec_.unk_id(), trainer_spec_.unk_piece()));
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  776|  8.53k|  RET_CHECK(insert_id(trainer_spec_.bos_id(), trainer_spec_.bos_piece()));
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  777|  8.53k|  RET_CHECK(insert_id(trainer_spec_.eos_id(), trainer_spec_.eos_piece()));
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  778|  8.53k|  RET_CHECK(insert_id(trainer_spec_.pad_id(), trainer_spec_.pad_piece()));
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  779|       |
  780|  8.53k|  RET_CHECK(has_unk) << trainer_spec_.unk_piece() << " must be defined.";
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  781|       |
  782|  8.53k|  absl::flat_hash_set<std::string> dup;
  783|       |
  784|  8.53k|  int id = 0;
  785|  8.53k|  auto insert_meta_symbol =
  786|  8.53k|      [&id, &dup, this](const std::string& w,
  787|  8.53k|                        ModelProto::SentencePiece::Type type) -> absl::Status {
  788|  8.53k|    if (!dup.insert(w).second) {
  789|  8.53k|      return absl::InternalError(absl::StrCat(
  790|  8.53k|          w, " is already defined. duplicated symbols are not allowed."));
  791|  8.53k|    }
  792|       |
  793|  8.53k|    if (w == trainer_spec_.unk_piece()) {
  794|  8.53k|      return absl::InternalError(
  795|  8.53k|          absl::StrCat(trainer_spec_.unk_piece(),
  796|  8.53k|                       " must not be defined with --control_symbols and "
  797|  8.53k|                       "--user_defined_symbols."));
  798|  8.53k|    }
  799|       |
  800|  8.53k|    if (w == trainer_spec_.bos_piece() && trainer_spec_.bos_id() >= 0) {
  801|  8.53k|      meta_pieces_[trainer_spec_.bos_id()].second = type;
  802|  8.53k|    } else if (w == trainer_spec_.eos_piece() && trainer_spec_.eos_id() >= 0) {
  803|  8.53k|      meta_pieces_[trainer_spec_.eos_id()].second = type;
  804|  8.53k|    } else if (w == trainer_spec_.pad_piece() && trainer_spec_.pad_id() >= 0) {
  805|  8.53k|      meta_pieces_[trainer_spec_.pad_id()].second = type;
  806|  8.53k|    } else {
  807|  8.53k|      while (meta_pieces_.find(id) != meta_pieces_.end()) {
  808|  8.53k|        ++id;
  809|  8.53k|      }
  810|  8.53k|      meta_pieces_[id] = std::make_pair(w, type);
  811|  8.53k|    }
  812|       |
  813|  8.53k|    return absl::OkStatus();
  814|  8.53k|  };
  815|       |
  816|  8.53k|  for (const auto& w : trainer_spec_.control_symbols()) {
  ------------------
  |  Branch (816:22): [True: 0, False: 8.53k]
  ------------------
  817|      0|    RETURN_IF_ERROR(insert_meta_symbol(w, ModelProto::SentencePiece::CONTROL));
  ------------------
  |  |   44|      0|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  818|      0|  }
  819|       |
  820|  8.53k|  for (const auto& w : trainer_spec_.user_defined_symbols()) {
  ------------------
  |  Branch (820:22): [True: 0, False: 8.53k]
  ------------------
  821|      0|    RETURN_IF_ERROR(
  ------------------
  |  |   44|      0|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  822|      0|        insert_meta_symbol(w, ModelProto::SentencePiece::USER_DEFINED));
  823|      0|    if (trainer_spec_.model_type() == TrainerSpec::WORD &&
  ------------------
  |  Branch (823:9): [True: 0, False: 0]
  ------------------
  824|      0|        normalizer_spec_.escape_whitespaces() &&
  ------------------
  |  Branch (824:9): [True: 0, False: 0]
  ------------------
  825|      0|        !absl::StartsWith(w, TrainerInterface::kWSStr)) {
  ------------------
  |  Branch (825:9): [True: 0, False: 0]
  ------------------
  826|       |      // WORD model tokens include the escaped whitespace prefix.
  827|      0|      RETURN_IF_ERROR(
  ------------------
  |  |   44|      0|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|      0|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|      0|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|      0|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|      0|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|      0|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|      0|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|      0|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|      0|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|      0|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|      0|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  828|      0|          insert_meta_symbol(absl::StrCat(TrainerInterface::kWSStr, w),
  829|      0|                             ModelProto::SentencePiece::USER_DEFINED));
  830|      0|    }
  831|      0|  }
  832|       |
  833|  8.53k|  if (trainer_spec_.byte_fallback()) {
  ------------------
  |  Branch (833:7): [True: 68, False: 8.47k]
  ------------------
  834|  17.4k|    for (int i = 0; i < 256; ++i) {
  ------------------
  |  Branch (834:21): [True: 17.4k, False: 68]
  ------------------
  835|  17.4k|      RETURN_IF_ERROR(
  ------------------
  |  |   44|  17.4k|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|  17.4k|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  34.8k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  34.8k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  34.8k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 17.4k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|  17.4k|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 17.4k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  34.8k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 17.4k, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  34.8k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  34.8k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|  17.4k|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  34.8k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  836|  17.4k|          insert_meta_symbol(ByteToPiece(i), ModelProto::SentencePiece::BYTE));
  837|  17.4k|    }
  838|     68|  }
  839|       |
  840|  8.53k|  return absl::OkStatus();
  841|  8.53k|}
trainer_interface.cc:_ZN13sentencepiece12_GLOBAL__N_110VerifySpecERKNS_11TrainerSpecE:
   58|  8.54k|absl::Status VerifySpec(const TrainerSpec& trainer_spec) {
   59|  8.54k|  RET_CHECK_GT(trainer_spec.vocab_size(), 0);
  ------------------
  |  |  294|  8.54k|#define RET_CHECK_GT(a, b) RET_CHECK((a) > (b))
  |  |  ------------------
  |  |  |  |  285|  8.54k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   60|       |
   61|  8.54k|  if (trainer_spec.model_type() == TrainerSpec::UNIGRAM ||
  ------------------
  |  Branch (61:7): [True: 5.91k, False: 2.63k]
  ------------------
   62|  7.35k|      trainer_spec.model_type() == TrainerSpec::BPE) {
  ------------------
  |  Branch (62:7): [True: 1.44k, False: 1.19k]
  ------------------
   63|  7.35k|    RET_CHECK(!trainer_spec.use_all_vocab())
  ------------------
  |  |  285|  7.35k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 7.35k, False: 0]
  |  |  ------------------
  |  |  286|  7.35k|  } else /* NOLINT */                                         \
  |  |  287|  7.35k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   64|      0|        << "--use_all_vocab=true is valid for WORD/CHAR model.";
   65|  7.35k|  }
   66|       |
   67|  8.54k|  if (!trainer_spec.seed_sentencepieces_file().empty()) {
  ------------------
  |  Branch (67:7): [True: 0, False: 8.54k]
  ------------------
   68|      0|    RET_CHECK(trainer_spec.model_type() == TrainerSpec::UNIGRAM)
  ------------------
  |  |  285|      0|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|  } else /* NOLINT */                                         \
  |  |  287|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   69|      0|        << "seed_sentencepieces_file is only supported for UNIGRAM model.";
   70|      0|  }
   71|       |
   72|  8.54k|#define CHECK_RANGE(variable, minval, maxval) \
   73|  8.54k|  RET_CHECK(variable >= minval && variable <= maxval)
   74|       |
   75|  8.54k|  CHECK_RANGE(trainer_spec.character_coverage(), 0.98, 1.0);
  ------------------
  |  |   73|  8.54k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  285|  25.6k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   76|  8.54k|  CHECK_RANGE(trainer_spec.max_sentencepiece_length(), 1, 512);
  ------------------
  |  |   73|  8.54k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  285|  25.6k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   77|  8.54k|  CHECK_RANGE(trainer_spec.num_sub_iterations(), 1, 10);
  ------------------
  |  |   73|  8.54k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  285|  25.6k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   78|  8.54k|  CHECK_RANGE(trainer_spec.num_threads(), 1, 1024);
  ------------------
  |  |   73|  8.54k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  285|  25.6k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   79|  8.54k|  CHECK_RANGE(trainer_spec.self_test_sample_size(), 0, 1000);
  ------------------
  |  |   73|  8.54k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  285|  25.6k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   80|  8.54k|  CHECK_RANGE(trainer_spec.shrinking_factor(), 0.5, 0.95);
  ------------------
  |  |   73|  8.54k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  285|  25.6k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   81|  8.54k|  CHECK_RANGE(trainer_spec.max_sentence_length(), 10, 1073741824);
  ------------------
  |  |   73|  8.54k|  RET_CHECK(variable >= minval && variable <= maxval)
  |  |  ------------------
  |  |  |  |  285|  25.6k|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  |  Branch (285:7): [True: 8.54k, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|  8.54k|  } else /* NOLINT */                                         \
  |  |  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   82|  8.54k|#undef CHECK_RANGE
   83|       |
   84|  8.54k|  RET_CHECK(trainer_spec.input_sentence_size() <= 0 ||
  ------------------
  |  |  285|  18.8k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 6.78k, False: 1.76k]
  |  |  |  Branch (285:7): [True: 1.75k, False: 6]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.54k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      6|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   85|  8.54k|            trainer_spec.input_sentence_size() > 100);
   86|       |
   87|  8.53k|  RET_CHECK(!trainer_spec.unk_piece().empty());
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   88|  8.53k|  RET_CHECK(!trainer_spec.bos_piece().empty());
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   89|  8.53k|  RET_CHECK(!trainer_spec.eos_piece().empty());
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   90|  8.53k|  RET_CHECK(!trainer_spec.pad_piece().empty());
  ------------------
  |  |  285|  8.53k|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 8.53k, False: 0]
  |  |  ------------------
  |  |  286|  8.53k|  } else /* NOLINT */                                         \
  |  |  287|  8.53k|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   91|       |
   92|  8.53k|  if ((SentencePieceTrainer::GetPretokenizerForTraining() != nullptr) ||
  ------------------
  |  Branch (92:7): [True: 0, False: 8.53k]
  ------------------
   93|  8.53k|      !trainer_spec.pretokenization_delimiter().empty()) {
  ------------------
  |  Branch (93:7): [True: 0, False: 8.53k]
  ------------------
   94|      0|    RET_CHECK(trainer_spec.model_type() == TrainerSpec::UNIGRAM ||
  ------------------
  |  |  285|      0|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  |  Branch (285:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  286|      0|  } else /* NOLINT */                                         \
  |  |  287|      0|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   95|      0|              trainer_spec.model_type() == TrainerSpec::BPE)
   96|      0|        << "PretokenizerForTraining is only supported in UNIGRAM or BPE mode.";
   97|      0|  }
   98|       |
   99|  8.53k|  return absl::OkStatus();
  100|  8.53k|}
trainer_interface.cc:_ZN13sentencepiece12_GLOBAL__N_125is_unicode_decimal_numberEDi:
  102|  7.36M|bool is_unicode_decimal_number(char32_t c) {
  103|  7.36M|  return (c >= 0x30 && c <= 0x39) || (c >= 0xff10 && c <= 0xff19);
  ------------------
  |  Branch (103:11): [True: 6.75M, False: 611k]
  |  Branch (103:24): [True: 2.78M, False: 3.96M]
  |  Branch (103:39): [True: 2.18M, False: 2.38M]
  |  Branch (103:54): [True: 0, False: 2.18M]
  ------------------
  104|  7.36M|}
trainer_interface.cc:_ZN13sentencepiece12_GLOBAL__N_116SentenceSelectorC2EPNSt3__16vectorINS2_4pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEENS8_ISB_EEEERKNS_11TrainerSpecE:
  114|  8.53k|      : sentences_(sentences), spec_(&spec) {
  115|  8.53k|    if (spec_->input_sentence_size() > 0) {
  ------------------
  |  Branch (115:9): [True: 1.75k, False: 6.78k]
  ------------------
  116|  1.75k|      if (spec_->shuffle_input_sentence()) {
  ------------------
  |  Branch (116:11): [True: 1.25k, False: 498]
  ------------------
  117|  1.25k|        constexpr size_t kSeed = 12345678;
  118|  1.25k|        sampler_ = std::make_unique<Sampler>(
  119|  1.25k|            sentences, spec_->input_sentence_size(), kSeed);
  120|  1.25k|      } else {
  121|  1.49k|        LOG(INFO)
  ------------------
  |  |  218|    498|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|    498|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  172|    498|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|    996|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|    996|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 498, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|    498|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 498]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|    498|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 498]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|    498|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   57|  1.99k|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   58|  1.99k|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::InfoTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  122|  1.49k|            << "First " << spec_->input_sentence_size()
  123|  1.49k|            << " sentences are selected. Remaining sentences are discarded.";
  124|    498|      }
  125|  1.75k|    }
  126|  8.53k|  }
trainer_interface.cc:_ZN13sentencepiece12_GLOBAL__N_116SentenceSelector3AddERKNSt3__14pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEE:
  140|  58.9k|  bool Add(const std::pair<std::string, int64_t>& sentence) {
  141|  58.9k|    if (spec_->input_sentence_size() == 0) {
  ------------------
  |  Branch (141:9): [True: 41.5k, False: 17.4k]
  ------------------
  142|  41.5k|      sentences_->emplace_back(sentence);
  143|  41.5k|    } else {
  144|  17.4k|      if (spec_->shuffle_input_sentence()) {
  ------------------
  |  Branch (144:11): [True: 10.0k, False: 7.37k]
  ------------------
  145|  10.0k|        sampler_->Add(sentence);
  146|  10.0k|      } else {
  147|  7.37k|        sentences_->emplace_back(sentence);
  148|  7.37k|        if (sentences_->size() >= spec_->input_sentence_size()) {
  ------------------
  |  Branch (148:13): [True: 0, False: 7.37k]
  ------------------
  149|      0|          return false;
  150|      0|        }
  151|  7.37k|      }
  152|  17.4k|    }
  153|       |
  154|  58.9k|    if (total_size() > 0 && total_size() % kTooBigSentencesSize == 0) {
  ------------------
  |  Branch (154:9): [True: 58.9k, False: 0]
  |  Branch (154:29): [True: 0, False: 58.9k]
  ------------------
  155|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  156|      0|    }
  157|       |
  158|  58.9k|    return true;
  159|  58.9k|  }
trainer_interface.cc:_ZNK13sentencepiece12_GLOBAL__N_116SentenceSelector6FinishEv:
  128|  8.53k|  void Finish() const {
  129|  8.53k|    if (sentences_->size() > kTooBigSentencesSize) {
  ------------------
  |  Branch (129:9): [True: 0, False: 8.53k]
  ------------------
  130|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  131|      0|                   << "), which may slow down training.";
  132|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  133|      0|                      "--input_sentence_size=<size> and "
  134|      0|                      "--shuffle_input_sentence=true.";
  135|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  136|      0|                      "the entire corpus.";
  137|      0|    }
  138|  8.53k|  }
trainer_interface.cc:_ZNK13sentencepiece12_GLOBAL__N_116SentenceSelector10total_sizeEv:
  161|   126k|  [[nodiscard]] size_t total_size() const {
  162|   126k|    return (sampler_ != nullptr) ? sampler_->total_size() : sentences_->size();
  ------------------
  |  Branch (162:12): [True: 21.3k, False: 105k]
  ------------------
  163|   126k|  }
trainer_interface.cc:_ZZN13sentencepiece16TrainerInterface14InitMetaPiecesEvENK3$_0clEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  757|  34.1k|  auto insert_id = [&has_unk, this](int id, const std::string& w) -> bool {
  758|  34.1k|    if (id < 0) {
  ------------------
  |  Branch (758:9): [True: 8.53k, False: 25.6k]
  ------------------
  759|  8.53k|      return true;
  760|  8.53k|    }
  761|  25.6k|    if (id >= trainer_spec_.vocab_size() ||
  ------------------
  |  Branch (761:9): [True: 0, False: 25.6k]
  |  Branch (761:9): [True: 0, False: 25.6k]
  ------------------
  762|  25.6k|        meta_pieces_.find(id) != meta_pieces_.end() ||
  ------------------
  |  Branch (762:9): [True: 0, False: 25.6k]
  ------------------
  763|  25.6k|        (has_unk && w == trainer_spec_.unk_piece())) {
  ------------------
  |  Branch (763:10): [True: 17.0k, False: 8.53k]
  |  Branch (763:21): [True: 0, False: 17.0k]
  ------------------
  764|      0|      return false;
  765|      0|    }
  766|  25.6k|    if (w == trainer_spec_.unk_piece()) {
  ------------------
  |  Branch (766:9): [True: 8.53k, False: 17.0k]
  ------------------
  767|  8.53k|      has_unk = true;
  768|  8.53k|    }
  769|  25.6k|    meta_pieces_[id] = std::make_pair(
  770|  25.6k|        w, w == trainer_spec_.unk_piece() ? ModelProto::SentencePiece::UNKNOWN
  ------------------
  |  Branch (770:12): [True: 8.53k, False: 17.0k]
  ------------------
  771|  25.6k|                                          : ModelProto::SentencePiece::CONTROL);
  772|  25.6k|    return true;
  773|  25.6k|  };
trainer_interface.cc:_ZZN13sentencepiece16TrainerInterface14InitMetaPiecesEvENK3$_1clERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS_29ModelProto_SentencePiece_TypeE:
  787|  17.4k|                        ModelProto::SentencePiece::Type type) -> absl::Status {
  788|  17.4k|    if (!dup.insert(w).second) {
  ------------------
  |  Branch (788:9): [True: 0, False: 17.4k]
  ------------------
  789|      0|      return absl::InternalError(absl::StrCat(
  790|      0|          w, " is already defined. duplicated symbols are not allowed."));
  791|      0|    }
  792|       |
  793|  17.4k|    if (w == trainer_spec_.unk_piece()) {
  ------------------
  |  Branch (793:9): [True: 0, False: 17.4k]
  ------------------
  794|      0|      return absl::InternalError(
  795|      0|          absl::StrCat(trainer_spec_.unk_piece(),
  796|      0|                       " must not be defined with --control_symbols and "
  797|      0|                       "--user_defined_symbols."));
  798|      0|    }
  799|       |
  800|  17.4k|    if (w == trainer_spec_.bos_piece() && trainer_spec_.bos_id() >= 0) {
  ------------------
  |  Branch (800:9): [True: 0, False: 17.4k]
  |  Branch (800:43): [True: 0, False: 0]
  ------------------
  801|      0|      meta_pieces_[trainer_spec_.bos_id()].second = type;
  802|  17.4k|    } else if (w == trainer_spec_.eos_piece() && trainer_spec_.eos_id() >= 0) {
  ------------------
  |  Branch (802:16): [True: 0, False: 17.4k]
  |  Branch (802:50): [True: 0, False: 0]
  ------------------
  803|      0|      meta_pieces_[trainer_spec_.eos_id()].second = type;
  804|  17.4k|    } else if (w == trainer_spec_.pad_piece() && trainer_spec_.pad_id() >= 0) {
  ------------------
  |  Branch (804:16): [True: 0, False: 17.4k]
  |  Branch (804:50): [True: 0, False: 0]
  ------------------
  805|      0|      meta_pieces_[trainer_spec_.pad_id()].second = type;
  806|  17.4k|    } else {
  807|  34.9k|      while (meta_pieces_.find(id) != meta_pieces_.end()) {
  ------------------
  |  Branch (807:14): [True: 17.5k, False: 17.4k]
  ------------------
  808|  17.5k|        ++id;
  809|  17.5k|      }
  810|  17.4k|      meta_pieces_[id] = std::make_pair(w, type);
  811|  17.4k|    }
  812|       |
  813|  17.4k|    return absl::OkStatus();
  814|  17.4k|  };
trainer_interface.cc:_ZZNK13sentencepiece16TrainerInterface20IsValidSentencePieceERKNSt3__16vectorIDiNS1_9allocatorIDiEEEEENK3$_0clEDi:
  237|  15.3M|                  [](char32_t c) { return c == kWSChar; });
trainer_interface.cc:_ZZN13sentencepiece16TrainerInterface13LoadSentencesEvENK3$_0clEv:
  450|  8.52k|        pool->Schedule([&, n] {
  451|  67.4k|          for (size_t i = n; i < sentences_.size();
  ------------------
  |  Branch (451:30): [True: 58.9k, False: 8.52k]
  ------------------
  452|  58.9k|               i += trainer_spec_.num_threads()) {
  453|  58.9k|            auto* s = &sentences_[i].first;
  454|  58.9k|            *s = meta_pieces_matcher.GlobalReplace(normalizer.Normalize(*s),
  455|  58.9k|                                                   kUPPBoundaryStr);
  456|  58.9k|          }
  457|  8.52k|        });

_ZN13sentencepiece16TrainerInterface5TrainEPNS_16SentenceIteratorEPNS_10ModelProtoE:
   95|  8.54k|                             ModelProto* output_model_proto) {
   96|  8.54k|    sentence_iterator_ = sentence_iterator;
   97|  8.54k|    output_model_proto_ = output_model_proto;
   98|  8.54k|    return Train();
   99|  8.54k|  }
_ZNK13sentencepiece16TrainerInterface6statusEv:
  103|  25.4k|  virtual absl::Status status() const { return status_; }
_ZN13sentencepiece6SortedIDiNSt3__14pairIblEEEENS1_6vectorINS2_IT_T0_EENS1_9allocatorIS7_EEEERKN4absl12lts_2026052613flat_hash_mapIS5_S6_NSC_18container_internal17FlatHashMapPolicyIS5_S6_E11DefaultHashENSG_9DefaultEqENSG_12DefaultAllocEEE:
   49|  8.52k|std::vector<std::pair<K, V>> Sorted(const absl::flat_hash_map<K, V>& m) {
   50|  8.52k|  std::vector<std::pair<K, V>> v(m.begin(), m.end());
   51|  8.52k|  return Sorted(v);
   52|  8.52k|}
_ZN13sentencepiece6SortedIDiNSt3__14pairIblEEEENS1_6vectorINS2_IT_T0_EENS1_9allocatorIS7_EEEERKSA_:
   38|  8.52k|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>>& m) {
   39|  8.52k|  std::vector<std::pair<K, V>> v = m;
   40|  8.52k|  std::sort(v.begin(), v.end(),
   41|  8.52k|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|  8.52k|              return (p1.second > p2.second ||
   43|  8.52k|                      (p1.second == p2.second && p1.first < p2.first));
   44|  8.52k|            });
   45|  8.52k|  return v;
   46|  8.52k|}
_ZZN13sentencepiece6SortedIDiNSt3__14pairIblEEEENS1_6vectorINS2_IT_T0_EENS1_9allocatorIS7_EEEERKSA_ENKUlRKNS2_IDiS3_EESF_E_clESF_SF_:
   41|  2.03M|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|  2.03M|              return (p1.second > p2.second ||
  ------------------
  |  Branch (42:23): [True: 807k, False: 1.22M]
  ------------------
   43|  1.22M|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (43:24): [True: 914k, False: 308k]
  |  Branch (43:50): [True: 611k, False: 302k]
  ------------------
   44|  2.03M|            });
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEElEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKN4absl12lts_2026052613flat_hash_mapISA_SB_NSG_18container_internal17FlatHashMapPolicyISA_SB_E11DefaultHashENSK_9DefaultEqENSK_12DefaultAllocEEE:
   49|  12.1k|std::vector<std::pair<K, V>> Sorted(const absl::flat_hash_map<K, V>& m) {
   50|  12.1k|  std::vector<std::pair<K, V>> v(m.begin(), m.end());
   51|  12.1k|  return Sorted(v);
   52|  12.1k|}
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEElEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_:
   38|  12.1k|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>>& m) {
   39|  12.1k|  std::vector<std::pair<K, V>> v = m;
   40|  12.1k|  std::sort(v.begin(), v.end(),
   41|  12.1k|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|  12.1k|              return (p1.second > p2.second ||
   43|  12.1k|                      (p1.second == p2.second && p1.first < p2.first));
   44|  12.1k|            });
   45|  12.1k|  return v;
   46|  12.1k|}
_ZZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEElEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_ENKUlRKNS9_IS7_lEESJ_E_clESJ_SJ_:
   41|  2.61M|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|  2.61M|              return (p1.second > p2.second ||
  ------------------
  |  Branch (42:23): [True: 587k, False: 2.03M]
  ------------------
   43|  2.03M|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (43:24): [True: 1.81M, False: 212k]
  |  Branch (43:50): [True: 1.19M, False: 618k]
  ------------------
   44|  2.61M|            });
_ZN13sentencepiece6SortedIifEENSt3__16vectorINS1_4pairIT_T0_EENS1_9allocatorIS6_EEEERKS9_:
   38|  9.87k|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>>& m) {
   39|  9.87k|  std::vector<std::pair<K, V>> v = m;
   40|  9.87k|  std::sort(v.begin(), v.end(),
   41|  9.87k|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|  9.87k|              return (p1.second > p2.second ||
   43|  9.87k|                      (p1.second == p2.second && p1.first < p2.first));
   44|  9.87k|            });
   45|  9.87k|  return v;
   46|  9.87k|}
_ZZN13sentencepiece6SortedIifEENSt3__16vectorINS1_4pairIT_T0_EENS1_9allocatorIS6_EEEERKS9_ENKUlRKNS3_IifEESE_E_clESE_SE_:
   41|  12.2M|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|  12.2M|              return (p1.second > p2.second ||
  ------------------
  |  Branch (42:23): [True: 7.75M, False: 4.51M]
  ------------------
   43|  4.51M|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (43:24): [True: 482k, False: 4.03M]
  |  Branch (43:50): [True: 281k, False: 200k]
  ------------------
   44|  12.2M|            });
_ZN13sentencepiece6SortedIDilEENSt3__16vectorINS1_4pairIT_T0_EENS1_9allocatorIS6_EEEERKN4absl12lts_2026052613flat_hash_mapIS4_S5_NSB_18container_internal17FlatHashMapPolicyIS4_S5_E11DefaultHashENSF_9DefaultEqENSF_12DefaultAllocEEE:
   49|  7.50k|std::vector<std::pair<K, V>> Sorted(const absl::flat_hash_map<K, V>& m) {
   50|  7.50k|  std::vector<std::pair<K, V>> v(m.begin(), m.end());
   51|  7.50k|  return Sorted(v);
   52|  7.50k|}
_ZN13sentencepiece6SortedIDilEENSt3__16vectorINS1_4pairIT_T0_EENS1_9allocatorIS6_EEEERKS9_:
   38|  7.50k|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>>& m) {
   39|  7.50k|  std::vector<std::pair<K, V>> v = m;
   40|  7.50k|  std::sort(v.begin(), v.end(),
   41|  7.50k|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|  7.50k|              return (p1.second > p2.second ||
   43|  7.50k|                      (p1.second == p2.second && p1.first < p2.first));
   44|  7.50k|            });
   45|  7.50k|  return v;
   46|  7.50k|}
_ZZN13sentencepiece6SortedIDilEENSt3__16vectorINS1_4pairIT_T0_EENS1_9allocatorIS6_EEEERKS9_ENKUlRKNS3_IDilEESE_E_clESE_SE_:
   41|  1.48M|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|  1.48M|              return (p1.second > p2.second ||
  ------------------
  |  Branch (42:23): [True: 578k, False: 904k]
  ------------------
   43|   904k|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (43:24): [True: 684k, False: 219k]
  |  Branch (43:50): [True: 456k, False: 227k]
  ------------------
   44|  1.48M|            });
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEfEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_:
   38|  11.6k|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>>& m) {
   39|  11.6k|  std::vector<std::pair<K, V>> v = m;
   40|  11.6k|  std::sort(v.begin(), v.end(),
   41|  11.6k|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|  11.6k|              return (p1.second > p2.second ||
   43|  11.6k|                      (p1.second == p2.second && p1.first < p2.first));
   44|  11.6k|            });
   45|  11.6k|  return v;
   46|  11.6k|}
_ZZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEfEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_ENKUlRKNS9_IS7_fEESJ_E_clESJ_SJ_:
   41|  2.97M|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|  2.97M|              return (p1.second > p2.second ||
  ------------------
  |  Branch (42:23): [True: 1.76M, False: 1.20M]
  ------------------
   43|  1.20M|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (43:24): [True: 414k, False: 793k]
  |  Branch (43:50): [True: 264k, False: 150k]
  ------------------
   44|  2.97M|            });
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEfEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKN4absl12lts_2026052613flat_hash_mapISA_SB_NSG_18container_internal17FlatHashMapPolicyISA_SB_E11DefaultHashENSK_9DefaultEqENSK_12DefaultAllocEEE:
   49|  5.83k|std::vector<std::pair<K, V>> Sorted(const absl::flat_hash_map<K, V>& m) {
   50|  5.83k|  std::vector<std::pair<K, V>> v(m.begin(), m.end());
   51|  5.83k|  return Sorted(v);
   52|  5.83k|}
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKN4absl12lts_2026052613flat_hash_mapISA_SB_NSG_18container_internal17FlatHashMapPolicyISA_SB_E11DefaultHashENSK_9DefaultEqENSK_12DefaultAllocEEE:
   49|    913|std::vector<std::pair<K, V>> Sorted(const absl::flat_hash_map<K, V>& m) {
   50|    913|  std::vector<std::pair<K, V>> v(m.begin(), m.end());
   51|    913|  return Sorted(v);
   52|    913|}
_ZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_:
   38|    913|std::vector<std::pair<K, V>> Sorted(const std::vector<std::pair<K, V>>& m) {
   39|    913|  std::vector<std::pair<K, V>> v = m;
   40|    913|  std::sort(v.begin(), v.end(),
   41|    913|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|    913|              return (p1.second > p2.second ||
   43|    913|                      (p1.second == p2.second && p1.first < p2.first));
   44|    913|            });
   45|    913|  return v;
   46|    913|}
_ZZN13sentencepiece6SortedINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmEENS1_6vectorINS1_4pairIT_T0_EENS5_ISC_EEEERKSE_ENKUlRKNS9_IS7_mEESJ_E_clESJ_SJ_:
   41|   843k|            [](const std::pair<K, V>& p1, const std::pair<K, V>& p2) {
   42|   843k|              return (p1.second > p2.second ||
  ------------------
  |  Branch (42:23): [True: 57.4k, False: 786k]
  ------------------
   43|   786k|                      (p1.second == p2.second && p1.first < p2.first));
  ------------------
  |  Branch (43:24): [True: 766k, False: 20.0k]
  |  Branch (43:50): [True: 488k, False: 277k]
  ------------------
   44|   843k|            });

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

unicode_script.cc:_ZN13sentencepiece14unicode_script12_GLOBAL__N_19InitTableEPN4absl12lts_2026052613flat_hash_mapIDiNS0_10ScriptTypeENS3_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS9_9allocatorINS9_4pairIKDiS5_EEEEEE:
   21|      1|void InitTable(absl::flat_hash_map<char32_t, ScriptType> *smap) {
   22|     33|  for (char32_t c = 0x0000; c <= 0x001F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (22:29): [True: 32, False: 1]
  ------------------
   23|      1|  (*smap)[0x0020] = U_Common;
   24|      4|  for (char32_t c = 0x0021; c <= 0x0023; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (24:29): [True: 3, False: 1]
  ------------------
   25|      1|  (*smap)[0x0024] = U_Common;
   26|      4|  for (char32_t c = 0x0025; c <= 0x0027; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (26:29): [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_t c = 0x002E; c <= 0x002F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (33:29): [True: 2, False: 1]
  ------------------
   34|     11|  for (char32_t c = 0x0030; c <= 0x0039; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (34:29): [True: 10, False: 1]
  ------------------
   35|      3|  for (char32_t c = 0x003A; c <= 0x003B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (35:29): [True: 2, False: 1]
  ------------------
   36|      4|  for (char32_t c = 0x003C; c <= 0x003E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (36:29): [True: 3, False: 1]
  ------------------
   37|      3|  for (char32_t c = 0x003F; c <= 0x0040; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (37:29): [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_t c = 0x007F; c <= 0x009F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (48:29): [True: 33, False: 1]
  ------------------
   49|      1|  (*smap)[0x00A0] = U_Common;
   50|      1|  (*smap)[0x00A1] = U_Common;
   51|      5|  for (char32_t c = 0x00A2; c <= 0x00A5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (51:29): [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_t c = 0x00B2; c <= 0x00B3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (63:29): [True: 2, False: 1]
  ------------------
   64|      1|  (*smap)[0x00B4] = U_Common;
   65|      1|  (*smap)[0x00B5] = U_Common;
   66|      3|  for (char32_t c = 0x00B6; c <= 0x00B7; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (66:29): [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_t c = 0x00BC; c <= 0x00BE; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (70:29): [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_t c = 0x02B9; c <= 0x02C1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (74:29): [True: 9, False: 1]
  ------------------
   75|      5|  for (char32_t c = 0x02C2; c <= 0x02C5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (75:29): [True: 4, False: 1]
  ------------------
   76|     13|  for (char32_t c = 0x02C6; c <= 0x02D1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (76:29): [True: 12, False: 1]
  ------------------
   77|     15|  for (char32_t c = 0x02D2; c <= 0x02DF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (77:29): [True: 14, False: 1]
  ------------------
   78|      6|  for (char32_t c = 0x02E5; c <= 0x02E9; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (78:29): [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_t c = 0x02EF; c <= 0x02FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (82:29): [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_t c = 0x0964; c <= 0x0965; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (96:29): [True: 2, False: 1]
  ------------------
   97|      1|  (*smap)[0x0E3F] = U_Common;
   98|      5|  for (char32_t c = 0x0FD5; c <= 0x0FD8; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (98:29): [True: 4, False: 1]
  ------------------
   99|      1|  (*smap)[0x10FB] = U_Common;
  100|      4|  for (char32_t c = 0x16EB; c <= 0x16ED; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (100:29): [True: 3, False: 1]
  ------------------
  101|      3|  for (char32_t c = 0x1735; c <= 0x1736; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (101:29): [True: 2, False: 1]
  ------------------
  102|      3|  for (char32_t c = 0x1802; c <= 0x1803; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (102:29): [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_t c = 0x1CE9; c <= 0x1CEC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (106:29): [True: 4, False: 1]
  ------------------
  107|      5|  for (char32_t c = 0x1CEE; c <= 0x1CF1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (107:29): [True: 4, False: 1]
  ------------------
  108|      3|  for (char32_t c = 0x1CF2; c <= 0x1CF3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (108:29): [True: 2, False: 1]
  ------------------
  109|      3|  for (char32_t c = 0x1CF5; c <= 0x1CF6; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (109:29): [True: 2, False: 1]
  ------------------
  110|     12|  for (char32_t c = 0x2000; c <= 0x200A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (110:29): [True: 11, False: 1]
  ------------------
  111|      1|  (*smap)[0x200B] = U_Common;
  112|      3|  for (char32_t c = 0x200E; c <= 0x200F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (112:29): [True: 2, False: 1]
  ------------------
  113|      7|  for (char32_t c = 0x2010; c <= 0x2015; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (113:29): [True: 6, False: 1]
  ------------------
  114|      3|  for (char32_t c = 0x2016; c <= 0x2017; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (114:29): [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_t c = 0x201B; c <= 0x201C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (118:29): [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_t c = 0x2020; c <= 0x2027; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (122:29): [True: 8, False: 1]
  ------------------
  123|      1|  (*smap)[0x2028] = U_Common;
  124|      1|  (*smap)[0x2029] = U_Common;
  125|      6|  for (char32_t c = 0x202A; c <= 0x202E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (125:29): [True: 5, False: 1]
  ------------------
  126|      1|  (*smap)[0x202F] = U_Common;
  127|     10|  for (char32_t c = 0x2030; c <= 0x2038; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (127:29): [True: 9, False: 1]
  ------------------
  128|      1|  (*smap)[0x2039] = U_Common;
  129|      1|  (*smap)[0x203A] = U_Common;
  130|      5|  for (char32_t c = 0x203B; c <= 0x203E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (130:29): [True: 4, False: 1]
  ------------------
  131|      3|  for (char32_t c = 0x203F; c <= 0x2040; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (131:29): [True: 2, False: 1]
  ------------------
  132|      4|  for (char32_t c = 0x2041; c <= 0x2043; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (132:29): [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_t c = 0x2047; c <= 0x2051; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (136:29): [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_t c = 0x2055; c <= 0x205E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (140:29): [True: 10, False: 1]
  ------------------
  141|      1|  (*smap)[0x205F] = U_Common;
  142|      6|  for (char32_t c = 0x2060; c <= 0x2064; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (142:29): [True: 5, False: 1]
  ------------------
  143|     11|  for (char32_t c = 0x2066; c <= 0x206F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (143:29): [True: 10, False: 1]
  ------------------
  144|      1|  (*smap)[0x2070] = U_Common;
  145|      7|  for (char32_t c = 0x2074; c <= 0x2079; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (145:29): [True: 6, False: 1]
  ------------------
  146|      4|  for (char32_t c = 0x207A; c <= 0x207C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (146:29): [True: 3, False: 1]
  ------------------
  147|      1|  (*smap)[0x207D] = U_Common;
  148|      1|  (*smap)[0x207E] = U_Common;
  149|     11|  for (char32_t c = 0x2080; c <= 0x2089; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (149:29): [True: 10, False: 1]
  ------------------
  150|      4|  for (char32_t c = 0x208A; c <= 0x208C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (150:29): [True: 3, False: 1]
  ------------------
  151|      1|  (*smap)[0x208D] = U_Common;
  152|      1|  (*smap)[0x208E] = U_Common;
  153|     32|  for (char32_t c = 0x20A0; c <= 0x20BE; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (153:29): [True: 31, False: 1]
  ------------------
  154|      3|  for (char32_t c = 0x2100; c <= 0x2101; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (154:29): [True: 2, False: 1]
  ------------------
  155|      1|  (*smap)[0x2102] = U_Common;
  156|      5|  for (char32_t c = 0x2103; c <= 0x2106; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (156:29): [True: 4, False: 1]
  ------------------
  157|      1|  (*smap)[0x2107] = U_Common;
  158|      3|  for (char32_t c = 0x2108; c <= 0x2109; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (158:29): [True: 2, False: 1]
  ------------------
  159|     11|  for (char32_t c = 0x210A; c <= 0x2113; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (159:29): [True: 10, False: 1]
  ------------------
  160|      1|  (*smap)[0x2114] = U_Common;
  161|      1|  (*smap)[0x2115] = U_Common;
  162|      3|  for (char32_t c = 0x2116; c <= 0x2117; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (162:29): [True: 2, False: 1]
  ------------------
  163|      1|  (*smap)[0x2118] = U_Common;
  164|      6|  for (char32_t c = 0x2119; c <= 0x211D; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (164:29): [True: 5, False: 1]
  ------------------
  165|      7|  for (char32_t c = 0x211E; c <= 0x2123; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (165:29): [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_t c = 0x212C; c <= 0x212D; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (171:29): [True: 2, False: 1]
  ------------------
  172|      1|  (*smap)[0x212E] = U_Common;
  173|      4|  for (char32_t c = 0x212F; c <= 0x2131; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (173:29): [True: 3, False: 1]
  ------------------
  174|      3|  for (char32_t c = 0x2133; c <= 0x2134; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (174:29): [True: 2, False: 1]
  ------------------
  175|      5|  for (char32_t c = 0x2135; c <= 0x2138; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (175:29): [True: 4, False: 1]
  ------------------
  176|      1|  (*smap)[0x2139] = U_Common;
  177|      3|  for (char32_t c = 0x213A; c <= 0x213B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (177:29): [True: 2, False: 1]
  ------------------
  178|      5|  for (char32_t c = 0x213C; c <= 0x213F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (178:29): [True: 4, False: 1]
  ------------------
  179|      6|  for (char32_t c = 0x2140; c <= 0x2144; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (179:29): [True: 5, False: 1]
  ------------------
  180|      6|  for (char32_t c = 0x2145; c <= 0x2149; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (180:29): [True: 5, False: 1]
  ------------------
  181|      1|  (*smap)[0x214A] = U_Common;
  182|      1|  (*smap)[0x214B] = U_Common;
  183|      3|  for (char32_t c = 0x214C; c <= 0x214D; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (183:29): [True: 2, False: 1]
  ------------------
  184|      1|  (*smap)[0x214F] = U_Common;
  185|     17|  for (char32_t c = 0x2150; c <= 0x215F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (185:29): [True: 16, False: 1]
  ------------------
  186|      1|  (*smap)[0x2189] = U_Common;
  187|      3|  for (char32_t c = 0x218A; c <= 0x218B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (187:29): [True: 2, False: 1]
  ------------------
  188|      6|  for (char32_t c = 0x2190; c <= 0x2194; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (188:29): [True: 5, False: 1]
  ------------------
  189|      6|  for (char32_t c = 0x2195; c <= 0x2199; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (189:29): [True: 5, False: 1]
  ------------------
  190|      3|  for (char32_t c = 0x219A; c <= 0x219B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (190:29): [True: 2, False: 1]
  ------------------
  191|      5|  for (char32_t c = 0x219C; c <= 0x219F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (191:29): [True: 4, False: 1]
  ------------------
  192|      1|  (*smap)[0x21A0] = U_Common;
  193|      3|  for (char32_t c = 0x21A1; c <= 0x21A2; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (193:29): [True: 2, False: 1]
  ------------------
  194|      1|  (*smap)[0x21A3] = U_Common;
  195|      3|  for (char32_t c = 0x21A4; c <= 0x21A5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (195:29): [True: 2, False: 1]
  ------------------
  196|      1|  (*smap)[0x21A6] = U_Common;
  197|      8|  for (char32_t c = 0x21A7; c <= 0x21AD; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (197:29): [True: 7, False: 1]
  ------------------
  198|      1|  (*smap)[0x21AE] = U_Common;
  199|     32|  for (char32_t c = 0x21AF; c <= 0x21CD; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (199:29): [True: 31, False: 1]
  ------------------
  200|      3|  for (char32_t c = 0x21CE; c <= 0x21CF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (200:29): [True: 2, False: 1]
  ------------------
  201|      3|  for (char32_t c = 0x21D0; c <= 0x21D1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (201:29): [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_t c = 0x21D5; c <= 0x21F3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (205:29): [True: 31, False: 1]
  ------------------
  206|    269|  for (char32_t c = 0x21F4; c <= 0x22FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (206:29): [True: 268, False: 1]
  ------------------
  207|      9|  for (char32_t c = 0x2300; c <= 0x2307; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (207:29): [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_t c = 0x230C; c <= 0x231F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (212:29): [True: 20, False: 1]
  ------------------
  213|      3|  for (char32_t c = 0x2320; c <= 0x2321; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (213:29): [True: 2, False: 1]
  ------------------
  214|      8|  for (char32_t c = 0x2322; c <= 0x2328; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (214:29): [True: 7, False: 1]
  ------------------
  215|      1|  (*smap)[0x2329] = U_Common;
  216|      1|  (*smap)[0x232A] = U_Common;
  217|     82|  for (char32_t c = 0x232B; c <= 0x237B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (217:29): [True: 81, False: 1]
  ------------------
  218|      1|  (*smap)[0x237C] = U_Common;
  219|     31|  for (char32_t c = 0x237D; c <= 0x239A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (219:29): [True: 30, False: 1]
  ------------------
  220|     26|  for (char32_t c = 0x239B; c <= 0x23B3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (220:29): [True: 25, False: 1]
  ------------------
  221|     41|  for (char32_t c = 0x23B4; c <= 0x23DB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (221:29): [True: 40, False: 1]
  ------------------
  222|      7|  for (char32_t c = 0x23DC; c <= 0x23E1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (222:29): [True: 6, False: 1]
  ------------------
  223|     30|  for (char32_t c = 0x23E2; c <= 0x23FE; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (223:29): [True: 29, False: 1]
  ------------------
  224|     40|  for (char32_t c = 0x2400; c <= 0x2426; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (224:29): [True: 39, False: 1]
  ------------------
  225|     12|  for (char32_t c = 0x2440; c <= 0x244A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (225:29): [True: 11, False: 1]
  ------------------
  226|     61|  for (char32_t c = 0x2460; c <= 0x249B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (226:29): [True: 60, False: 1]
  ------------------
  227|     79|  for (char32_t c = 0x249C; c <= 0x24E9; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (227:29): [True: 78, False: 1]
  ------------------
  228|     23|  for (char32_t c = 0x24EA; c <= 0x24FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (228:29): [True: 22, False: 1]
  ------------------
  229|    184|  for (char32_t c = 0x2500; c <= 0x25B6; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (229:29): [True: 183, False: 1]
  ------------------
  230|      1|  (*smap)[0x25B7] = U_Common;
  231|     10|  for (char32_t c = 0x25B8; c <= 0x25C0; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (231:29): [True: 9, False: 1]
  ------------------
  232|      1|  (*smap)[0x25C1] = U_Common;
  233|     55|  for (char32_t c = 0x25C2; c <= 0x25F7; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (233:29): [True: 54, False: 1]
  ------------------
  234|      9|  for (char32_t c = 0x25F8; c <= 0x25FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (234:29): [True: 8, False: 1]
  ------------------
  235|    112|  for (char32_t c = 0x2600; c <= 0x266E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (235:29): [True: 111, False: 1]
  ------------------
  236|      1|  (*smap)[0x266F] = U_Common;
  237|    249|  for (char32_t c = 0x2670; c <= 0x2767; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (237:29): [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_t c = 0x2776; c <= 0x2793; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (252:29): [True: 30, False: 1]
  ------------------
  253|     45|  for (char32_t c = 0x2794; c <= 0x27BF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (253:29): [True: 44, False: 1]
  ------------------
  254|      6|  for (char32_t c = 0x27C0; c <= 0x27C4; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (254:29): [True: 5, False: 1]
  ------------------
  255|      1|  (*smap)[0x27C5] = U_Common;
  256|      1|  (*smap)[0x27C6] = U_Common;
  257|     32|  for (char32_t c = 0x27C7; c <= 0x27E5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (257:29): [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_t c = 0x27F0; c <= 0x27FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (268:29): [True: 16, False: 1]
  ------------------
  269|    132|  for (char32_t c = 0x2900; c <= 0x2982; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (269:29): [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_t c = 0x2999; c <= 0x29D7; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (292:29): [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_t c = 0x29DC; c <= 0x29FB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (297:29): [True: 32, False: 1]
  ------------------
  298|      1|  (*smap)[0x29FC] = U_Common;
  299|      1|  (*smap)[0x29FD] = U_Common;
  300|    259|  for (char32_t c = 0x29FE; c <= 0x2AFF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (300:29): [True: 258, False: 1]
  ------------------
  301|     49|  for (char32_t c = 0x2B00; c <= 0x2B2F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (301:29): [True: 48, False: 1]
  ------------------
  302|     22|  for (char32_t c = 0x2B30; c <= 0x2B44; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (302:29): [True: 21, False: 1]
  ------------------
  303|      3|  for (char32_t c = 0x2B45; c <= 0x2B46; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (303:29): [True: 2, False: 1]
  ------------------
  304|      7|  for (char32_t c = 0x2B47; c <= 0x2B4C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (304:29): [True: 6, False: 1]
  ------------------
  305|     40|  for (char32_t c = 0x2B4D; c <= 0x2B73; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (305:29): [True: 39, False: 1]
  ------------------
  306|     33|  for (char32_t c = 0x2B76; c <= 0x2B95; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (306:29): [True: 32, False: 1]
  ------------------
  307|     35|  for (char32_t c = 0x2B98; c <= 0x2BB9; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (307:29): [True: 34, False: 1]
  ------------------
  308|     13|  for (char32_t c = 0x2BBD; c <= 0x2BC8; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (308:29): [True: 12, False: 1]
  ------------------
  309|      9|  for (char32_t c = 0x2BCA; c <= 0x2BD1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (309:29): [True: 8, False: 1]
  ------------------
  310|      5|  for (char32_t c = 0x2BEC; c <= 0x2BEF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (310:29): [True: 4, False: 1]
  ------------------
  311|      3|  for (char32_t c = 0x2E00; c <= 0x2E01; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (311:29): [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_t c = 0x2E06; c <= 0x2E08; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (316:29): [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_t c = 0x2E0E; c <= 0x2E16; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (322:29): [True: 9, False: 1]
  ------------------
  323|      1|  (*smap)[0x2E17] = U_Common;
  324|      3|  for (char32_t c = 0x2E18; c <= 0x2E19; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (324:29): [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_t c = 0x2E1E; c <= 0x2E1F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (329:29): [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_t c = 0x2E2A; c <= 0x2E2E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (340:29): [True: 5, False: 1]
  ------------------
  341|      1|  (*smap)[0x2E2F] = U_Common;
  342|     11|  for (char32_t c = 0x2E30; c <= 0x2E39; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (342:29): [True: 10, False: 1]
  ------------------
  343|      3|  for (char32_t c = 0x2E3A; c <= 0x2E3B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (343:29): [True: 2, False: 1]
  ------------------
  344|      5|  for (char32_t c = 0x2E3C; c <= 0x2E3F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (344:29): [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_t c = 0x2E43; c <= 0x2E44; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (348:29): [True: 2, False: 1]
  ------------------
  349|     13|  for (char32_t c = 0x2FF0; c <= 0x2FFB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (349:29): [True: 12, False: 1]
  ------------------
  350|      1|  (*smap)[0x3000] = U_Common;
  351|      4|  for (char32_t c = 0x3001; c <= 0x3003; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (351:29): [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_t c = 0x3012; c <= 0x3013; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (364:29): [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_t c = 0x301E; c <= 0x301F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (375:29): [True: 2, False: 1]
  ------------------
  376|      1|  (*smap)[0x3020] = U_Common;
  377|      1|  (*smap)[0x3030] = U_Common;
  378|      6|  for (char32_t c = 0x3031; c <= 0x3035; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (378:29): [True: 5, False: 1]
  ------------------
  379|      3|  for (char32_t c = 0x3036; c <= 0x3037; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (379:29): [True: 2, False: 1]
  ------------------
  380|      1|  (*smap)[0x303C] = U_Common;
  381|      1|  (*smap)[0x303D] = U_Common;
  382|      3|  for (char32_t c = 0x303E; c <= 0x303F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (382:29): [True: 2, False: 1]
  ------------------
  383|      3|  for (char32_t c = 0x309B; c <= 0x309C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (383:29): [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_t c = 0x3190; c <= 0x3191; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (387:29): [True: 2, False: 1]
  ------------------
  388|      5|  for (char32_t c = 0x3192; c <= 0x3195; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (388:29): [True: 4, False: 1]
  ------------------
  389|     11|  for (char32_t c = 0x3196; c <= 0x319F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (389:29): [True: 10, False: 1]
  ------------------
  390|     37|  for (char32_t c = 0x31C0; c <= 0x31E3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (390:29): [True: 36, False: 1]
  ------------------
  391|     11|  for (char32_t c = 0x3220; c <= 0x3229; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (391:29): [True: 10, False: 1]
  ------------------
  392|     31|  for (char32_t c = 0x322A; c <= 0x3247; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (392:29): [True: 30, False: 1]
  ------------------
  393|      9|  for (char32_t c = 0x3248; c <= 0x324F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (393:29): [True: 8, False: 1]
  ------------------
  394|      1|  (*smap)[0x3250] = U_Common;
  395|     16|  for (char32_t c = 0x3251; c <= 0x325F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (395:29): [True: 15, False: 1]
  ------------------
  396|      1|  (*smap)[0x327F] = U_Common;
  397|     11|  for (char32_t c = 0x3280; c <= 0x3289; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (397:29): [True: 10, False: 1]
  ------------------
  398|     40|  for (char32_t c = 0x328A; c <= 0x32B0; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (398:29): [True: 39, False: 1]
  ------------------
  399|     16|  for (char32_t c = 0x32B1; c <= 0x32BF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (399:29): [True: 15, False: 1]
  ------------------
  400|     17|  for (char32_t c = 0x32C0; c <= 0x32CF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (400:29): [True: 16, False: 1]
  ------------------
  401|    169|  for (char32_t c = 0x3358; c <= 0x33FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (401:29): [True: 168, False: 1]
  ------------------
  402|     65|  for (char32_t c = 0x4DC0; c <= 0x4DFF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (402:29): [True: 64, False: 1]
  ------------------
  403|     24|  for (char32_t c = 0xA700; c <= 0xA716; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (403:29): [True: 23, False: 1]
  ------------------
  404|     10|  for (char32_t c = 0xA717; c <= 0xA71F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (404:29): [True: 9, False: 1]
  ------------------
  405|      3|  for (char32_t c = 0xA720; c <= 0xA721; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (405:29): [True: 2, False: 1]
  ------------------
  406|      1|  (*smap)[0xA788] = U_Common;
  407|      3|  for (char32_t c = 0xA789; c <= 0xA78A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (407:29): [True: 2, False: 1]
  ------------------
  408|      7|  for (char32_t c = 0xA830; c <= 0xA835; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (408:29): [True: 6, False: 1]
  ------------------
  409|      3|  for (char32_t c = 0xA836; c <= 0xA837; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (409:29): [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_t c = 0xFE10; c <= 0xFE16; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (417:29): [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_t c = 0xFE31; c <= 0xFE32; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (422:29): [True: 2, False: 1]
  ------------------
  423|      3|  for (char32_t c = 0xFE33; c <= 0xFE34; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (423:29): [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_t c = 0xFE45; c <= 0xFE46; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (440:29): [True: 2, False: 1]
  ------------------
  441|      1|  (*smap)[0xFE47] = U_Common;
  442|      1|  (*smap)[0xFE48] = U_Common;
  443|      5|  for (char32_t c = 0xFE49; c <= 0xFE4C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (443:29): [True: 4, False: 1]
  ------------------
  444|      4|  for (char32_t c = 0xFE4D; c <= 0xFE4F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (444:29): [True: 3, False: 1]
  ------------------
  445|      4|  for (char32_t c = 0xFE50; c <= 0xFE52; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (445:29): [True: 3, False: 1]
  ------------------
  446|      5|  for (char32_t c = 0xFE54; c <= 0xFE57; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (446:29): [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_t c = 0xFE5F; c <= 0xFE61; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (454:29): [True: 3, False: 1]
  ------------------
  455|      1|  (*smap)[0xFE62] = U_Common;
  456|      1|  (*smap)[0xFE63] = U_Common;
  457|      4|  for (char32_t c = 0xFE64; c <= 0xFE66; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (457:29): [True: 3, False: 1]
  ------------------
  458|      1|  (*smap)[0xFE68] = U_Common;
  459|      1|  (*smap)[0xFE69] = U_Common;
  460|      3|  for (char32_t c = 0xFE6A; c <= 0xFE6B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (460:29): [True: 2, False: 1]
  ------------------
  461|      1|  (*smap)[0xFEFF] = U_Common;
  462|      4|  for (char32_t c = 0xFF01; c <= 0xFF03; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (462:29): [True: 3, False: 1]
  ------------------
  463|      1|  (*smap)[0xFF04] = U_Common;
  464|      4|  for (char32_t c = 0xFF05; c <= 0xFF07; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (464:29): [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_t c = 0xFF0E; c <= 0xFF0F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (471:29): [True: 2, False: 1]
  ------------------
  472|     11|  for (char32_t c = 0xFF10; c <= 0xFF19; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (472:29): [True: 10, False: 1]
  ------------------
  473|      3|  for (char32_t c = 0xFF1A; c <= 0xFF1B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (473:29): [True: 2, False: 1]
  ------------------
  474|      4|  for (char32_t c = 0xFF1C; c <= 0xFF1E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (474:29): [True: 3, False: 1]
  ------------------
  475|      3|  for (char32_t c = 0xFF1F; c <= 0xFF20; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (475:29): [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_t c = 0xFF64; c <= 0xFF65; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (491:29): [True: 2, False: 1]
  ------------------
  492|      1|  (*smap)[0xFF70] = U_Common;
  493|      3|  for (char32_t c = 0xFF9E; c <= 0xFF9F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (493:29): [True: 2, False: 1]
  ------------------
  494|      3|  for (char32_t c = 0xFFE0; c <= 0xFFE1; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (494:29): [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_t c = 0xFFE5; c <= 0xFFE6; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (498:29): [True: 2, False: 1]
  ------------------
  499|      1|  (*smap)[0xFFE8] = U_Common;
  500|      5|  for (char32_t c = 0xFFE9; c <= 0xFFEC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (500:29): [True: 4, False: 1]
  ------------------
  501|      3|  for (char32_t c = 0xFFED; c <= 0xFFEE; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (501:29): [True: 2, False: 1]
  ------------------
  502|      4|  for (char32_t c = 0xFFF9; c <= 0xFFFB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (502:29): [True: 3, False: 1]
  ------------------
  503|      3|  for (char32_t c = 0xFFFC; c <= 0xFFFD; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (503:29): [True: 2, False: 1]
  ------------------
  504|      4|  for (char32_t c = 0x10100; c <= 0x10102; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (504:30): [True: 3, False: 1]
  ------------------
  505|     46|  for (char32_t c = 0x10107; c <= 0x10133; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (505:30): [True: 45, False: 1]
  ------------------
  506|     10|  for (char32_t c = 0x10137; c <= 0x1013F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (506:30): [True: 9, False: 1]
  ------------------
  507|     13|  for (char32_t c = 0x10190; c <= 0x1019B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (507:30): [True: 12, False: 1]
  ------------------
  508|     46|  for (char32_t c = 0x101D0; c <= 0x101FC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (508:30): [True: 45, False: 1]
  ------------------
  509|     28|  for (char32_t c = 0x102E1; c <= 0x102FB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (509:30): [True: 27, False: 1]
  ------------------
  510|      5|  for (char32_t c = 0x1BCA0; c <= 0x1BCA3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (510:30): [True: 4, False: 1]
  ------------------
  511|    247|  for (char32_t c = 0x1D000; c <= 0x1D0F5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (511:30): [True: 246, False: 1]
  ------------------
  512|     40|  for (char32_t c = 0x1D100; c <= 0x1D126; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (512:30): [True: 39, False: 1]
  ------------------
  513|     61|  for (char32_t c = 0x1D129; c <= 0x1D164; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (513:30): [True: 60, False: 1]
  ------------------
  514|      3|  for (char32_t c = 0x1D165; c <= 0x1D166; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (514:30): [True: 2, False: 1]
  ------------------
  515|      4|  for (char32_t c = 0x1D16A; c <= 0x1D16C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (515:30): [True: 3, False: 1]
  ------------------
  516|      7|  for (char32_t c = 0x1D16D; c <= 0x1D172; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (516:30): [True: 6, False: 1]
  ------------------
  517|      9|  for (char32_t c = 0x1D173; c <= 0x1D17A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (517:30): [True: 8, False: 1]
  ------------------
  518|      3|  for (char32_t c = 0x1D183; c <= 0x1D184; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (518:30): [True: 2, False: 1]
  ------------------
  519|     31|  for (char32_t c = 0x1D18C; c <= 0x1D1A9; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (519:30): [True: 30, False: 1]
  ------------------
  520|     60|  for (char32_t c = 0x1D1AE; c <= 0x1D1E8; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (520:30): [True: 59, False: 1]
  ------------------
  521|     88|  for (char32_t c = 0x1D300; c <= 0x1D356; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (521:30): [True: 87, False: 1]
  ------------------
  522|     19|  for (char32_t c = 0x1D360; c <= 0x1D371; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (522:30): [True: 18, False: 1]
  ------------------
  523|     86|  for (char32_t c = 0x1D400; c <= 0x1D454; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (523:30): [True: 85, False: 1]
  ------------------
  524|     72|  for (char32_t c = 0x1D456; c <= 0x1D49C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (524:30): [True: 71, False: 1]
  ------------------
  525|      3|  for (char32_t c = 0x1D49E; c <= 0x1D49F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (525:30): [True: 2, False: 1]
  ------------------
  526|      1|  (*smap)[0x1D4A2] = U_Common;
  527|      3|  for (char32_t c = 0x1D4A5; c <= 0x1D4A6; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (527:30): [True: 2, False: 1]
  ------------------
  528|      5|  for (char32_t c = 0x1D4A9; c <= 0x1D4AC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (528:30): [True: 4, False: 1]
  ------------------
  529|     13|  for (char32_t c = 0x1D4AE; c <= 0x1D4B9; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (529:30): [True: 12, False: 1]
  ------------------
  530|      1|  (*smap)[0x1D4BB] = U_Common;
  531|      8|  for (char32_t c = 0x1D4BD; c <= 0x1D4C3; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (531:30): [True: 7, False: 1]
  ------------------
  532|     66|  for (char32_t c = 0x1D4C5; c <= 0x1D505; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (532:30): [True: 65, False: 1]
  ------------------
  533|      5|  for (char32_t c = 0x1D507; c <= 0x1D50A; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (533:30): [True: 4, False: 1]
  ------------------
  534|      9|  for (char32_t c = 0x1D50D; c <= 0x1D514; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (534:30): [True: 8, False: 1]
  ------------------
  535|      8|  for (char32_t c = 0x1D516; c <= 0x1D51C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (535:30): [True: 7, False: 1]
  ------------------
  536|     29|  for (char32_t c = 0x1D51E; c <= 0x1D539; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (536:30): [True: 28, False: 1]
  ------------------
  537|      5|  for (char32_t c = 0x1D53B; c <= 0x1D53E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (537:30): [True: 4, False: 1]
  ------------------
  538|      6|  for (char32_t c = 0x1D540; c <= 0x1D544; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (538:30): [True: 5, False: 1]
  ------------------
  539|      1|  (*smap)[0x1D546] = U_Common;
  540|      8|  for (char32_t c = 0x1D54A; c <= 0x1D550; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (540:30): [True: 7, False: 1]
  ------------------
  541|    341|  for (char32_t c = 0x1D552; c <= 0x1D6A5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (541:30): [True: 340, False: 1]
  ------------------
  542|     26|  for (char32_t c = 0x1D6A8; c <= 0x1D6C0; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (542:30): [True: 25, False: 1]
  ------------------
  543|      1|  (*smap)[0x1D6C1] = U_Common;
  544|     26|  for (char32_t c = 0x1D6C2; c <= 0x1D6DA; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (544:30): [True: 25, False: 1]
  ------------------
  545|      1|  (*smap)[0x1D6DB] = U_Common;
  546|     32|  for (char32_t c = 0x1D6DC; c <= 0x1D6FA; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (546:30): [True: 31, False: 1]
  ------------------
  547|      1|  (*smap)[0x1D6FB] = U_Common;
  548|     26|  for (char32_t c = 0x1D6FC; c <= 0x1D714; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (548:30): [True: 25, False: 1]
  ------------------
  549|      1|  (*smap)[0x1D715] = U_Common;
  550|     32|  for (char32_t c = 0x1D716; c <= 0x1D734; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (550:30): [True: 31, False: 1]
  ------------------
  551|      1|  (*smap)[0x1D735] = U_Common;
  552|     26|  for (char32_t c = 0x1D736; c <= 0x1D74E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (552:30): [True: 25, False: 1]
  ------------------
  553|      1|  (*smap)[0x1D74F] = U_Common;
  554|     32|  for (char32_t c = 0x1D750; c <= 0x1D76E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (554:30): [True: 31, False: 1]
  ------------------
  555|      1|  (*smap)[0x1D76F] = U_Common;
  556|     26|  for (char32_t c = 0x1D770; c <= 0x1D788; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (556:30): [True: 25, False: 1]
  ------------------
  557|      1|  (*smap)[0x1D789] = U_Common;
  558|     32|  for (char32_t c = 0x1D78A; c <= 0x1D7A8; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (558:30): [True: 31, False: 1]
  ------------------
  559|      1|  (*smap)[0x1D7A9] = U_Common;
  560|     26|  for (char32_t c = 0x1D7AA; c <= 0x1D7C2; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (560:30): [True: 25, False: 1]
  ------------------
  561|      1|  (*smap)[0x1D7C3] = U_Common;
  562|      9|  for (char32_t c = 0x1D7C4; c <= 0x1D7CB; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (562:30): [True: 8, False: 1]
  ------------------
  563|     51|  for (char32_t c = 0x1D7CE; c <= 0x1D7FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (563:30): [True: 50, False: 1]
  ------------------
  564|     45|  for (char32_t c = 0x1F000; c <= 0x1F02B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (564:30): [True: 44, False: 1]
  ------------------
  565|    101|  for (char32_t c = 0x1F030; c <= 0x1F093; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (565:30): [True: 100, False: 1]
  ------------------
  566|     16|  for (char32_t c = 0x1F0A0; c <= 0x1F0AE; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (566:30): [True: 15, False: 1]
  ------------------
  567|     16|  for (char32_t c = 0x1F0B1; c <= 0x1F0BF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (567:30): [True: 15, False: 1]
  ------------------
  568|     16|  for (char32_t c = 0x1F0C1; c <= 0x1F0CF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (568:30): [True: 15, False: 1]
  ------------------
  569|     38|  for (char32_t c = 0x1F0D1; c <= 0x1F0F5; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (569:30): [True: 37, False: 1]
  ------------------
  570|     14|  for (char32_t c = 0x1F100; c <= 0x1F10C; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (570:30): [True: 13, False: 1]
  ------------------
  571|     32|  for (char32_t c = 0x1F110; c <= 0x1F12E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (571:30): [True: 31, False: 1]
  ------------------
  572|     61|  for (char32_t c = 0x1F130; c <= 0x1F16B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (572:30): [True: 60, False: 1]
  ------------------
  573|     62|  for (char32_t c = 0x1F170; c <= 0x1F1AC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (573:30): [True: 61, False: 1]
  ------------------
  574|     27|  for (char32_t c = 0x1F1E6; c <= 0x1F1FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (574:30): [True: 26, False: 1]
  ------------------
  575|      3|  for (char32_t c = 0x1F201; c <= 0x1F202; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (575:30): [True: 2, False: 1]
  ------------------
  576|     45|  for (char32_t c = 0x1F210; c <= 0x1F23B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (576:30): [True: 44, False: 1]
  ------------------
  577|     10|  for (char32_t c = 0x1F240; c <= 0x1F248; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (577:30): [True: 9, False: 1]
  ------------------
  578|      3|  for (char32_t c = 0x1F250; c <= 0x1F251; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (578:30): [True: 2, False: 1]
  ------------------
  579|    252|  for (char32_t c = 0x1F300; c <= 0x1F3FA; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (579:30): [True: 251, False: 1]
  ------------------
  580|      6|  for (char32_t c = 0x1F3FB; c <= 0x1F3FF; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (580:30): [True: 5, False: 1]
  ------------------
  581|    724|  for (char32_t c = 0x1F400; c <= 0x1F6D2; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (581:30): [True: 723, False: 1]
  ------------------
  582|     14|  for (char32_t c = 0x1F6E0; c <= 0x1F6EC; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (582:30): [True: 13, False: 1]
  ------------------
  583|      8|  for (char32_t c = 0x1F6F0; c <= 0x1F6F6; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (583:30): [True: 7, False: 1]
  ------------------
  584|    117|  for (char32_t c = 0x1F700; c <= 0x1F773; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (584:30): [True: 116, False: 1]
  ------------------
  585|     86|  for (char32_t c = 0x1F780; c <= 0x1F7D4; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (585:30): [True: 85, False: 1]
  ------------------
  586|     13|  for (char32_t c = 0x1F800; c <= 0x1F80B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (586:30): [True: 12, False: 1]
  ------------------
  587|     57|  for (char32_t c = 0x1F810; c <= 0x1F847; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (587:30): [True: 56, False: 1]
  ------------------
  588|     11|  for (char32_t c = 0x1F850; c <= 0x1F859; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (588:30): [True: 10, False: 1]
  ------------------
  589|     41|  for (char32_t c = 0x1F860; c <= 0x1F887; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (589:30): [True: 40, False: 1]
  ------------------
  590|     31|  for (char32_t c = 0x1F890; c <= 0x1F8AD; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (590:30): [True: 30, False: 1]
  ------------------
  591|     16|  for (char32_t c = 0x1F910; c <= 0x1F91E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (591:30): [True: 15, False: 1]
  ------------------
  592|      9|  for (char32_t c = 0x1F920; c <= 0x1F927; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (592:30): [True: 8, False: 1]
  ------------------
  593|      1|  (*smap)[0x1F930] = U_Common;
  594|     13|  for (char32_t c = 0x1F933; c <= 0x1F93E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (594:30): [True: 12, False: 1]
  ------------------
  595|     13|  for (char32_t c = 0x1F940; c <= 0x1F94B; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (595:30): [True: 12, False: 1]
  ------------------
  596|     16|  for (char32_t c = 0x1F950; c <= 0x1F95E; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (596:30): [True: 15, False: 1]
  ------------------
  597|     19|  for (char32_t c = 0x1F980; c <= 0x1F991; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (597:30): [True: 18, False: 1]
  ------------------
  598|      1|  (*smap)[0x1F9C0] = U_Common;
  599|      1|  (*smap)[0xE0001] = U_Common;
  600|     97|  for (char32_t c = 0xE0020; c <= 0xE007F; ++c) (*smap)[c] = U_Common;
  ------------------
  |  Branch (600:30): [True: 96, False: 1]
  ------------------
  601|     27|  for (char32_t c = 0x0041; c <= 0x005A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (601:29): [True: 26, False: 1]
  ------------------
  602|     27|  for (char32_t c = 0x0061; c <= 0x007A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (602:29): [True: 26, False: 1]
  ------------------
  603|      1|  (*smap)[0x00AA] = U_Latin;
  604|      1|  (*smap)[0x00BA] = U_Latin;
  605|     24|  for (char32_t c = 0x00C0; c <= 0x00D6; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (605:29): [True: 23, False: 1]
  ------------------
  606|     32|  for (char32_t c = 0x00D8; c <= 0x00F6; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (606:29): [True: 31, False: 1]
  ------------------
  607|    196|  for (char32_t c = 0x00F8; c <= 0x01BA; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (607:29): [True: 195, False: 1]
  ------------------
  608|      1|  (*smap)[0x01BB] = U_Latin;
  609|      5|  for (char32_t c = 0x01BC; c <= 0x01BF; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (609:29): [True: 4, False: 1]
  ------------------
  610|      5|  for (char32_t c = 0x01C0; c <= 0x01C3; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (610:29): [True: 4, False: 1]
  ------------------
  611|    209|  for (char32_t c = 0x01C4; c <= 0x0293; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (611:29): [True: 208, False: 1]
  ------------------
  612|      1|  (*smap)[0x0294] = U_Latin;
  613|     28|  for (char32_t c = 0x0295; c <= 0x02AF; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (613:29): [True: 27, False: 1]
  ------------------
  614|     10|  for (char32_t c = 0x02B0; c <= 0x02B8; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (614:29): [True: 9, False: 1]
  ------------------
  615|      6|  for (char32_t c = 0x02E0; c <= 0x02E4; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (615:29): [True: 5, False: 1]
  ------------------
  616|     39|  for (char32_t c = 0x1D00; c <= 0x1D25; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (616:29): [True: 38, False: 1]
  ------------------
  617|     50|  for (char32_t c = 0x1D2C; c <= 0x1D5C; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (617:29): [True: 49, False: 1]
  ------------------
  618|      5|  for (char32_t c = 0x1D62; c <= 0x1D65; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (618:29): [True: 4, False: 1]
  ------------------
  619|     14|  for (char32_t c = 0x1D6B; c <= 0x1D77; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (619:29): [True: 13, False: 1]
  ------------------
  620|     35|  for (char32_t c = 0x1D79; c <= 0x1D9A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (620:29): [True: 34, False: 1]
  ------------------
  621|     37|  for (char32_t c = 0x1D9B; c <= 0x1DBE; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (621:29): [True: 36, False: 1]
  ------------------
  622|    257|  for (char32_t c = 0x1E00; c <= 0x1EFF; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (622:29): [True: 256, False: 1]
  ------------------
  623|      1|  (*smap)[0x2071] = U_Latin;
  624|      1|  (*smap)[0x207F] = U_Latin;
  625|     14|  for (char32_t c = 0x2090; c <= 0x209C; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (625:29): [True: 13, False: 1]
  ------------------
  626|      3|  for (char32_t c = 0x212A; c <= 0x212B; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (626:29): [True: 2, False: 1]
  ------------------
  627|      1|  (*smap)[0x2132] = U_Latin;
  628|      1|  (*smap)[0x214E] = U_Latin;
  629|     36|  for (char32_t c = 0x2160; c <= 0x2182; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (629:29): [True: 35, False: 1]
  ------------------
  630|      3|  for (char32_t c = 0x2183; c <= 0x2184; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (630:29): [True: 2, False: 1]
  ------------------
  631|      5|  for (char32_t c = 0x2185; c <= 0x2188; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (631:29): [True: 4, False: 1]
  ------------------
  632|     29|  for (char32_t c = 0x2C60; c <= 0x2C7B; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (632:29): [True: 28, False: 1]
  ------------------
  633|      3|  for (char32_t c = 0x2C7C; c <= 0x2C7D; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (633:29): [True: 2, False: 1]
  ------------------
  634|      3|  for (char32_t c = 0x2C7E; c <= 0x2C7F; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (634:29): [True: 2, False: 1]
  ------------------
  635|     79|  for (char32_t c = 0xA722; c <= 0xA76F; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (635:29): [True: 78, False: 1]
  ------------------
  636|      1|  (*smap)[0xA770] = U_Latin;
  637|     24|  for (char32_t c = 0xA771; c <= 0xA787; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (637:29): [True: 23, False: 1]
  ------------------
  638|      5|  for (char32_t c = 0xA78B; c <= 0xA78E; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (638:29): [True: 4, False: 1]
  ------------------
  639|      1|  (*smap)[0xA78F] = U_Latin;
  640|     32|  for (char32_t c = 0xA790; c <= 0xA7AE; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (640:29): [True: 31, False: 1]
  ------------------
  641|      9|  for (char32_t c = 0xA7B0; c <= 0xA7B7; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (641:29): [True: 8, False: 1]
  ------------------
  642|      1|  (*smap)[0xA7F7] = U_Latin;
  643|      3|  for (char32_t c = 0xA7F8; c <= 0xA7F9; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (643:29): [True: 2, False: 1]
  ------------------
  644|      1|  (*smap)[0xA7FA] = U_Latin;
  645|      6|  for (char32_t c = 0xA7FB; c <= 0xA7FF; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (645:29): [True: 5, False: 1]
  ------------------
  646|     44|  for (char32_t c = 0xAB30; c <= 0xAB5A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (646:29): [True: 43, False: 1]
  ------------------
  647|      5|  for (char32_t c = 0xAB5C; c <= 0xAB5F; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (647:29): [True: 4, False: 1]
  ------------------
  648|      6|  for (char32_t c = 0xAB60; c <= 0xAB64; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (648:29): [True: 5, False: 1]
  ------------------
  649|      8|  for (char32_t c = 0xFB00; c <= 0xFB06; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (649:29): [True: 7, False: 1]
  ------------------
  650|     27|  for (char32_t c = 0xFF21; c <= 0xFF3A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (650:29): [True: 26, False: 1]
  ------------------
  651|     27|  for (char32_t c = 0xFF41; c <= 0xFF5A; ++c) (*smap)[c] = U_Latin;
  ------------------
  |  Branch (651:29): [True: 26, False: 1]
  ------------------
  652|      5|  for (char32_t c = 0x0370; c <= 0x0373; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (652:29): [True: 4, False: 1]
  ------------------
  653|      1|  (*smap)[0x0375] = U_Greek;
  654|      3|  for (char32_t c = 0x0376; c <= 0x0377; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (654:29): [True: 2, False: 1]
  ------------------
  655|      1|  (*smap)[0x037A] = U_Greek;
  656|      4|  for (char32_t c = 0x037B; c <= 0x037D; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (656:29): [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_t c = 0x0388; c <= 0x038A; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (660:29): [True: 3, False: 1]
  ------------------
  661|      1|  (*smap)[0x038C] = U_Greek;
  662|     21|  for (char32_t c = 0x038E; c <= 0x03A1; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (662:29): [True: 20, False: 1]
  ------------------
  663|     64|  for (char32_t c = 0x03A3; c <= 0x03E1; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (663:29): [True: 63, False: 1]
  ------------------
  664|      7|  for (char32_t c = 0x03F0; c <= 0x03F5; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (664:29): [True: 6, False: 1]
  ------------------
  665|      1|  (*smap)[0x03F6] = U_Greek;
  666|     10|  for (char32_t c = 0x03F7; c <= 0x03FF; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (666:29): [True: 9, False: 1]
  ------------------
  667|      6|  for (char32_t c = 0x1D26; c <= 0x1D2A; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (667:29): [True: 5, False: 1]
  ------------------
  668|      6|  for (char32_t c = 0x1D5D; c <= 0x1D61; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (668:29): [True: 5, False: 1]
  ------------------
  669|      6|  for (char32_t c = 0x1D66; c <= 0x1D6A; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (669:29): [True: 5, False: 1]
  ------------------
  670|      1|  (*smap)[0x1DBF] = U_Greek;
  671|     23|  for (char32_t c = 0x1F00; c <= 0x1F15; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (671:29): [True: 22, False: 1]
  ------------------
  672|      7|  for (char32_t c = 0x1F18; c <= 0x1F1D; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (672:29): [True: 6, False: 1]
  ------------------
  673|     39|  for (char32_t c = 0x1F20; c <= 0x1F45; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (673:29): [True: 38, False: 1]
  ------------------
  674|      7|  for (char32_t c = 0x1F48; c <= 0x1F4D; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (674:29): [True: 6, False: 1]
  ------------------
  675|      9|  for (char32_t c = 0x1F50; c <= 0x1F57; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (675:29): [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_t c = 0x1F5F; c <= 0x1F7D; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (679:29): [True: 31, False: 1]
  ------------------
  680|     54|  for (char32_t c = 0x1F80; c <= 0x1FB4; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (680:29): [True: 53, False: 1]
  ------------------
  681|      8|  for (char32_t c = 0x1FB6; c <= 0x1FBC; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (681:29): [True: 7, False: 1]
  ------------------
  682|      1|  (*smap)[0x1FBD] = U_Greek;
  683|      1|  (*smap)[0x1FBE] = U_Greek;
  684|      4|  for (char32_t c = 0x1FBF; c <= 0x1FC1; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (684:29): [True: 3, False: 1]
  ------------------
  685|      4|  for (char32_t c = 0x1FC2; c <= 0x1FC4; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (685:29): [True: 3, False: 1]
  ------------------
  686|      8|  for (char32_t c = 0x1FC6; c <= 0x1FCC; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (686:29): [True: 7, False: 1]
  ------------------
  687|      4|  for (char32_t c = 0x1FCD; c <= 0x1FCF; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (687:29): [True: 3, False: 1]
  ------------------
  688|      5|  for (char32_t c = 0x1FD0; c <= 0x1FD3; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (688:29): [True: 4, False: 1]
  ------------------
  689|      7|  for (char32_t c = 0x1FD6; c <= 0x1FDB; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (689:29): [True: 6, False: 1]
  ------------------
  690|      4|  for (char32_t c = 0x1FDD; c <= 0x1FDF; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (690:29): [True: 3, False: 1]
  ------------------
  691|     14|  for (char32_t c = 0x1FE0; c <= 0x1FEC; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (691:29): [True: 13, False: 1]
  ------------------
  692|      4|  for (char32_t c = 0x1FED; c <= 0x1FEF; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (692:29): [True: 3, False: 1]
  ------------------
  693|      4|  for (char32_t c = 0x1FF2; c <= 0x1FF4; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (693:29): [True: 3, False: 1]
  ------------------
  694|      8|  for (char32_t c = 0x1FF6; c <= 0x1FFC; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (694:29): [True: 7, False: 1]
  ------------------
  695|      3|  for (char32_t c = 0x1FFD; c <= 0x1FFE; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (695:29): [True: 2, False: 1]
  ------------------
  696|      1|  (*smap)[0x2126] = U_Greek;
  697|      1|  (*smap)[0xAB65] = U_Greek;
  698|     54|  for (char32_t c = 0x10140; c <= 0x10174; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (698:30): [True: 53, False: 1]
  ------------------
  699|      5|  for (char32_t c = 0x10175; c <= 0x10178; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (699:30): [True: 4, False: 1]
  ------------------
  700|     18|  for (char32_t c = 0x10179; c <= 0x10189; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (700:30): [True: 17, False: 1]
  ------------------
  701|      3|  for (char32_t c = 0x1018A; c <= 0x1018B; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (701:30): [True: 2, False: 1]
  ------------------
  702|      4|  for (char32_t c = 0x1018C; c <= 0x1018E; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (702:30): [True: 3, False: 1]
  ------------------
  703|      1|  (*smap)[0x101A0] = U_Greek;
  704|     67|  for (char32_t c = 0x1D200; c <= 0x1D241; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (704:30): [True: 66, False: 1]
  ------------------
  705|      4|  for (char32_t c = 0x1D242; c <= 0x1D244; ++c) (*smap)[c] = U_Greek;
  ------------------
  |  Branch (705:30): [True: 3, False: 1]
  ------------------
  706|      1|  (*smap)[0x1D245] = U_Greek;
  707|    131|  for (char32_t c = 0x0400; c <= 0x0481; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (707:29): [True: 130, False: 1]
  ------------------
  708|      1|  (*smap)[0x0482] = U_Cyrillic;
  709|      3|  for (char32_t c = 0x0483; c <= 0x0484; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (709:29): [True: 2, False: 1]
  ------------------
  710|      1|  (*smap)[0x0487] = U_Cyrillic;
  711|      3|  for (char32_t c = 0x0488; c <= 0x0489; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (711:29): [True: 2, False: 1]
  ------------------
  712|    167|  for (char32_t c = 0x048A; c <= 0x052F; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (712:29): [True: 166, False: 1]
  ------------------
  713|     10|  for (char32_t c = 0x1C80; c <= 0x1C88; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (713:29): [True: 9, False: 1]
  ------------------
  714|      1|  (*smap)[0x1D2B] = U_Cyrillic;
  715|      1|  (*smap)[0x1D78] = U_Cyrillic;
  716|     33|  for (char32_t c = 0x2DE0; c <= 0x2DFF; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (716:29): [True: 32, False: 1]
  ------------------
  717|     47|  for (char32_t c = 0xA640; c <= 0xA66D; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (717:29): [True: 46, False: 1]
  ------------------
  718|      1|  (*smap)[0xA66E] = U_Cyrillic;
  719|      1|  (*smap)[0xA66F] = U_Cyrillic;
  720|      4|  for (char32_t c = 0xA670; c <= 0xA672; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (720:29): [True: 3, False: 1]
  ------------------
  721|      1|  (*smap)[0xA673] = U_Cyrillic;
  722|     11|  for (char32_t c = 0xA674; c <= 0xA67D; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (722:29): [True: 10, False: 1]
  ------------------
  723|      1|  (*smap)[0xA67E] = U_Cyrillic;
  724|      1|  (*smap)[0xA67F] = U_Cyrillic;
  725|     29|  for (char32_t c = 0xA680; c <= 0xA69B; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (725:29): [True: 28, False: 1]
  ------------------
  726|      3|  for (char32_t c = 0xA69C; c <= 0xA69D; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (726:29): [True: 2, False: 1]
  ------------------
  727|      3|  for (char32_t c = 0xA69E; c <= 0xA69F; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (727:29): [True: 2, False: 1]
  ------------------
  728|      3|  for (char32_t c = 0xFE2E; c <= 0xFE2F; ++c) (*smap)[c] = U_Cyrillic;
  ------------------
  |  Branch (728:29): [True: 2, False: 1]
  ------------------
  729|     39|  for (char32_t c = 0x0531; c <= 0x0556; ++c) (*smap)[c] = U_Armenian;
  ------------------
  |  Branch (729:29): [True: 38, False: 1]
  ------------------
  730|      1|  (*smap)[0x0559] = U_Armenian;
  731|      7|  for (char32_t c = 0x055A; c <= 0x055F; ++c) (*smap)[c] = U_Armenian;
  ------------------
  |  Branch (731:29): [True: 6, False: 1]
  ------------------
  732|     40|  for (char32_t c = 0x0561; c <= 0x0587; ++c) (*smap)[c] = U_Armenian;
  ------------------
  |  Branch (732:29): [True: 39, False: 1]
  ------------------
  733|      1|  (*smap)[0x058A] = U_Armenian;
  734|      3|  for (char32_t c = 0x058D; c <= 0x058E; ++c) (*smap)[c] = U_Armenian;
  ------------------
  |  Branch (734:29): [True: 2, False: 1]
  ------------------
  735|      1|  (*smap)[0x058F] = U_Armenian;
  736|      6|  for (char32_t c = 0xFB13; c <= 0xFB17; ++c) (*smap)[c] = U_Armenian;
  ------------------
  |  Branch (736:29): [True: 5, False: 1]
  ------------------
  737|     46|  for (char32_t c = 0x0591; c <= 0x05BD; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (737:29): [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_t c = 0x05C1; c <= 0x05C2; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (741:29): [True: 2, False: 1]
  ------------------
  742|      1|  (*smap)[0x05C3] = U_Hebrew;
  743|      3|  for (char32_t c = 0x05C4; c <= 0x05C5; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (743:29): [True: 2, False: 1]
  ------------------
  744|      1|  (*smap)[0x05C6] = U_Hebrew;
  745|      1|  (*smap)[0x05C7] = U_Hebrew;
  746|     28|  for (char32_t c = 0x05D0; c <= 0x05EA; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (746:29): [True: 27, False: 1]
  ------------------
  747|      4|  for (char32_t c = 0x05F0; c <= 0x05F2; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (747:29): [True: 3, False: 1]
  ------------------
  748|      3|  for (char32_t c = 0x05F3; c <= 0x05F4; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (748:29): [True: 2, False: 1]
  ------------------
  749|      1|  (*smap)[0xFB1D] = U_Hebrew;
  750|      1|  (*smap)[0xFB1E] = U_Hebrew;
  751|     11|  for (char32_t c = 0xFB1F; c <= 0xFB28; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (751:29): [True: 10, False: 1]
  ------------------
  752|      1|  (*smap)[0xFB29] = U_Hebrew;
  753|     14|  for (char32_t c = 0xFB2A; c <= 0xFB36; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (753:29): [True: 13, False: 1]
  ------------------
  754|      6|  for (char32_t c = 0xFB38; c <= 0xFB3C; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (754:29): [True: 5, False: 1]
  ------------------
  755|      1|  (*smap)[0xFB3E] = U_Hebrew;
  756|      3|  for (char32_t c = 0xFB40; c <= 0xFB41; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (756:29): [True: 2, False: 1]
  ------------------
  757|      3|  for (char32_t c = 0xFB43; c <= 0xFB44; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (757:29): [True: 2, False: 1]
  ------------------
  758|     11|  for (char32_t c = 0xFB46; c <= 0xFB4F; ++c) (*smap)[c] = U_Hebrew;
  ------------------
  |  Branch (758:29): [True: 10, False: 1]
  ------------------
  759|      6|  for (char32_t c = 0x0600; c <= 0x0604; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (759:29): [True: 5, False: 1]
  ------------------
  760|      4|  for (char32_t c = 0x0606; c <= 0x0608; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (760:29): [True: 3, False: 1]
  ------------------
  761|      3|  for (char32_t c = 0x0609; c <= 0x060A; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (761:29): [True: 2, False: 1]
  ------------------
  762|      1|  (*smap)[0x060B] = U_Arabic;
  763|      1|  (*smap)[0x060D] = U_Arabic;
  764|      3|  for (char32_t c = 0x060E; c <= 0x060F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (764:29): [True: 2, False: 1]
  ------------------
  765|     12|  for (char32_t c = 0x0610; c <= 0x061A; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (765:29): [True: 11, False: 1]
  ------------------
  766|      1|  (*smap)[0x061E] = U_Arabic;
  767|     33|  for (char32_t c = 0x0620; c <= 0x063F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (767:29): [True: 32, False: 1]
  ------------------
  768|     11|  for (char32_t c = 0x0641; c <= 0x064A; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (768:29): [True: 10, False: 1]
  ------------------
  769|     11|  for (char32_t c = 0x0656; c <= 0x065F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (769:29): [True: 10, False: 1]
  ------------------
  770|     11|  for (char32_t c = 0x0660; c <= 0x0669; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (770:29): [True: 10, False: 1]
  ------------------
  771|      5|  for (char32_t c = 0x066A; c <= 0x066D; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (771:29): [True: 4, False: 1]
  ------------------
  772|      3|  for (char32_t c = 0x066E; c <= 0x066F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (772:29): [True: 2, False: 1]
  ------------------
  773|    100|  for (char32_t c = 0x0671; c <= 0x06D3; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (773:29): [True: 99, False: 1]
  ------------------
  774|      1|  (*smap)[0x06D4] = U_Arabic;
  775|      1|  (*smap)[0x06D5] = U_Arabic;
  776|      8|  for (char32_t c = 0x06D6; c <= 0x06DC; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (776:29): [True: 7, False: 1]
  ------------------
  777|      1|  (*smap)[0x06DE] = U_Arabic;
  778|      7|  for (char32_t c = 0x06DF; c <= 0x06E4; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (778:29): [True: 6, False: 1]
  ------------------
  779|      3|  for (char32_t c = 0x06E5; c <= 0x06E6; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (779:29): [True: 2, False: 1]
  ------------------
  780|      3|  for (char32_t c = 0x06E7; c <= 0x06E8; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (780:29): [True: 2, False: 1]
  ------------------
  781|      1|  (*smap)[0x06E9] = U_Arabic;
  782|      5|  for (char32_t c = 0x06EA; c <= 0x06ED; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (782:29): [True: 4, False: 1]
  ------------------
  783|      3|  for (char32_t c = 0x06EE; c <= 0x06EF; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (783:29): [True: 2, False: 1]
  ------------------
  784|     11|  for (char32_t c = 0x06F0; c <= 0x06F9; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (784:29): [True: 10, False: 1]
  ------------------
  785|      4|  for (char32_t c = 0x06FA; c <= 0x06FC; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (785:29): [True: 3, False: 1]
  ------------------
  786|      3|  for (char32_t c = 0x06FD; c <= 0x06FE; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (786:29): [True: 2, False: 1]
  ------------------
  787|      1|  (*smap)[0x06FF] = U_Arabic;
  788|     49|  for (char32_t c = 0x0750; c <= 0x077F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (788:29): [True: 48, False: 1]
  ------------------
  789|     22|  for (char32_t c = 0x08A0; c <= 0x08B4; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (789:29): [True: 21, False: 1]
  ------------------
  790|      9|  for (char32_t c = 0x08B6; c <= 0x08BD; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (790:29): [True: 8, False: 1]
  ------------------
  791|     15|  for (char32_t c = 0x08D4; c <= 0x08E1; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (791:29): [True: 14, False: 1]
  ------------------
  792|     30|  for (char32_t c = 0x08E3; c <= 0x08FF; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (792:29): [True: 29, False: 1]
  ------------------
  793|     99|  for (char32_t c = 0xFB50; c <= 0xFBB1; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (793:29): [True: 98, False: 1]
  ------------------
  794|     17|  for (char32_t c = 0xFBB2; c <= 0xFBC1; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (794:29): [True: 16, False: 1]
  ------------------
  795|    364|  for (char32_t c = 0xFBD3; c <= 0xFD3D; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (795:29): [True: 363, False: 1]
  ------------------
  796|     65|  for (char32_t c = 0xFD50; c <= 0xFD8F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (796:29): [True: 64, False: 1]
  ------------------
  797|     55|  for (char32_t c = 0xFD92; c <= 0xFDC7; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (797:29): [True: 54, False: 1]
  ------------------
  798|     13|  for (char32_t c = 0xFDF0; c <= 0xFDFB; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (798:29): [True: 12, False: 1]
  ------------------
  799|      1|  (*smap)[0xFDFC] = U_Arabic;
  800|      1|  (*smap)[0xFDFD] = U_Arabic;
  801|      6|  for (char32_t c = 0xFE70; c <= 0xFE74; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (801:29): [True: 5, False: 1]
  ------------------
  802|    136|  for (char32_t c = 0xFE76; c <= 0xFEFC; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (802:29): [True: 135, False: 1]
  ------------------
  803|     32|  for (char32_t c = 0x10E60; c <= 0x10E7E; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (803:30): [True: 31, False: 1]
  ------------------
  804|      5|  for (char32_t c = 0x1EE00; c <= 0x1EE03; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (804:30): [True: 4, False: 1]
  ------------------
  805|     28|  for (char32_t c = 0x1EE05; c <= 0x1EE1F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (805:30): [True: 27, False: 1]
  ------------------
  806|      3|  for (char32_t c = 0x1EE21; c <= 0x1EE22; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (806:30): [True: 2, False: 1]
  ------------------
  807|      1|  (*smap)[0x1EE24] = U_Arabic;
  808|      1|  (*smap)[0x1EE27] = U_Arabic;
  809|     11|  for (char32_t c = 0x1EE29; c <= 0x1EE32; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (809:30): [True: 10, False: 1]
  ------------------
  810|      5|  for (char32_t c = 0x1EE34; c <= 0x1EE37; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (810:30): [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_t c = 0x1EE4D; c <= 0x1EE4F; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (817:30): [True: 3, False: 1]
  ------------------
  818|      3|  for (char32_t c = 0x1EE51; c <= 0x1EE52; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (818:30): [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_t c = 0x1EE61; c <= 0x1EE62; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (825:30): [True: 2, False: 1]
  ------------------
  826|      1|  (*smap)[0x1EE64] = U_Arabic;
  827|      5|  for (char32_t c = 0x1EE67; c <= 0x1EE6A; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (827:30): [True: 4, False: 1]
  ------------------
  828|      8|  for (char32_t c = 0x1EE6C; c <= 0x1EE72; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (828:30): [True: 7, False: 1]
  ------------------
  829|      5|  for (char32_t c = 0x1EE74; c <= 0x1EE77; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (829:30): [True: 4, False: 1]
  ------------------
  830|      5|  for (char32_t c = 0x1EE79; c <= 0x1EE7C; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (830:30): [True: 4, False: 1]
  ------------------
  831|      1|  (*smap)[0x1EE7E] = U_Arabic;
  832|     11|  for (char32_t c = 0x1EE80; c <= 0x1EE89; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (832:30): [True: 10, False: 1]
  ------------------
  833|     18|  for (char32_t c = 0x1EE8B; c <= 0x1EE9B; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (833:30): [True: 17, False: 1]
  ------------------
  834|      4|  for (char32_t c = 0x1EEA1; c <= 0x1EEA3; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (834:30): [True: 3, False: 1]
  ------------------
  835|      6|  for (char32_t c = 0x1EEA5; c <= 0x1EEA9; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (835:30): [True: 5, False: 1]
  ------------------
  836|     18|  for (char32_t c = 0x1EEAB; c <= 0x1EEBB; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (836:30): [True: 17, False: 1]
  ------------------
  837|      3|  for (char32_t c = 0x1EEF0; c <= 0x1EEF1; ++c) (*smap)[c] = U_Arabic;
  ------------------
  |  Branch (837:30): [True: 2, False: 1]
  ------------------
  838|     15|  for (char32_t c = 0x0700; c <= 0x070D; ++c) (*smap)[c] = U_Syriac;
  ------------------
  |  Branch (838:29): [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_t c = 0x0712; c <= 0x072F; ++c) (*smap)[c] = U_Syriac;
  ------------------
  |  Branch (842:29): [True: 30, False: 1]
  ------------------
  843|     28|  for (char32_t c = 0x0730; c <= 0x074A; ++c) (*smap)[c] = U_Syriac;
  ------------------
  |  Branch (843:29): [True: 27, False: 1]
  ------------------
  844|      4|  for (char32_t c = 0x074D; c <= 0x074F; ++c) (*smap)[c] = U_Syriac;
  ------------------
  |  Branch (844:29): [True: 3, False: 1]
  ------------------
  845|     39|  for (char32_t c = 0x0780; c <= 0x07A5; ++c) (*smap)[c] = U_Thaana;
  ------------------
  |  Branch (845:29): [True: 38, False: 1]
  ------------------
  846|     12|  for (char32_t c = 0x07A6; c <= 0x07B0; ++c) (*smap)[c] = U_Thaana;
  ------------------
  |  Branch (846:29): [True: 11, False: 1]
  ------------------
  847|      1|  (*smap)[0x07B1] = U_Thaana;
  848|      4|  for (char32_t c = 0x0900; c <= 0x0902; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (848:29): [True: 3, False: 1]
  ------------------
  849|      1|  (*smap)[0x0903] = U_Devanagari;
  850|     55|  for (char32_t c = 0x0904; c <= 0x0939; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (850:29): [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_t c = 0x093E; c <= 0x0940; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (855:29): [True: 3, False: 1]
  ------------------
  856|      9|  for (char32_t c = 0x0941; c <= 0x0948; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (856:29): [True: 8, False: 1]
  ------------------
  857|      5|  for (char32_t c = 0x0949; c <= 0x094C; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (857:29): [True: 4, False: 1]
  ------------------
  858|      1|  (*smap)[0x094D] = U_Devanagari;
  859|      3|  for (char32_t c = 0x094E; c <= 0x094F; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (859:29): [True: 2, False: 1]
  ------------------
  860|      1|  (*smap)[0x0950] = U_Devanagari;
  861|      6|  for (char32_t c = 0x0953; c <= 0x0957; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (861:29): [True: 5, False: 1]
  ------------------
  862|     11|  for (char32_t c = 0x0958; c <= 0x0961; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (862:29): [True: 10, False: 1]
  ------------------
  863|      3|  for (char32_t c = 0x0962; c <= 0x0963; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (863:29): [True: 2, False: 1]
  ------------------
  864|     11|  for (char32_t c = 0x0966; c <= 0x096F; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (864:29): [True: 10, False: 1]
  ------------------
  865|      1|  (*smap)[0x0970] = U_Devanagari;
  866|      1|  (*smap)[0x0971] = U_Devanagari;
  867|     15|  for (char32_t c = 0x0972; c <= 0x097F; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (867:29): [True: 14, False: 1]
  ------------------
  868|     19|  for (char32_t c = 0xA8E0; c <= 0xA8F1; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (868:29): [True: 18, False: 1]
  ------------------
  869|      7|  for (char32_t c = 0xA8F2; c <= 0xA8F7; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (869:29): [True: 6, False: 1]
  ------------------
  870|      4|  for (char32_t c = 0xA8F8; c <= 0xA8FA; ++c) (*smap)[c] = U_Devanagari;
  ------------------
  |  Branch (870:29): [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_t c = 0x0982; c <= 0x0983; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (876:29): [True: 2, False: 1]
  ------------------
  877|      9|  for (char32_t c = 0x0985; c <= 0x098C; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (877:29): [True: 8, False: 1]
  ------------------
  878|      3|  for (char32_t c = 0x098F; c <= 0x0990; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (878:29): [True: 2, False: 1]
  ------------------
  879|     23|  for (char32_t c = 0x0993; c <= 0x09A8; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (879:29): [True: 22, False: 1]
  ------------------
  880|      8|  for (char32_t c = 0x09AA; c <= 0x09B0; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (880:29): [True: 7, False: 1]
  ------------------
  881|      1|  (*smap)[0x09B2] = U_Bengali;
  882|      5|  for (char32_t c = 0x09B6; c <= 0x09B9; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (882:29): [True: 4, False: 1]
  ------------------
  883|      1|  (*smap)[0x09BC] = U_Bengali;
  884|      1|  (*smap)[0x09BD] = U_Bengali;
  885|      4|  for (char32_t c = 0x09BE; c <= 0x09C0; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (885:29): [True: 3, False: 1]
  ------------------
  886|      5|  for (char32_t c = 0x09C1; c <= 0x09C4; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (886:29): [True: 4, False: 1]
  ------------------
  887|      3|  for (char32_t c = 0x09C7; c <= 0x09C8; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (887:29): [True: 2, False: 1]
  ------------------
  888|      3|  for (char32_t c = 0x09CB; c <= 0x09CC; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (888:29): [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_t c = 0x09DC; c <= 0x09DD; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (892:29): [True: 2, False: 1]
  ------------------
  893|      4|  for (char32_t c = 0x09DF; c <= 0x09E1; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (893:29): [True: 3, False: 1]
  ------------------
  894|      3|  for (char32_t c = 0x09E2; c <= 0x09E3; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (894:29): [True: 2, False: 1]
  ------------------
  895|     11|  for (char32_t c = 0x09E6; c <= 0x09EF; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (895:29): [True: 10, False: 1]
  ------------------
  896|      3|  for (char32_t c = 0x09F0; c <= 0x09F1; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (896:29): [True: 2, False: 1]
  ------------------
  897|      3|  for (char32_t c = 0x09F2; c <= 0x09F3; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (897:29): [True: 2, False: 1]
  ------------------
  898|      7|  for (char32_t c = 0x09F4; c <= 0x09F9; ++c) (*smap)[c] = U_Bengali;
  ------------------
  |  Branch (898:29): [True: 6, False: 1]
  ------------------
  899|      1|  (*smap)[0x09FA] = U_Bengali;
  900|      1|  (*smap)[0x09FB] = U_Bengali;
  901|      3|  for (char32_t c = 0x0A01; c <= 0x0A02; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (901:29): [True: 2, False: 1]
  ------------------
  902|      1|  (*smap)[0x0A03] = U_Gurmukhi;
  903|      7|  for (char32_t c = 0x0A05; c <= 0x0A0A; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (903:29): [True: 6, False: 1]
  ------------------
  904|      3|  for (char32_t c = 0x0A0F; c <= 0x0A10; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (904:29): [True: 2, False: 1]
  ------------------
  905|     23|  for (char32_t c = 0x0A13; c <= 0x0A28; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (905:29): [True: 22, False: 1]
  ------------------
  906|      8|  for (char32_t c = 0x0A2A; c <= 0x0A30; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (906:29): [True: 7, False: 1]
  ------------------
  907|      3|  for (char32_t c = 0x0A32; c <= 0x0A33; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (907:29): [True: 2, False: 1]
  ------------------
  908|      3|  for (char32_t c = 0x0A35; c <= 0x0A36; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (908:29): [True: 2, False: 1]
  ------------------
  909|      3|  for (char32_t c = 0x0A38; c <= 0x0A39; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (909:29): [True: 2, False: 1]
  ------------------
  910|      1|  (*smap)[0x0A3C] = U_Gurmukhi;
  911|      4|  for (char32_t c = 0x0A3E; c <= 0x0A40; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (911:29): [True: 3, False: 1]
  ------------------
  912|      3|  for (char32_t c = 0x0A41; c <= 0x0A42; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (912:29): [True: 2, False: 1]
  ------------------
  913|      3|  for (char32_t c = 0x0A47; c <= 0x0A48; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (913:29): [True: 2, False: 1]
  ------------------
  914|      4|  for (char32_t c = 0x0A4B; c <= 0x0A4D; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (914:29): [True: 3, False: 1]
  ------------------
  915|      1|  (*smap)[0x0A51] = U_Gurmukhi;
  916|      5|  for (char32_t c = 0x0A59; c <= 0x0A5C; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (916:29): [True: 4, False: 1]
  ------------------
  917|      1|  (*smap)[0x0A5E] = U_Gurmukhi;
  918|     11|  for (char32_t c = 0x0A66; c <= 0x0A6F; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (918:29): [True: 10, False: 1]
  ------------------
  919|      3|  for (char32_t c = 0x0A70; c <= 0x0A71; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (919:29): [True: 2, False: 1]
  ------------------
  920|      4|  for (char32_t c = 0x0A72; c <= 0x0A74; ++c) (*smap)[c] = U_Gurmukhi;
  ------------------
  |  Branch (920:29): [True: 3, False: 1]
  ------------------
  921|      1|  (*smap)[0x0A75] = U_Gurmukhi;
  922|      3|  for (char32_t c = 0x0A81; c <= 0x0A82; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (922:29): [True: 2, False: 1]
  ------------------
  923|      1|  (*smap)[0x0A83] = U_Gujarati;
  924|     10|  for (char32_t c = 0x0A85; c <= 0x0A8D; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (924:29): [True: 9, False: 1]
  ------------------
  925|      4|  for (char32_t c = 0x0A8F; c <= 0x0A91; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (925:29): [True: 3, False: 1]
  ------------------
  926|     23|  for (char32_t c = 0x0A93; c <= 0x0AA8; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (926:29): [True: 22, False: 1]
  ------------------
  927|      8|  for (char32_t c = 0x0AAA; c <= 0x0AB0; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (927:29): [True: 7, False: 1]
  ------------------
  928|      3|  for (char32_t c = 0x0AB2; c <= 0x0AB3; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (928:29): [True: 2, False: 1]
  ------------------
  929|      6|  for (char32_t c = 0x0AB5; c <= 0x0AB9; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (929:29): [True: 5, False: 1]
  ------------------
  930|      1|  (*smap)[0x0ABC] = U_Gujarati;
  931|      1|  (*smap)[0x0ABD] = U_Gujarati;
  932|      4|  for (char32_t c = 0x0ABE; c <= 0x0AC0; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (932:29): [True: 3, False: 1]
  ------------------
  933|      6|  for (char32_t c = 0x0AC1; c <= 0x0AC5; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (933:29): [True: 5, False: 1]
  ------------------
  934|      3|  for (char32_t c = 0x0AC7; c <= 0x0AC8; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (934:29): [True: 2, False: 1]
  ------------------
  935|      1|  (*smap)[0x0AC9] = U_Gujarati;
  936|      3|  for (char32_t c = 0x0ACB; c <= 0x0ACC; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (936:29): [True: 2, False: 1]
  ------------------
  937|      1|  (*smap)[0x0ACD] = U_Gujarati;
  938|      1|  (*smap)[0x0AD0] = U_Gujarati;
  939|      3|  for (char32_t c = 0x0AE0; c <= 0x0AE1; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (939:29): [True: 2, False: 1]
  ------------------
  940|      3|  for (char32_t c = 0x0AE2; c <= 0x0AE3; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (940:29): [True: 2, False: 1]
  ------------------
  941|     11|  for (char32_t c = 0x0AE6; c <= 0x0AEF; ++c) (*smap)[c] = U_Gujarati;
  ------------------
  |  Branch (941:29): [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_t c = 0x0B02; c <= 0x0B03; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (946:29): [True: 2, False: 1]
  ------------------
  947|      9|  for (char32_t c = 0x0B05; c <= 0x0B0C; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (947:29): [True: 8, False: 1]
  ------------------
  948|      3|  for (char32_t c = 0x0B0F; c <= 0x0B10; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (948:29): [True: 2, False: 1]
  ------------------
  949|     23|  for (char32_t c = 0x0B13; c <= 0x0B28; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (949:29): [True: 22, False: 1]
  ------------------
  950|      8|  for (char32_t c = 0x0B2A; c <= 0x0B30; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (950:29): [True: 7, False: 1]
  ------------------
  951|      3|  for (char32_t c = 0x0B32; c <= 0x0B33; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (951:29): [True: 2, False: 1]
  ------------------
  952|      6|  for (char32_t c = 0x0B35; c <= 0x0B39; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (952:29): [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_t c = 0x0B41; c <= 0x0B44; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (958:29): [True: 4, False: 1]
  ------------------
  959|      3|  for (char32_t c = 0x0B47; c <= 0x0B48; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (959:29): [True: 2, False: 1]
  ------------------
  960|      3|  for (char32_t c = 0x0B4B; c <= 0x0B4C; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (960:29): [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_t c = 0x0B5C; c <= 0x0B5D; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (964:29): [True: 2, False: 1]
  ------------------
  965|      4|  for (char32_t c = 0x0B5F; c <= 0x0B61; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (965:29): [True: 3, False: 1]
  ------------------
  966|      3|  for (char32_t c = 0x0B62; c <= 0x0B63; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (966:29): [True: 2, False: 1]
  ------------------
  967|     11|  for (char32_t c = 0x0B66; c <= 0x0B6F; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (967:29): [True: 10, False: 1]
  ------------------
  968|      1|  (*smap)[0x0B70] = U_Oriya;
  969|      1|  (*smap)[0x0B71] = U_Oriya;
  970|      7|  for (char32_t c = 0x0B72; c <= 0x0B77; ++c) (*smap)[c] = U_Oriya;
  ------------------
  |  Branch (970:29): [True: 6, False: 1]
  ------------------
  971|      1|  (*smap)[0x0B82] = U_Tamil;
  972|      1|  (*smap)[0x0B83] = U_Tamil;
  973|      7|  for (char32_t c = 0x0B85; c <= 0x0B8A; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (973:29): [True: 6, False: 1]
  ------------------
  974|      4|  for (char32_t c = 0x0B8E; c <= 0x0B90; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (974:29): [True: 3, False: 1]
  ------------------
  975|      5|  for (char32_t c = 0x0B92; c <= 0x0B95; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (975:29): [True: 4, False: 1]
  ------------------
  976|      3|  for (char32_t c = 0x0B99; c <= 0x0B9A; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (976:29): [True: 2, False: 1]
  ------------------
  977|      1|  (*smap)[0x0B9C] = U_Tamil;
  978|      3|  for (char32_t c = 0x0B9E; c <= 0x0B9F; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (978:29): [True: 2, False: 1]
  ------------------
  979|      3|  for (char32_t c = 0x0BA3; c <= 0x0BA4; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (979:29): [True: 2, False: 1]
  ------------------
  980|      4|  for (char32_t c = 0x0BA8; c <= 0x0BAA; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (980:29): [True: 3, False: 1]
  ------------------
  981|     13|  for (char32_t c = 0x0BAE; c <= 0x0BB9; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (981:29): [True: 12, False: 1]
  ------------------
  982|      3|  for (char32_t c = 0x0BBE; c <= 0x0BBF; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (982:29): [True: 2, False: 1]
  ------------------
  983|      1|  (*smap)[0x0BC0] = U_Tamil;
  984|      3|  for (char32_t c = 0x0BC1; c <= 0x0BC2; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (984:29): [True: 2, False: 1]
  ------------------
  985|      4|  for (char32_t c = 0x0BC6; c <= 0x0BC8; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (985:29): [True: 3, False: 1]
  ------------------
  986|      4|  for (char32_t c = 0x0BCA; c <= 0x0BCC; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (986:29): [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_t c = 0x0BE6; c <= 0x0BEF; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (990:29): [True: 10, False: 1]
  ------------------
  991|      4|  for (char32_t c = 0x0BF0; c <= 0x0BF2; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (991:29): [True: 3, False: 1]
  ------------------
  992|      7|  for (char32_t c = 0x0BF3; c <= 0x0BF8; ++c) (*smap)[c] = U_Tamil;
  ------------------
  |  Branch (992:29): [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_t c = 0x0C01; c <= 0x0C03; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (996:29): [True: 3, False: 1]
  ------------------
  997|      9|  for (char32_t c = 0x0C05; c <= 0x0C0C; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (997:29): [True: 8, False: 1]
  ------------------
  998|      4|  for (char32_t c = 0x0C0E; c <= 0x0C10; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (998:29): [True: 3, False: 1]
  ------------------
  999|     24|  for (char32_t c = 0x0C12; c <= 0x0C28; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (999:29): [True: 23, False: 1]
  ------------------
 1000|     17|  for (char32_t c = 0x0C2A; c <= 0x0C39; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1000:29): [True: 16, False: 1]
  ------------------
 1001|      1|  (*smap)[0x0C3D] = U_Telugu;
 1002|      4|  for (char32_t c = 0x0C3E; c <= 0x0C40; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1002:29): [True: 3, False: 1]
  ------------------
 1003|      5|  for (char32_t c = 0x0C41; c <= 0x0C44; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1003:29): [True: 4, False: 1]
  ------------------
 1004|      4|  for (char32_t c = 0x0C46; c <= 0x0C48; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1004:29): [True: 3, False: 1]
  ------------------
 1005|      5|  for (char32_t c = 0x0C4A; c <= 0x0C4D; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1005:29): [True: 4, False: 1]
  ------------------
 1006|      3|  for (char32_t c = 0x0C55; c <= 0x0C56; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1006:29): [True: 2, False: 1]
  ------------------
 1007|      4|  for (char32_t c = 0x0C58; c <= 0x0C5A; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1007:29): [True: 3, False: 1]
  ------------------
 1008|      3|  for (char32_t c = 0x0C60; c <= 0x0C61; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1008:29): [True: 2, False: 1]
  ------------------
 1009|      3|  for (char32_t c = 0x0C62; c <= 0x0C63; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1009:29): [True: 2, False: 1]
  ------------------
 1010|     11|  for (char32_t c = 0x0C66; c <= 0x0C6F; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1010:29): [True: 10, False: 1]
  ------------------
 1011|      8|  for (char32_t c = 0x0C78; c <= 0x0C7E; ++c) (*smap)[c] = U_Telugu;
  ------------------
  |  Branch (1011:29): [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_t c = 0x0C82; c <= 0x0C83; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1015:29): [True: 2, False: 1]
  ------------------
 1016|      9|  for (char32_t c = 0x0C85; c <= 0x0C8C; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1016:29): [True: 8, False: 1]
  ------------------
 1017|      4|  for (char32_t c = 0x0C8E; c <= 0x0C90; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1017:29): [True: 3, False: 1]
  ------------------
 1018|     24|  for (char32_t c = 0x0C92; c <= 0x0CA8; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1018:29): [True: 23, False: 1]
  ------------------
 1019|     11|  for (char32_t c = 0x0CAA; c <= 0x0CB3; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1019:29): [True: 10, False: 1]
  ------------------
 1020|      6|  for (char32_t c = 0x0CB5; c <= 0x0CB9; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1020:29): [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_t c = 0x0CC0; c <= 0x0CC4; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1025:29): [True: 5, False: 1]
  ------------------
 1026|      1|  (*smap)[0x0CC6] = U_Kannada;
 1027|      3|  for (char32_t c = 0x0CC7; c <= 0x0CC8; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1027:29): [True: 2, False: 1]
  ------------------
 1028|      3|  for (char32_t c = 0x0CCA; c <= 0x0CCB; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1028:29): [True: 2, False: 1]
  ------------------
 1029|      3|  for (char32_t c = 0x0CCC; c <= 0x0CCD; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1029:29): [True: 2, False: 1]
  ------------------
 1030|      3|  for (char32_t c = 0x0CD5; c <= 0x0CD6; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1030:29): [True: 2, False: 1]
  ------------------
 1031|      1|  (*smap)[0x0CDE] = U_Kannada;
 1032|      3|  for (char32_t c = 0x0CE0; c <= 0x0CE1; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1032:29): [True: 2, False: 1]
  ------------------
 1033|      3|  for (char32_t c = 0x0CE2; c <= 0x0CE3; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1033:29): [True: 2, False: 1]
  ------------------
 1034|     11|  for (char32_t c = 0x0CE6; c <= 0x0CEF; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1034:29): [True: 10, False: 1]
  ------------------
 1035|      3|  for (char32_t c = 0x0CF1; c <= 0x0CF2; ++c) (*smap)[c] = U_Kannada;
  ------------------
  |  Branch (1035:29): [True: 2, False: 1]
  ------------------
 1036|      1|  (*smap)[0x0D01] = U_Malayalam;
 1037|      3|  for (char32_t c = 0x0D02; c <= 0x0D03; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1037:29): [True: 2, False: 1]
  ------------------
 1038|      9|  for (char32_t c = 0x0D05; c <= 0x0D0C; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1038:29): [True: 8, False: 1]
  ------------------
 1039|      4|  for (char32_t c = 0x0D0E; c <= 0x0D10; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1039:29): [True: 3, False: 1]
  ------------------
 1040|     42|  for (char32_t c = 0x0D12; c <= 0x0D3A; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1040:29): [True: 41, False: 1]
  ------------------
 1041|      1|  (*smap)[0x0D3D] = U_Malayalam;
 1042|      4|  for (char32_t c = 0x0D3E; c <= 0x0D40; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1042:29): [True: 3, False: 1]
  ------------------
 1043|      5|  for (char32_t c = 0x0D41; c <= 0x0D44; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1043:29): [True: 4, False: 1]
  ------------------
 1044|      4|  for (char32_t c = 0x0D46; c <= 0x0D48; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1044:29): [True: 3, False: 1]
  ------------------
 1045|      4|  for (char32_t c = 0x0D4A; c <= 0x0D4C; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1045:29): [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_t c = 0x0D54; c <= 0x0D56; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1049:29): [True: 3, False: 1]
  ------------------
 1050|      1|  (*smap)[0x0D57] = U_Malayalam;
 1051|      8|  for (char32_t c = 0x0D58; c <= 0x0D5E; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1051:29): [True: 7, False: 1]
  ------------------
 1052|      4|  for (char32_t c = 0x0D5F; c <= 0x0D61; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1052:29): [True: 3, False: 1]
  ------------------
 1053|      3|  for (char32_t c = 0x0D62; c <= 0x0D63; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1053:29): [True: 2, False: 1]
  ------------------
 1054|     11|  for (char32_t c = 0x0D66; c <= 0x0D6F; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1054:29): [True: 10, False: 1]
  ------------------
 1055|     10|  for (char32_t c = 0x0D70; c <= 0x0D78; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1055:29): [True: 9, False: 1]
  ------------------
 1056|      1|  (*smap)[0x0D79] = U_Malayalam;
 1057|      7|  for (char32_t c = 0x0D7A; c <= 0x0D7F; ++c) (*smap)[c] = U_Malayalam;
  ------------------
  |  Branch (1057:29): [True: 6, False: 1]
  ------------------
 1058|      3|  for (char32_t c = 0x0D82; c <= 0x0D83; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1058:29): [True: 2, False: 1]
  ------------------
 1059|     19|  for (char32_t c = 0x0D85; c <= 0x0D96; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1059:29): [True: 18, False: 1]
  ------------------
 1060|     25|  for (char32_t c = 0x0D9A; c <= 0x0DB1; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1060:29): [True: 24, False: 1]
  ------------------
 1061|     10|  for (char32_t c = 0x0DB3; c <= 0x0DBB; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1061:29): [True: 9, False: 1]
  ------------------
 1062|      1|  (*smap)[0x0DBD] = U_Sinhala;
 1063|      8|  for (char32_t c = 0x0DC0; c <= 0x0DC6; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1063:29): [True: 7, False: 1]
  ------------------
 1064|      1|  (*smap)[0x0DCA] = U_Sinhala;
 1065|      4|  for (char32_t c = 0x0DCF; c <= 0x0DD1; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1065:29): [True: 3, False: 1]
  ------------------
 1066|      4|  for (char32_t c = 0x0DD2; c <= 0x0DD4; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1066:29): [True: 3, False: 1]
  ------------------
 1067|      1|  (*smap)[0x0DD6] = U_Sinhala;
 1068|      9|  for (char32_t c = 0x0DD8; c <= 0x0DDF; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1068:29): [True: 8, False: 1]
  ------------------
 1069|     11|  for (char32_t c = 0x0DE6; c <= 0x0DEF; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1069:29): [True: 10, False: 1]
  ------------------
 1070|      3|  for (char32_t c = 0x0DF2; c <= 0x0DF3; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1070:29): [True: 2, False: 1]
  ------------------
 1071|      1|  (*smap)[0x0DF4] = U_Sinhala;
 1072|     21|  for (char32_t c = 0x111E1; c <= 0x111F4; ++c) (*smap)[c] = U_Sinhala;
  ------------------
  |  Branch (1072:30): [True: 20, False: 1]
  ------------------
 1073|     49|  for (char32_t c = 0x0E01; c <= 0x0E30; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1073:29): [True: 48, False: 1]
  ------------------
 1074|      1|  (*smap)[0x0E31] = U_Thai;
 1075|      3|  for (char32_t c = 0x0E32; c <= 0x0E33; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1075:29): [True: 2, False: 1]
  ------------------
 1076|      8|  for (char32_t c = 0x0E34; c <= 0x0E3A; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1076:29): [True: 7, False: 1]
  ------------------
 1077|      7|  for (char32_t c = 0x0E40; c <= 0x0E45; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1077:29): [True: 6, False: 1]
  ------------------
 1078|      1|  (*smap)[0x0E46] = U_Thai;
 1079|      9|  for (char32_t c = 0x0E47; c <= 0x0E4E; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1079:29): [True: 8, False: 1]
  ------------------
 1080|      1|  (*smap)[0x0E4F] = U_Thai;
 1081|     11|  for (char32_t c = 0x0E50; c <= 0x0E59; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1081:29): [True: 10, False: 1]
  ------------------
 1082|      3|  for (char32_t c = 0x0E5A; c <= 0x0E5B; ++c) (*smap)[c] = U_Thai;
  ------------------
  |  Branch (1082:29): [True: 2, False: 1]
  ------------------
 1083|      3|  for (char32_t c = 0x0E81; c <= 0x0E82; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1083:29): [True: 2, False: 1]
  ------------------
 1084|      1|  (*smap)[0x0E84] = U_Lao;
 1085|      3|  for (char32_t c = 0x0E87; c <= 0x0E88; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1085:29): [True: 2, False: 1]
  ------------------
 1086|      1|  (*smap)[0x0E8A] = U_Lao;
 1087|      1|  (*smap)[0x0E8D] = U_Lao;
 1088|      5|  for (char32_t c = 0x0E94; c <= 0x0E97; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1088:29): [True: 4, False: 1]
  ------------------
 1089|      8|  for (char32_t c = 0x0E99; c <= 0x0E9F; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1089:29): [True: 7, False: 1]
  ------------------
 1090|      4|  for (char32_t c = 0x0EA1; c <= 0x0EA3; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1090:29): [True: 3, False: 1]
  ------------------
 1091|      1|  (*smap)[0x0EA5] = U_Lao;
 1092|      1|  (*smap)[0x0EA7] = U_Lao;
 1093|      3|  for (char32_t c = 0x0EAA; c <= 0x0EAB; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1093:29): [True: 2, False: 1]
  ------------------
 1094|      5|  for (char32_t c = 0x0EAD; c <= 0x0EB0; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1094:29): [True: 4, False: 1]
  ------------------
 1095|      1|  (*smap)[0x0EB1] = U_Lao;
 1096|      3|  for (char32_t c = 0x0EB2; c <= 0x0EB3; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1096:29): [True: 2, False: 1]
  ------------------
 1097|      7|  for (char32_t c = 0x0EB4; c <= 0x0EB9; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1097:29): [True: 6, False: 1]
  ------------------
 1098|      3|  for (char32_t c = 0x0EBB; c <= 0x0EBC; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1098:29): [True: 2, False: 1]
  ------------------
 1099|      1|  (*smap)[0x0EBD] = U_Lao;
 1100|      6|  for (char32_t c = 0x0EC0; c <= 0x0EC4; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1100:29): [True: 5, False: 1]
  ------------------
 1101|      1|  (*smap)[0x0EC6] = U_Lao;
 1102|      7|  for (char32_t c = 0x0EC8; c <= 0x0ECD; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1102:29): [True: 6, False: 1]
  ------------------
 1103|     11|  for (char32_t c = 0x0ED0; c <= 0x0ED9; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1103:29): [True: 10, False: 1]
  ------------------
 1104|      5|  for (char32_t c = 0x0EDC; c <= 0x0EDF; ++c) (*smap)[c] = U_Lao;
  ------------------
  |  Branch (1104:29): [True: 4, False: 1]
  ------------------
 1105|      1|  (*smap)[0x0F00] = U_Tibetan;
 1106|      4|  for (char32_t c = 0x0F01; c <= 0x0F03; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1106:29): [True: 3, False: 1]
  ------------------
 1107|     16|  for (char32_t c = 0x0F04; c <= 0x0F12; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1107:29): [True: 15, False: 1]
  ------------------
 1108|      1|  (*smap)[0x0F13] = U_Tibetan;
 1109|      1|  (*smap)[0x0F14] = U_Tibetan;
 1110|      4|  for (char32_t c = 0x0F15; c <= 0x0F17; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1110:29): [True: 3, False: 1]
  ------------------
 1111|      3|  for (char32_t c = 0x0F18; c <= 0x0F19; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1111:29): [True: 2, False: 1]
  ------------------
 1112|      7|  for (char32_t c = 0x0F1A; c <= 0x0F1F; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1112:29): [True: 6, False: 1]
  ------------------
 1113|     11|  for (char32_t c = 0x0F20; c <= 0x0F29; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1113:29): [True: 10, False: 1]
  ------------------
 1114|     11|  for (char32_t c = 0x0F2A; c <= 0x0F33; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1114:29): [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_t c = 0x0F3E; c <= 0x0F3F; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1125:29): [True: 2, False: 1]
  ------------------
 1126|      9|  for (char32_t c = 0x0F40; c <= 0x0F47; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1126:29): [True: 8, False: 1]
  ------------------
 1127|     37|  for (char32_t c = 0x0F49; c <= 0x0F6C; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1127:29): [True: 36, False: 1]
  ------------------
 1128|     15|  for (char32_t c = 0x0F71; c <= 0x0F7E; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1128:29): [True: 14, False: 1]
  ------------------
 1129|      1|  (*smap)[0x0F7F] = U_Tibetan;
 1130|      6|  for (char32_t c = 0x0F80; c <= 0x0F84; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1130:29): [True: 5, False: 1]
  ------------------
 1131|      1|  (*smap)[0x0F85] = U_Tibetan;
 1132|      3|  for (char32_t c = 0x0F86; c <= 0x0F87; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1132:29): [True: 2, False: 1]
  ------------------
 1133|      6|  for (char32_t c = 0x0F88; c <= 0x0F8C; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1133:29): [True: 5, False: 1]
  ------------------
 1134|     12|  for (char32_t c = 0x0F8D; c <= 0x0F97; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1134:29): [True: 11, False: 1]
  ------------------
 1135|     37|  for (char32_t c = 0x0F99; c <= 0x0FBC; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1135:29): [True: 36, False: 1]
  ------------------
 1136|      9|  for (char32_t c = 0x0FBE; c <= 0x0FC5; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1136:29): [True: 8, False: 1]
  ------------------
 1137|      1|  (*smap)[0x0FC6] = U_Tibetan;
 1138|      7|  for (char32_t c = 0x0FC7; c <= 0x0FCC; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1138:29): [True: 6, False: 1]
  ------------------
 1139|      3|  for (char32_t c = 0x0FCE; c <= 0x0FCF; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1139:29): [True: 2, False: 1]
  ------------------
 1140|      6|  for (char32_t c = 0x0FD0; c <= 0x0FD4; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1140:29): [True: 5, False: 1]
  ------------------
 1141|      3|  for (char32_t c = 0x0FD9; c <= 0x0FDA; ++c) (*smap)[c] = U_Tibetan;
  ------------------
  |  Branch (1141:29): [True: 2, False: 1]
  ------------------
 1142|     44|  for (char32_t c = 0x1000; c <= 0x102A; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1142:29): [True: 43, False: 1]
  ------------------
 1143|      3|  for (char32_t c = 0x102B; c <= 0x102C; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1143:29): [True: 2, False: 1]
  ------------------
 1144|      5|  for (char32_t c = 0x102D; c <= 0x1030; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1144:29): [True: 4, False: 1]
  ------------------
 1145|      1|  (*smap)[0x1031] = U_Myanmar;
 1146|      7|  for (char32_t c = 0x1032; c <= 0x1037; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1146:29): [True: 6, False: 1]
  ------------------
 1147|      1|  (*smap)[0x1038] = U_Myanmar;
 1148|      3|  for (char32_t c = 0x1039; c <= 0x103A; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1148:29): [True: 2, False: 1]
  ------------------
 1149|      3|  for (char32_t c = 0x103B; c <= 0x103C; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1149:29): [True: 2, False: 1]
  ------------------
 1150|      3|  for (char32_t c = 0x103D; c <= 0x103E; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1150:29): [True: 2, False: 1]
  ------------------
 1151|      1|  (*smap)[0x103F] = U_Myanmar;
 1152|     11|  for (char32_t c = 0x1040; c <= 0x1049; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1152:29): [True: 10, False: 1]
  ------------------
 1153|      7|  for (char32_t c = 0x104A; c <= 0x104F; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1153:29): [True: 6, False: 1]
  ------------------
 1154|      7|  for (char32_t c = 0x1050; c <= 0x1055; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1154:29): [True: 6, False: 1]
  ------------------
 1155|      3|  for (char32_t c = 0x1056; c <= 0x1057; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1155:29): [True: 2, False: 1]
  ------------------
 1156|      3|  for (char32_t c = 0x1058; c <= 0x1059; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1156:29): [True: 2, False: 1]
  ------------------
 1157|      5|  for (char32_t c = 0x105A; c <= 0x105D; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1157:29): [True: 4, False: 1]
  ------------------
 1158|      4|  for (char32_t c = 0x105E; c <= 0x1060; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1158:29): [True: 3, False: 1]
  ------------------
 1159|      1|  (*smap)[0x1061] = U_Myanmar;
 1160|      4|  for (char32_t c = 0x1062; c <= 0x1064; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1160:29): [True: 3, False: 1]
  ------------------
 1161|      3|  for (char32_t c = 0x1065; c <= 0x1066; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1161:29): [True: 2, False: 1]
  ------------------
 1162|      8|  for (char32_t c = 0x1067; c <= 0x106D; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1162:29): [True: 7, False: 1]
  ------------------
 1163|      4|  for (char32_t c = 0x106E; c <= 0x1070; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1163:29): [True: 3, False: 1]
  ------------------
 1164|      5|  for (char32_t c = 0x1071; c <= 0x1074; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1164:29): [True: 4, False: 1]
  ------------------
 1165|     14|  for (char32_t c = 0x1075; c <= 0x1081; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1165:29): [True: 13, False: 1]
  ------------------
 1166|      1|  (*smap)[0x1082] = U_Myanmar;
 1167|      3|  for (char32_t c = 0x1083; c <= 0x1084; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1167:29): [True: 2, False: 1]
  ------------------
 1168|      3|  for (char32_t c = 0x1085; c <= 0x1086; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1168:29): [True: 2, False: 1]
  ------------------
 1169|      7|  for (char32_t c = 0x1087; c <= 0x108C; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1169:29): [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_t c = 0x1090; c <= 0x1099; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1173:29): [True: 10, False: 1]
  ------------------
 1174|      4|  for (char32_t c = 0x109A; c <= 0x109C; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1174:29): [True: 3, False: 1]
  ------------------
 1175|      1|  (*smap)[0x109D] = U_Myanmar;
 1176|      3|  for (char32_t c = 0x109E; c <= 0x109F; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1176:29): [True: 2, False: 1]
  ------------------
 1177|      6|  for (char32_t c = 0xA9E0; c <= 0xA9E4; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1177:29): [True: 5, False: 1]
  ------------------
 1178|      1|  (*smap)[0xA9E5] = U_Myanmar;
 1179|      1|  (*smap)[0xA9E6] = U_Myanmar;
 1180|     10|  for (char32_t c = 0xA9E7; c <= 0xA9EF; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1180:29): [True: 9, False: 1]
  ------------------
 1181|     11|  for (char32_t c = 0xA9F0; c <= 0xA9F9; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1181:29): [True: 10, False: 1]
  ------------------
 1182|      6|  for (char32_t c = 0xA9FA; c <= 0xA9FE; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1182:29): [True: 5, False: 1]
  ------------------
 1183|     17|  for (char32_t c = 0xAA60; c <= 0xAA6F; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1183:29): [True: 16, False: 1]
  ------------------
 1184|      1|  (*smap)[0xAA70] = U_Myanmar;
 1185|      7|  for (char32_t c = 0xAA71; c <= 0xAA76; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1185:29): [True: 6, False: 1]
  ------------------
 1186|      4|  for (char32_t c = 0xAA77; c <= 0xAA79; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1186:29): [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_t c = 0xAA7E; c <= 0xAA7F; ++c) (*smap)[c] = U_Myanmar;
  ------------------
  |  Branch (1191:29): [True: 2, False: 1]
  ------------------
 1192|     39|  for (char32_t c = 0x10A0; c <= 0x10C5; ++c) (*smap)[c] = U_Georgian;
  ------------------
  |  Branch (1192:29): [True: 38, False: 1]
  ------------------
 1193|      1|  (*smap)[0x10C7] = U_Georgian;
 1194|      1|  (*smap)[0x10CD] = U_Georgian;
 1195|     44|  for (char32_t c = 0x10D0; c <= 0x10FA; ++c) (*smap)[c] = U_Georgian;
  ------------------
  |  Branch (1195:29): [True: 43, False: 1]
  ------------------
 1196|      1|  (*smap)[0x10FC] = U_Georgian;
 1197|      4|  for (char32_t c = 0x10FD; c <= 0x10FF; ++c) (*smap)[c] = U_Georgian;
  ------------------
  |  Branch (1197:29): [True: 3, False: 1]
  ------------------
 1198|     39|  for (char32_t c = 0x2D00; c <= 0x2D25; ++c) (*smap)[c] = U_Georgian;
  ------------------
  |  Branch (1198:29): [True: 38, False: 1]
  ------------------
 1199|      1|  (*smap)[0x2D27] = U_Georgian;
 1200|      1|  (*smap)[0x2D2D] = U_Georgian;
 1201|    257|  for (char32_t c = 0x1100; c <= 0x11FF; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1201:29): [True: 256, False: 1]
  ------------------
 1202|      3|  for (char32_t c = 0x302E; c <= 0x302F; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1202:29): [True: 2, False: 1]
  ------------------
 1203|     95|  for (char32_t c = 0x3131; c <= 0x318E; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1203:29): [True: 94, False: 1]
  ------------------
 1204|     32|  for (char32_t c = 0x3200; c <= 0x321E; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1204:29): [True: 31, False: 1]
  ------------------
 1205|     32|  for (char32_t c = 0x3260; c <= 0x327E; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1205:29): [True: 31, False: 1]
  ------------------
 1206|     30|  for (char32_t c = 0xA960; c <= 0xA97C; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1206:29): [True: 29, False: 1]
  ------------------
 1207|  11.1k|  for (char32_t c = 0xAC00; c <= 0xD7A3; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1207:29): [True: 11.1k, False: 1]
  ------------------
 1208|     24|  for (char32_t c = 0xD7B0; c <= 0xD7C6; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1208:29): [True: 23, False: 1]
  ------------------
 1209|     50|  for (char32_t c = 0xD7CB; c <= 0xD7FB; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1209:29): [True: 49, False: 1]
  ------------------
 1210|     32|  for (char32_t c = 0xFFA0; c <= 0xFFBE; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1210:29): [True: 31, False: 1]
  ------------------
 1211|      7|  for (char32_t c = 0xFFC2; c <= 0xFFC7; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1211:29): [True: 6, False: 1]
  ------------------
 1212|      7|  for (char32_t c = 0xFFCA; c <= 0xFFCF; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1212:29): [True: 6, False: 1]
  ------------------
 1213|      7|  for (char32_t c = 0xFFD2; c <= 0xFFD7; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1213:29): [True: 6, False: 1]
  ------------------
 1214|      4|  for (char32_t c = 0xFFDA; c <= 0xFFDC; ++c) (*smap)[c] = U_Hangul;
  ------------------
  |  Branch (1214:29): [True: 3, False: 1]
  ------------------
 1215|     74|  for (char32_t c = 0x1200; c <= 0x1248; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1215:29): [True: 73, False: 1]
  ------------------
 1216|      5|  for (char32_t c = 0x124A; c <= 0x124D; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1216:29): [True: 4, False: 1]
  ------------------
 1217|      8|  for (char32_t c = 0x1250; c <= 0x1256; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1217:29): [True: 7, False: 1]
  ------------------
 1218|      1|  (*smap)[0x1258] = U_Ethiopic;
 1219|      5|  for (char32_t c = 0x125A; c <= 0x125D; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1219:29): [True: 4, False: 1]
  ------------------
 1220|     42|  for (char32_t c = 0x1260; c <= 0x1288; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1220:29): [True: 41, False: 1]
  ------------------
 1221|      5|  for (char32_t c = 0x128A; c <= 0x128D; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1221:29): [True: 4, False: 1]
  ------------------
 1222|     34|  for (char32_t c = 0x1290; c <= 0x12B0; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1222:29): [True: 33, False: 1]
  ------------------
 1223|      5|  for (char32_t c = 0x12B2; c <= 0x12B5; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1223:29): [True: 4, False: 1]
  ------------------
 1224|      8|  for (char32_t c = 0x12B8; c <= 0x12BE; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1224:29): [True: 7, False: 1]
  ------------------
 1225|      1|  (*smap)[0x12C0] = U_Ethiopic;
 1226|      5|  for (char32_t c = 0x12C2; c <= 0x12C5; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1226:29): [True: 4, False: 1]
  ------------------
 1227|     16|  for (char32_t c = 0x12C8; c <= 0x12D6; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1227:29): [True: 15, False: 1]
  ------------------
 1228|     58|  for (char32_t c = 0x12D8; c <= 0x1310; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1228:29): [True: 57, False: 1]
  ------------------
 1229|      5|  for (char32_t c = 0x1312; c <= 0x1315; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1229:29): [True: 4, False: 1]
  ------------------
 1230|     68|  for (char32_t c = 0x1318; c <= 0x135A; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1230:29): [True: 67, False: 1]
  ------------------
 1231|      4|  for (char32_t c = 0x135D; c <= 0x135F; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1231:29): [True: 3, False: 1]
  ------------------
 1232|     10|  for (char32_t c = 0x1360; c <= 0x1368; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1232:29): [True: 9, False: 1]
  ------------------
 1233|     21|  for (char32_t c = 0x1369; c <= 0x137C; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1233:29): [True: 20, False: 1]
  ------------------
 1234|     17|  for (char32_t c = 0x1380; c <= 0x138F; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1234:29): [True: 16, False: 1]
  ------------------
 1235|     11|  for (char32_t c = 0x1390; c <= 0x1399; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1235:29): [True: 10, False: 1]
  ------------------
 1236|     24|  for (char32_t c = 0x2D80; c <= 0x2D96; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1236:29): [True: 23, False: 1]
  ------------------
 1237|      8|  for (char32_t c = 0x2DA0; c <= 0x2DA6; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1237:29): [True: 7, False: 1]
  ------------------
 1238|      8|  for (char32_t c = 0x2DA8; c <= 0x2DAE; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1238:29): [True: 7, False: 1]
  ------------------
 1239|      8|  for (char32_t c = 0x2DB0; c <= 0x2DB6; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1239:29): [True: 7, False: 1]
  ------------------
 1240|      8|  for (char32_t c = 0x2DB8; c <= 0x2DBE; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1240:29): [True: 7, False: 1]
  ------------------
 1241|      8|  for (char32_t c = 0x2DC0; c <= 0x2DC6; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1241:29): [True: 7, False: 1]
  ------------------
 1242|      8|  for (char32_t c = 0x2DC8; c <= 0x2DCE; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1242:29): [True: 7, False: 1]
  ------------------
 1243|      8|  for (char32_t c = 0x2DD0; c <= 0x2DD6; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1243:29): [True: 7, False: 1]
  ------------------
 1244|      8|  for (char32_t c = 0x2DD8; c <= 0x2DDE; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1244:29): [True: 7, False: 1]
  ------------------
 1245|      7|  for (char32_t c = 0xAB01; c <= 0xAB06; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1245:29): [True: 6, False: 1]
  ------------------
 1246|      7|  for (char32_t c = 0xAB09; c <= 0xAB0E; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1246:29): [True: 6, False: 1]
  ------------------
 1247|      7|  for (char32_t c = 0xAB11; c <= 0xAB16; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1247:29): [True: 6, False: 1]
  ------------------
 1248|      8|  for (char32_t c = 0xAB20; c <= 0xAB26; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1248:29): [True: 7, False: 1]
  ------------------
 1249|      8|  for (char32_t c = 0xAB28; c <= 0xAB2E; ++c) (*smap)[c] = U_Ethiopic;
  ------------------
  |  Branch (1249:29): [True: 7, False: 1]
  ------------------
 1250|     87|  for (char32_t c = 0x13A0; c <= 0x13F5; ++c) (*smap)[c] = U_Cherokee;
  ------------------
  |  Branch (1250:29): [True: 86, False: 1]
  ------------------
 1251|      7|  for (char32_t c = 0x13F8; c <= 0x13FD; ++c) (*smap)[c] = U_Cherokee;
  ------------------
  |  Branch (1251:29): [True: 6, False: 1]
  ------------------
 1252|     81|  for (char32_t c = 0xAB70; c <= 0xABBF; ++c) (*smap)[c] = U_Cherokee;
  ------------------
  |  Branch (1252:29): [True: 80, False: 1]
  ------------------
 1253|      1|  (*smap)[0x1400] = U_Canadian_Aboriginal;
 1254|    621|  for (char32_t c = 0x1401; c <= 0x166C; ++c) (*smap)[c] = U_Canadian_Aboriginal;
  ------------------
  |  Branch (1254:29): [True: 620, False: 1]
  ------------------
 1255|      3|  for (char32_t c = 0x166D; c <= 0x166E; ++c) (*smap)[c] = U_Canadian_Aboriginal;
  ------------------
  |  Branch (1255:29): [True: 2, False: 1]
  ------------------
 1256|     18|  for (char32_t c = 0x166F; c <= 0x167F; ++c) (*smap)[c] = U_Canadian_Aboriginal;
  ------------------
  |  Branch (1256:29): [True: 17, False: 1]
  ------------------
 1257|     71|  for (char32_t c = 0x18B0; c <= 0x18F5; ++c) (*smap)[c] = U_Canadian_Aboriginal;
  ------------------
  |  Branch (1257:29): [True: 70, False: 1]
  ------------------
 1258|      1|  (*smap)[0x1680] = U_Ogham;
 1259|     27|  for (char32_t c = 0x1681; c <= 0x169A; ++c) (*smap)[c] = U_Ogham;
  ------------------
  |  Branch (1259:29): [True: 26, False: 1]
  ------------------
 1260|      1|  (*smap)[0x169B] = U_Ogham;
 1261|      1|  (*smap)[0x169C] = U_Ogham;
 1262|     76|  for (char32_t c = 0x16A0; c <= 0x16EA; ++c) (*smap)[c] = U_Runic;
  ------------------
  |  Branch (1262:29): [True: 75, False: 1]
  ------------------
 1263|      4|  for (char32_t c = 0x16EE; c <= 0x16F0; ++c) (*smap)[c] = U_Runic;
  ------------------
  |  Branch (1263:29): [True: 3, False: 1]
  ------------------
 1264|      9|  for (char32_t c = 0x16F1; c <= 0x16F8; ++c) (*smap)[c] = U_Runic;
  ------------------
  |  Branch (1264:29): [True: 8, False: 1]
  ------------------
 1265|     53|  for (char32_t c = 0x1780; c <= 0x17B3; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1265:29): [True: 52, False: 1]
  ------------------
 1266|      3|  for (char32_t c = 0x17B4; c <= 0x17B5; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1266:29): [True: 2, False: 1]
  ------------------
 1267|      1|  (*smap)[0x17B6] = U_Khmer;
 1268|      8|  for (char32_t c = 0x17B7; c <= 0x17BD; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1268:29): [True: 7, False: 1]
  ------------------
 1269|      9|  for (char32_t c = 0x17BE; c <= 0x17C5; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1269:29): [True: 8, False: 1]
  ------------------
 1270|      1|  (*smap)[0x17C6] = U_Khmer;
 1271|      3|  for (char32_t c = 0x17C7; c <= 0x17C8; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1271:29): [True: 2, False: 1]
  ------------------
 1272|     12|  for (char32_t c = 0x17C9; c <= 0x17D3; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1272:29): [True: 11, False: 1]
  ------------------
 1273|      4|  for (char32_t c = 0x17D4; c <= 0x17D6; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1273:29): [True: 3, False: 1]
  ------------------
 1274|      1|  (*smap)[0x17D7] = U_Khmer;
 1275|      4|  for (char32_t c = 0x17D8; c <= 0x17DA; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1275:29): [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_t c = 0x17E0; c <= 0x17E9; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1279:29): [True: 10, False: 1]
  ------------------
 1280|     11|  for (char32_t c = 0x17F0; c <= 0x17F9; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1280:29): [True: 10, False: 1]
  ------------------
 1281|     33|  for (char32_t c = 0x19E0; c <= 0x19FF; ++c) (*smap)[c] = U_Khmer;
  ------------------
  |  Branch (1281:29): [True: 32, False: 1]
  ------------------
 1282|      3|  for (char32_t c = 0x1800; c <= 0x1801; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1282:29): [True: 2, False: 1]
  ------------------
 1283|      1|  (*smap)[0x1804] = U_Mongolian;
 1284|      1|  (*smap)[0x1806] = U_Mongolian;
 1285|      5|  for (char32_t c = 0x1807; c <= 0x180A; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1285:29): [True: 4, False: 1]
  ------------------
 1286|      4|  for (char32_t c = 0x180B; c <= 0x180D; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1286:29): [True: 3, False: 1]
  ------------------
 1287|      1|  (*smap)[0x180E] = U_Mongolian;
 1288|     11|  for (char32_t c = 0x1810; c <= 0x1819; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1288:29): [True: 10, False: 1]
  ------------------
 1289|     36|  for (char32_t c = 0x1820; c <= 0x1842; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1289:29): [True: 35, False: 1]
  ------------------
 1290|      1|  (*smap)[0x1843] = U_Mongolian;
 1291|     53|  for (char32_t c = 0x1844; c <= 0x1877; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1291:29): [True: 52, False: 1]
  ------------------
 1292|      6|  for (char32_t c = 0x1880; c <= 0x1884; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1292:29): [True: 5, False: 1]
  ------------------
 1293|      3|  for (char32_t c = 0x1885; c <= 0x1886; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1293:29): [True: 2, False: 1]
  ------------------
 1294|     35|  for (char32_t c = 0x1887; c <= 0x18A8; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1294:29): [True: 34, False: 1]
  ------------------
 1295|      1|  (*smap)[0x18A9] = U_Mongolian;
 1296|      1|  (*smap)[0x18AA] = U_Mongolian;
 1297|     14|  for (char32_t c = 0x11660; c <= 0x1166C; ++c) (*smap)[c] = U_Mongolian;
  ------------------
  |  Branch (1297:30): [True: 13, False: 1]
  ------------------
 1298|     87|  for (char32_t c = 0x3041; c <= 0x3096; ++c) (*smap)[c] = U_Hiragana;
  ------------------
  |  Branch (1298:29): [True: 86, False: 1]
  ------------------
 1299|      3|  for (char32_t c = 0x309D; c <= 0x309E; ++c) (*smap)[c] = U_Hiragana;
  ------------------
  |  Branch (1299:29): [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_t c = 0x30A1; c <= 0x30FA; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1303:29): [True: 90, False: 1]
  ------------------
 1304|      3|  for (char32_t c = 0x30FD; c <= 0x30FE; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1304:29): [True: 2, False: 1]
  ------------------
 1305|      1|  (*smap)[0x30FF] = U_Katakana;
 1306|     17|  for (char32_t c = 0x31F0; c <= 0x31FF; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1306:29): [True: 16, False: 1]
  ------------------
 1307|     48|  for (char32_t c = 0x32D0; c <= 0x32FE; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1307:29): [True: 47, False: 1]
  ------------------
 1308|     89|  for (char32_t c = 0x3300; c <= 0x3357; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1308:29): [True: 88, False: 1]
  ------------------
 1309|     11|  for (char32_t c = 0xFF66; c <= 0xFF6F; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1309:29): [True: 10, False: 1]
  ------------------
 1310|     46|  for (char32_t c = 0xFF71; c <= 0xFF9D; ++c) (*smap)[c] = U_Katakana;
  ------------------
  |  Branch (1310:29): [True: 45, False: 1]
  ------------------
 1311|      1|  (*smap)[0x1B000] = U_Katakana;
 1312|      3|  for (char32_t c = 0x02EA; c <= 0x02EB; ++c) (*smap)[c] = U_Bopomofo;
  ------------------
  |  Branch (1312:29): [True: 2, False: 1]
  ------------------
 1313|     42|  for (char32_t c = 0x3105; c <= 0x312D; ++c) (*smap)[c] = U_Bopomofo;
  ------------------
  |  Branch (1313:29): [True: 41, False: 1]
  ------------------
 1314|     28|  for (char32_t c = 0x31A0; c <= 0x31BA; ++c) (*smap)[c] = U_Bopomofo;
  ------------------
  |  Branch (1314:29): [True: 27, False: 1]
  ------------------
 1315|     27|  for (char32_t c = 0x2E80; c <= 0x2E99; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1315:29): [True: 26, False: 1]
  ------------------
 1316|     90|  for (char32_t c = 0x2E9B; c <= 0x2EF3; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1316:29): [True: 89, False: 1]
  ------------------
 1317|    215|  for (char32_t c = 0x2F00; c <= 0x2FD5; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1317:29): [True: 214, False: 1]
  ------------------
 1318|      1|  (*smap)[0x3005] = U_Han;
 1319|      1|  (*smap)[0x3007] = U_Han;
 1320|     10|  for (char32_t c = 0x3021; c <= 0x3029; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1320:29): [True: 9, False: 1]
  ------------------
 1321|      4|  for (char32_t c = 0x3038; c <= 0x303A; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1321:29): [True: 3, False: 1]
  ------------------
 1322|      1|  (*smap)[0x303B] = U_Han;
 1323|  6.58k|  for (char32_t c = 0x3400; c <= 0x4DB5; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1323:29): [True: 6.58k, False: 1]
  ------------------
 1324|  20.9k|  for (char32_t c = 0x4E00; c <= 0x9FD5; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1324:29): [True: 20.9k, False: 1]
  ------------------
 1325|    367|  for (char32_t c = 0xF900; c <= 0xFA6D; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1325:29): [True: 366, False: 1]
  ------------------
 1326|    107|  for (char32_t c = 0xFA70; c <= 0xFAD9; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1326:29): [True: 106, False: 1]
  ------------------
 1327|  42.7k|  for (char32_t c = 0x20000; c <= 0x2A6D6; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1327:30): [True: 42.7k, False: 1]
  ------------------
 1328|  4.15k|  for (char32_t c = 0x2A700; c <= 0x2B734; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1328:30): [True: 4.14k, False: 1]
  ------------------
 1329|    223|  for (char32_t c = 0x2B740; c <= 0x2B81D; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1329:30): [True: 222, False: 1]
  ------------------
 1330|  5.76k|  for (char32_t c = 0x2B820; c <= 0x2CEA1; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1330:30): [True: 5.76k, False: 1]
  ------------------
 1331|    543|  for (char32_t c = 0x2F800; c <= 0x2FA1D; ++c) (*smap)[c] = U_Han;
  ------------------
  |  Branch (1331:30): [True: 542, False: 1]
  ------------------
 1332|     22|  for (char32_t c = 0xA000; c <= 0xA014; ++c) (*smap)[c] = U_Yi;
  ------------------
  |  Branch (1332:29): [True: 21, False: 1]
  ------------------
 1333|      1|  (*smap)[0xA015] = U_Yi;
 1334|  1.14k|  for (char32_t c = 0xA016; c <= 0xA48C; ++c) (*smap)[c] = U_Yi;
  ------------------
  |  Branch (1334:29): [True: 1.14k, False: 1]
  ------------------
 1335|     56|  for (char32_t c = 0xA490; c <= 0xA4C6; ++c) (*smap)[c] = U_Yi;
  ------------------
  |  Branch (1335:29): [True: 55, False: 1]
  ------------------
 1336|     33|  for (char32_t c = 0x10300; c <= 0x1031F; ++c) (*smap)[c] = U_Old_Italic;
  ------------------
  |  Branch (1336:30): [True: 32, False: 1]
  ------------------
 1337|      5|  for (char32_t c = 0x10320; c <= 0x10323; ++c) (*smap)[c] = U_Old_Italic;
  ------------------
  |  Branch (1337:30): [True: 4, False: 1]
  ------------------
 1338|     18|  for (char32_t c = 0x10330; c <= 0x10340; ++c) (*smap)[c] = U_Gothic;
  ------------------
  |  Branch (1338:30): [True: 17, False: 1]
  ------------------
 1339|      1|  (*smap)[0x10341] = U_Gothic;
 1340|      9|  for (char32_t c = 0x10342; c <= 0x10349; ++c) (*smap)[c] = U_Gothic;
  ------------------
  |  Branch (1340:30): [True: 8, False: 1]
  ------------------
 1341|      1|  (*smap)[0x1034A] = U_Gothic;
 1342|     81|  for (char32_t c = 0x10400; c <= 0x1044F; ++c) (*smap)[c] = U_Deseret;
  ------------------
  |  Branch (1342:30): [True: 80, False: 1]
  ------------------
 1343|    113|  for (char32_t c = 0x0300; c <= 0x036F; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1343:29): [True: 112, False: 1]
  ------------------
 1344|      3|  for (char32_t c = 0x0485; c <= 0x0486; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1344:29): [True: 2, False: 1]
  ------------------
 1345|     12|  for (char32_t c = 0x064B; c <= 0x0655; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1345:29): [True: 11, False: 1]
  ------------------
 1346|      1|  (*smap)[0x0670] = U_Inherited;
 1347|      3|  for (char32_t c = 0x0951; c <= 0x0952; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1347:29): [True: 2, False: 1]
  ------------------
 1348|     15|  for (char32_t c = 0x1AB0; c <= 0x1ABD; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1348:29): [True: 14, False: 1]
  ------------------
 1349|      1|  (*smap)[0x1ABE] = U_Inherited;
 1350|      4|  for (char32_t c = 0x1CD0; c <= 0x1CD2; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1350:29): [True: 3, False: 1]
  ------------------
 1351|     14|  for (char32_t c = 0x1CD4; c <= 0x1CE0; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1351:29): [True: 13, False: 1]
  ------------------
 1352|      8|  for (char32_t c = 0x1CE2; c <= 0x1CE8; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1352:29): [True: 7, False: 1]
  ------------------
 1353|      1|  (*smap)[0x1CED] = U_Inherited;
 1354|      1|  (*smap)[0x1CF4] = U_Inherited;
 1355|      3|  for (char32_t c = 0x1CF8; c <= 0x1CF9; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1355:29): [True: 2, False: 1]
  ------------------
 1356|     55|  for (char32_t c = 0x1DC0; c <= 0x1DF5; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1356:29): [True: 54, False: 1]
  ------------------
 1357|      6|  for (char32_t c = 0x1DFB; c <= 0x1DFF; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1357:29): [True: 5, False: 1]
  ------------------
 1358|      3|  for (char32_t c = 0x200C; c <= 0x200D; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1358:29): [True: 2, False: 1]
  ------------------
 1359|     14|  for (char32_t c = 0x20D0; c <= 0x20DC; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1359:29): [True: 13, False: 1]
  ------------------
 1360|      5|  for (char32_t c = 0x20DD; c <= 0x20E0; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1360:29): [True: 4, False: 1]
  ------------------
 1361|      1|  (*smap)[0x20E1] = U_Inherited;
 1362|      4|  for (char32_t c = 0x20E2; c <= 0x20E4; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1362:29): [True: 3, False: 1]
  ------------------
 1363|     13|  for (char32_t c = 0x20E5; c <= 0x20F0; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1363:29): [True: 12, False: 1]
  ------------------
 1364|      5|  for (char32_t c = 0x302A; c <= 0x302D; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1364:29): [True: 4, False: 1]
  ------------------
 1365|      3|  for (char32_t c = 0x3099; c <= 0x309A; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1365:29): [True: 2, False: 1]
  ------------------
 1366|     17|  for (char32_t c = 0xFE00; c <= 0xFE0F; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1366:29): [True: 16, False: 1]
  ------------------
 1367|     15|  for (char32_t c = 0xFE20; c <= 0xFE2D; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1367:29): [True: 14, False: 1]
  ------------------
 1368|      1|  (*smap)[0x101FD] = U_Inherited;
 1369|      1|  (*smap)[0x102E0] = U_Inherited;
 1370|      4|  for (char32_t c = 0x1D167; c <= 0x1D169; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1370:30): [True: 3, False: 1]
  ------------------
 1371|      9|  for (char32_t c = 0x1D17B; c <= 0x1D182; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1371:30): [True: 8, False: 1]
  ------------------
 1372|      8|  for (char32_t c = 0x1D185; c <= 0x1D18B; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1372:30): [True: 7, False: 1]
  ------------------
 1373|      5|  for (char32_t c = 0x1D1AA; c <= 0x1D1AD; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1373:30): [True: 4, False: 1]
  ------------------
 1374|    241|  for (char32_t c = 0xE0100; c <= 0xE01EF; ++c) (*smap)[c] = U_Inherited;
  ------------------
  |  Branch (1374:30): [True: 240, False: 1]
  ------------------
 1375|     14|  for (char32_t c = 0x1700; c <= 0x170C; ++c) (*smap)[c] = U_Tagalog;
  ------------------
  |  Branch (1375:29): [True: 13, False: 1]
  ------------------
 1376|      5|  for (char32_t c = 0x170E; c <= 0x1711; ++c) (*smap)[c] = U_Tagalog;
  ------------------
  |  Branch (1376:29): [True: 4, False: 1]
  ------------------
 1377|      4|  for (char32_t c = 0x1712; c <= 0x1714; ++c) (*smap)[c] = U_Tagalog;
  ------------------
  |  Branch (1377:29): [True: 3, False: 1]
  ------------------
 1378|     19|  for (char32_t c = 0x1720; c <= 0x1731; ++c) (*smap)[c] = U_Hanunoo;
  ------------------
  |  Branch (1378:29): [True: 18, False: 1]
  ------------------
 1379|      4|  for (char32_t c = 0x1732; c <= 0x1734; ++c) (*smap)[c] = U_Hanunoo;
  ------------------
  |  Branch (1379:29): [True: 3, False: 1]
  ------------------
 1380|     19|  for (char32_t c = 0x1740; c <= 0x1751; ++c) (*smap)[c] = U_Buhid;
  ------------------
  |  Branch (1380:29): [True: 18, False: 1]
  ------------------
 1381|      3|  for (char32_t c = 0x1752; c <= 0x1753; ++c) (*smap)[c] = U_Buhid;
  ------------------
  |  Branch (1381:29): [True: 2, False: 1]
  ------------------
 1382|     14|  for (char32_t c = 0x1760; c <= 0x176C; ++c) (*smap)[c] = U_Tagbanwa;
  ------------------
  |  Branch (1382:29): [True: 13, False: 1]
  ------------------
 1383|      4|  for (char32_t c = 0x176E; c <= 0x1770; ++c) (*smap)[c] = U_Tagbanwa;
  ------------------
  |  Branch (1383:29): [True: 3, False: 1]
  ------------------
 1384|      3|  for (char32_t c = 0x1772; c <= 0x1773; ++c) (*smap)[c] = U_Tagbanwa;
  ------------------
  |  Branch (1384:29): [True: 2, False: 1]
  ------------------
 1385|     32|  for (char32_t c = 0x1900; c <= 0x191E; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1385:29): [True: 31, False: 1]
  ------------------
 1386|      4|  for (char32_t c = 0x1920; c <= 0x1922; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1386:29): [True: 3, False: 1]
  ------------------
 1387|      5|  for (char32_t c = 0x1923; c <= 0x1926; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1387:29): [True: 4, False: 1]
  ------------------
 1388|      3|  for (char32_t c = 0x1927; c <= 0x1928; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1388:29): [True: 2, False: 1]
  ------------------
 1389|      4|  for (char32_t c = 0x1929; c <= 0x192B; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1389:29): [True: 3, False: 1]
  ------------------
 1390|      3|  for (char32_t c = 0x1930; c <= 0x1931; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1390:29): [True: 2, False: 1]
  ------------------
 1391|      1|  (*smap)[0x1932] = U_Limbu;
 1392|      7|  for (char32_t c = 0x1933; c <= 0x1938; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1392:29): [True: 6, False: 1]
  ------------------
 1393|      4|  for (char32_t c = 0x1939; c <= 0x193B; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1393:29): [True: 3, False: 1]
  ------------------
 1394|      1|  (*smap)[0x1940] = U_Limbu;
 1395|      3|  for (char32_t c = 0x1944; c <= 0x1945; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1395:29): [True: 2, False: 1]
  ------------------
 1396|     11|  for (char32_t c = 0x1946; c <= 0x194F; ++c) (*smap)[c] = U_Limbu;
  ------------------
  |  Branch (1396:29): [True: 10, False: 1]
  ------------------
 1397|     31|  for (char32_t c = 0x1950; c <= 0x196D; ++c) (*smap)[c] = U_Tai_Le;
  ------------------
  |  Branch (1397:29): [True: 30, False: 1]
  ------------------
 1398|      6|  for (char32_t c = 0x1970; c <= 0x1974; ++c) (*smap)[c] = U_Tai_Le;
  ------------------
  |  Branch (1398:29): [True: 5, False: 1]
  ------------------
 1399|     13|  for (char32_t c = 0x10000; c <= 0x1000B; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1399:30): [True: 12, False: 1]
  ------------------
 1400|     27|  for (char32_t c = 0x1000D; c <= 0x10026; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1400:30): [True: 26, False: 1]
  ------------------
 1401|     20|  for (char32_t c = 0x10028; c <= 0x1003A; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1401:30): [True: 19, False: 1]
  ------------------
 1402|      3|  for (char32_t c = 0x1003C; c <= 0x1003D; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1402:30): [True: 2, False: 1]
  ------------------
 1403|     16|  for (char32_t c = 0x1003F; c <= 0x1004D; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1403:30): [True: 15, False: 1]
  ------------------
 1404|     15|  for (char32_t c = 0x10050; c <= 0x1005D; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1404:30): [True: 14, False: 1]
  ------------------
 1405|    124|  for (char32_t c = 0x10080; c <= 0x100FA; ++c) (*smap)[c] = U_Linear_B;
  ------------------
  |  Branch (1405:30): [True: 123, False: 1]
  ------------------
 1406|     31|  for (char32_t c = 0x10380; c <= 0x1039D; ++c) (*smap)[c] = U_Ugaritic;
  ------------------
  |  Branch (1406:30): [True: 30, False: 1]
  ------------------
 1407|      1|  (*smap)[0x1039F] = U_Ugaritic;
 1408|     49|  for (char32_t c = 0x10450; c <= 0x1047F; ++c) (*smap)[c] = U_Shavian;
  ------------------
  |  Branch (1408:30): [True: 48, False: 1]
  ------------------
 1409|     31|  for (char32_t c = 0x10480; c <= 0x1049D; ++c) (*smap)[c] = U_Osmanya;
  ------------------
  |  Branch (1409:30): [True: 30, False: 1]
  ------------------
 1410|     11|  for (char32_t c = 0x104A0; c <= 0x104A9; ++c) (*smap)[c] = U_Osmanya;
  ------------------
  |  Branch (1410:30): [True: 10, False: 1]
  ------------------
 1411|      7|  for (char32_t c = 0x10800; c <= 0x10805; ++c) (*smap)[c] = U_Cypriot;
  ------------------
  |  Branch (1411:30): [True: 6, False: 1]
  ------------------
 1412|      1|  (*smap)[0x10808] = U_Cypriot;
 1413|     45|  for (char32_t c = 0x1080A; c <= 0x10835; ++c) (*smap)[c] = U_Cypriot;
  ------------------
  |  Branch (1413:30): [True: 44, False: 1]
  ------------------
 1414|      3|  for (char32_t c = 0x10837; c <= 0x10838; ++c) (*smap)[c] = U_Cypriot;
  ------------------
  |  Branch (1414:30): [True: 2, False: 1]
  ------------------
 1415|      1|  (*smap)[0x1083C] = U_Cypriot;
 1416|      1|  (*smap)[0x1083F] = U_Cypriot;
 1417|    257|  for (char32_t c = 0x2800; c <= 0x28FF; ++c) (*smap)[c] = U_Braille;
  ------------------
  |  Branch (1417:29): [True: 256, False: 1]
  ------------------
 1418|     24|  for (char32_t c = 0x1A00; c <= 0x1A16; ++c) (*smap)[c] = U_Buginese;
  ------------------
  |  Branch (1418:29): [True: 23, False: 1]
  ------------------
 1419|      3|  for (char32_t c = 0x1A17; c <= 0x1A18; ++c) (*smap)[c] = U_Buginese;
  ------------------
  |  Branch (1419:29): [True: 2, False: 1]
  ------------------
 1420|      3|  for (char32_t c = 0x1A19; c <= 0x1A1A; ++c) (*smap)[c] = U_Buginese;
  ------------------
  |  Branch (1420:29): [True: 2, False: 1]
  ------------------
 1421|      1|  (*smap)[0x1A1B] = U_Buginese;
 1422|      3|  for (char32_t c = 0x1A1E; c <= 0x1A1F; ++c) (*smap)[c] = U_Buginese;
  ------------------
  |  Branch (1422:29): [True: 2, False: 1]
  ------------------
 1423|     15|  for (char32_t c = 0x03E2; c <= 0x03EF; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1423:29): [True: 14, False: 1]
  ------------------
 1424|    102|  for (char32_t c = 0x2C80; c <= 0x2CE4; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1424:29): [True: 101, False: 1]
  ------------------
 1425|      7|  for (char32_t c = 0x2CE5; c <= 0x2CEA; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1425:29): [True: 6, False: 1]
  ------------------
 1426|      5|  for (char32_t c = 0x2CEB; c <= 0x2CEE; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1426:29): [True: 4, False: 1]
  ------------------
 1427|      4|  for (char32_t c = 0x2CEF; c <= 0x2CF1; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1427:29): [True: 3, False: 1]
  ------------------
 1428|      3|  for (char32_t c = 0x2CF2; c <= 0x2CF3; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1428:29): [True: 2, False: 1]
  ------------------
 1429|      5|  for (char32_t c = 0x2CF9; c <= 0x2CFC; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1429:29): [True: 4, False: 1]
  ------------------
 1430|      1|  (*smap)[0x2CFD] = U_Coptic;
 1431|      3|  for (char32_t c = 0x2CFE; c <= 0x2CFF; ++c) (*smap)[c] = U_Coptic;
  ------------------
  |  Branch (1431:29): [True: 2, False: 1]
  ------------------
 1432|     45|  for (char32_t c = 0x1980; c <= 0x19AB; ++c) (*smap)[c] = U_New_Tai_Lue;
  ------------------
  |  Branch (1432:29): [True: 44, False: 1]
  ------------------
 1433|     27|  for (char32_t c = 0x19B0; c <= 0x19C9; ++c) (*smap)[c] = U_New_Tai_Lue;
  ------------------
  |  Branch (1433:29): [True: 26, False: 1]
  ------------------
 1434|     11|  for (char32_t c = 0x19D0; c <= 0x19D9; ++c) (*smap)[c] = U_New_Tai_Lue;
  ------------------
  |  Branch (1434:29): [True: 10, False: 1]
  ------------------
 1435|      1|  (*smap)[0x19DA] = U_New_Tai_Lue;
 1436|      3|  for (char32_t c = 0x19DE; c <= 0x19DF; ++c) (*smap)[c] = U_New_Tai_Lue;
  ------------------
  |  Branch (1436:29): [True: 2, False: 1]
  ------------------
 1437|     48|  for (char32_t c = 0x2C00; c <= 0x2C2E; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1437:29): [True: 47, False: 1]
  ------------------
 1438|     48|  for (char32_t c = 0x2C30; c <= 0x2C5E; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1438:29): [True: 47, False: 1]
  ------------------
 1439|      8|  for (char32_t c = 0x1E000; c <= 0x1E006; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1439:30): [True: 7, False: 1]
  ------------------
 1440|     18|  for (char32_t c = 0x1E008; c <= 0x1E018; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1440:30): [True: 17, False: 1]
  ------------------
 1441|      8|  for (char32_t c = 0x1E01B; c <= 0x1E021; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1441:30): [True: 7, False: 1]
  ------------------
 1442|      3|  for (char32_t c = 0x1E023; c <= 0x1E024; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1442:30): [True: 2, False: 1]
  ------------------
 1443|      6|  for (char32_t c = 0x1E026; c <= 0x1E02A; ++c) (*smap)[c] = U_Glagolitic;
  ------------------
  |  Branch (1443:30): [True: 5, False: 1]
  ------------------
 1444|     57|  for (char32_t c = 0x2D30; c <= 0x2D67; ++c) (*smap)[c] = U_Tifinagh;
  ------------------
  |  Branch (1444:29): [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_t c = 0xA800; c <= 0xA801; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1448:29): [True: 2, False: 1]
  ------------------
 1449|      1|  (*smap)[0xA802] = U_Syloti_Nagri;
 1450|      4|  for (char32_t c = 0xA803; c <= 0xA805; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1450:29): [True: 3, False: 1]
  ------------------
 1451|      1|  (*smap)[0xA806] = U_Syloti_Nagri;
 1452|      5|  for (char32_t c = 0xA807; c <= 0xA80A; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1452:29): [True: 4, False: 1]
  ------------------
 1453|      1|  (*smap)[0xA80B] = U_Syloti_Nagri;
 1454|     24|  for (char32_t c = 0xA80C; c <= 0xA822; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1454:29): [True: 23, False: 1]
  ------------------
 1455|      3|  for (char32_t c = 0xA823; c <= 0xA824; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1455:29): [True: 2, False: 1]
  ------------------
 1456|      3|  for (char32_t c = 0xA825; c <= 0xA826; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1456:29): [True: 2, False: 1]
  ------------------
 1457|      1|  (*smap)[0xA827] = U_Syloti_Nagri;
 1458|      5|  for (char32_t c = 0xA828; c <= 0xA82B; ++c) (*smap)[c] = U_Syloti_Nagri;
  ------------------
  |  Branch (1458:29): [True: 4, False: 1]
  ------------------
 1459|     37|  for (char32_t c = 0x103A0; c <= 0x103C3; ++c) (*smap)[c] = U_Old_Persian;
  ------------------
  |  Branch (1459:30): [True: 36, False: 1]
  ------------------
 1460|      9|  for (char32_t c = 0x103C8; c <= 0x103CF; ++c) (*smap)[c] = U_Old_Persian;
  ------------------
  |  Branch (1460:30): [True: 8, False: 1]
  ------------------
 1461|      1|  (*smap)[0x103D0] = U_Old_Persian;
 1462|      6|  for (char32_t c = 0x103D1; c <= 0x103D5; ++c) (*smap)[c] = U_Old_Persian;
  ------------------
  |  Branch (1462:30): [True: 5, False: 1]
  ------------------
 1463|      1|  (*smap)[0x10A00] = U_Kharoshthi;
 1464|      4|  for (char32_t c = 0x10A01; c <= 0x10A03; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1464:30): [True: 3, False: 1]
  ------------------
 1465|      3|  for (char32_t c = 0x10A05; c <= 0x10A06; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1465:30): [True: 2, False: 1]
  ------------------
 1466|      5|  for (char32_t c = 0x10A0C; c <= 0x10A0F; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1466:30): [True: 4, False: 1]
  ------------------
 1467|      5|  for (char32_t c = 0x10A10; c <= 0x10A13; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1467:30): [True: 4, False: 1]
  ------------------
 1468|      4|  for (char32_t c = 0x10A15; c <= 0x10A17; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1468:30): [True: 3, False: 1]
  ------------------
 1469|     28|  for (char32_t c = 0x10A19; c <= 0x10A33; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1469:30): [True: 27, False: 1]
  ------------------
 1470|      4|  for (char32_t c = 0x10A38; c <= 0x10A3A; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1470:30): [True: 3, False: 1]
  ------------------
 1471|      1|  (*smap)[0x10A3F] = U_Kharoshthi;
 1472|      9|  for (char32_t c = 0x10A40; c <= 0x10A47; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1472:30): [True: 8, False: 1]
  ------------------
 1473|     10|  for (char32_t c = 0x10A50; c <= 0x10A58; ++c) (*smap)[c] = U_Kharoshthi;
  ------------------
  |  Branch (1473:30): [True: 9, False: 1]
  ------------------
 1474|      5|  for (char32_t c = 0x1B00; c <= 0x1B03; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1474:29): [True: 4, False: 1]
  ------------------
 1475|      1|  (*smap)[0x1B04] = U_Balinese;
 1476|     48|  for (char32_t c = 0x1B05; c <= 0x1B33; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1476:29): [True: 47, False: 1]
  ------------------
 1477|      1|  (*smap)[0x1B34] = U_Balinese;
 1478|      1|  (*smap)[0x1B35] = U_Balinese;
 1479|      6|  for (char32_t c = 0x1B36; c <= 0x1B3A; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1479:29): [True: 5, False: 1]
  ------------------
 1480|      1|  (*smap)[0x1B3B] = U_Balinese;
 1481|      1|  (*smap)[0x1B3C] = U_Balinese;
 1482|      6|  for (char32_t c = 0x1B3D; c <= 0x1B41; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1482:29): [True: 5, False: 1]
  ------------------
 1483|      1|  (*smap)[0x1B42] = U_Balinese;
 1484|      3|  for (char32_t c = 0x1B43; c <= 0x1B44; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1484:29): [True: 2, False: 1]
  ------------------
 1485|      8|  for (char32_t c = 0x1B45; c <= 0x1B4B; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1485:29): [True: 7, False: 1]
  ------------------
 1486|     11|  for (char32_t c = 0x1B50; c <= 0x1B59; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1486:29): [True: 10, False: 1]
  ------------------
 1487|      8|  for (char32_t c = 0x1B5A; c <= 0x1B60; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1487:29): [True: 7, False: 1]
  ------------------
 1488|     11|  for (char32_t c = 0x1B61; c <= 0x1B6A; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1488:29): [True: 10, False: 1]
  ------------------
 1489|     10|  for (char32_t c = 0x1B6B; c <= 0x1B73; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1489:29): [True: 9, False: 1]
  ------------------
 1490|     10|  for (char32_t c = 0x1B74; c <= 0x1B7C; ++c) (*smap)[c] = U_Balinese;
  ------------------
  |  Branch (1490:29): [True: 9, False: 1]
  ------------------
 1491|    923|  for (char32_t c = 0x12000; c <= 0x12399; ++c) (*smap)[c] = U_Cuneiform;
  ------------------
  |  Branch (1491:30): [True: 922, False: 1]
  ------------------
 1492|    112|  for (char32_t c = 0x12400; c <= 0x1246E; ++c) (*smap)[c] = U_Cuneiform;
  ------------------
  |  Branch (1492:30): [True: 111, False: 1]
  ------------------
 1493|      6|  for (char32_t c = 0x12470; c <= 0x12474; ++c) (*smap)[c] = U_Cuneiform;
  ------------------
  |  Branch (1493:30): [True: 5, False: 1]
  ------------------
 1494|    197|  for (char32_t c = 0x12480; c <= 0x12543; ++c) (*smap)[c] = U_Cuneiform;
  ------------------
  |  Branch (1494:30): [True: 196, False: 1]
  ------------------
 1495|     23|  for (char32_t c = 0x10900; c <= 0x10915; ++c) (*smap)[c] = U_Phoenician;
  ------------------
  |  Branch (1495:30): [True: 22, False: 1]
  ------------------
 1496|      7|  for (char32_t c = 0x10916; c <= 0x1091B; ++c) (*smap)[c] = U_Phoenician;
  ------------------
  |  Branch (1496:30): [True: 6, False: 1]
  ------------------
 1497|      1|  (*smap)[0x1091F] = U_Phoenician;
 1498|     53|  for (char32_t c = 0xA840; c <= 0xA873; ++c) (*smap)[c] = U_Phags_Pa;
  ------------------
  |  Branch (1498:29): [True: 52, False: 1]
  ------------------
 1499|      5|  for (char32_t c = 0xA874; c <= 0xA877; ++c) (*smap)[c] = U_Phags_Pa;
  ------------------
  |  Branch (1499:29): [True: 4, False: 1]
  ------------------
 1500|     11|  for (char32_t c = 0x07C0; c <= 0x07C9; ++c) (*smap)[c] = U_Nko;
  ------------------
  |  Branch (1500:29): [True: 10, False: 1]
  ------------------
 1501|     34|  for (char32_t c = 0x07CA; c <= 0x07EA; ++c) (*smap)[c] = U_Nko;
  ------------------
  |  Branch (1501:29): [True: 33, False: 1]
  ------------------
 1502|     10|  for (char32_t c = 0x07EB; c <= 0x07F3; ++c) (*smap)[c] = U_Nko;
  ------------------
  |  Branch (1502:29): [True: 9, False: 1]
  ------------------
 1503|      3|  for (char32_t c = 0x07F4; c <= 0x07F5; ++c) (*smap)[c] = U_Nko;
  ------------------
  |  Branch (1503:29): [True: 2, False: 1]
  ------------------
 1504|      1|  (*smap)[0x07F6] = U_Nko;
 1505|      4|  for (char32_t c = 0x07F7; c <= 0x07F9; ++c) (*smap)[c] = U_Nko;
  ------------------
  |  Branch (1505:29): [True: 3, False: 1]
  ------------------
 1506|      1|  (*smap)[0x07FA] = U_Nko;
 1507|      3|  for (char32_t c = 0x1B80; c <= 0x1B81; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1507:29): [True: 2, False: 1]
  ------------------
 1508|      1|  (*smap)[0x1B82] = U_Sundanese;
 1509|     31|  for (char32_t c = 0x1B83; c <= 0x1BA0; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1509:29): [True: 30, False: 1]
  ------------------
 1510|      1|  (*smap)[0x1BA1] = U_Sundanese;
 1511|      5|  for (char32_t c = 0x1BA2; c <= 0x1BA5; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1511:29): [True: 4, False: 1]
  ------------------
 1512|      3|  for (char32_t c = 0x1BA6; c <= 0x1BA7; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1512:29): [True: 2, False: 1]
  ------------------
 1513|      3|  for (char32_t c = 0x1BA8; c <= 0x1BA9; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1513:29): [True: 2, False: 1]
  ------------------
 1514|      1|  (*smap)[0x1BAA] = U_Sundanese;
 1515|      4|  for (char32_t c = 0x1BAB; c <= 0x1BAD; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1515:29): [True: 3, False: 1]
  ------------------
 1516|      3|  for (char32_t c = 0x1BAE; c <= 0x1BAF; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1516:29): [True: 2, False: 1]
  ------------------
 1517|     11|  for (char32_t c = 0x1BB0; c <= 0x1BB9; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1517:29): [True: 10, False: 1]
  ------------------
 1518|      7|  for (char32_t c = 0x1BBA; c <= 0x1BBF; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1518:29): [True: 6, False: 1]
  ------------------
 1519|      9|  for (char32_t c = 0x1CC0; c <= 0x1CC7; ++c) (*smap)[c] = U_Sundanese;
  ------------------
  |  Branch (1519:29): [True: 8, False: 1]
  ------------------
 1520|     37|  for (char32_t c = 0x1C00; c <= 0x1C23; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1520:29): [True: 36, False: 1]
  ------------------
 1521|      9|  for (char32_t c = 0x1C24; c <= 0x1C2B; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1521:29): [True: 8, False: 1]
  ------------------
 1522|      9|  for (char32_t c = 0x1C2C; c <= 0x1C33; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1522:29): [True: 8, False: 1]
  ------------------
 1523|      3|  for (char32_t c = 0x1C34; c <= 0x1C35; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1523:29): [True: 2, False: 1]
  ------------------
 1524|      3|  for (char32_t c = 0x1C36; c <= 0x1C37; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1524:29): [True: 2, False: 1]
  ------------------
 1525|      6|  for (char32_t c = 0x1C3B; c <= 0x1C3F; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1525:29): [True: 5, False: 1]
  ------------------
 1526|     11|  for (char32_t c = 0x1C40; c <= 0x1C49; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1526:29): [True: 10, False: 1]
  ------------------
 1527|      4|  for (char32_t c = 0x1C4D; c <= 0x1C4F; ++c) (*smap)[c] = U_Lepcha;
  ------------------
  |  Branch (1527:29): [True: 3, False: 1]
  ------------------
 1528|     11|  for (char32_t c = 0x1C50; c <= 0x1C59; ++c) (*smap)[c] = U_Ol_Chiki;
  ------------------
  |  Branch (1528:29): [True: 10, False: 1]
  ------------------
 1529|     31|  for (char32_t c = 0x1C5A; c <= 0x1C77; ++c) (*smap)[c] = U_Ol_Chiki;
  ------------------
  |  Branch (1529:29): [True: 30, False: 1]
  ------------------
 1530|      7|  for (char32_t c = 0x1C78; c <= 0x1C7D; ++c) (*smap)[c] = U_Ol_Chiki;
  ------------------
  |  Branch (1530:29): [True: 6, False: 1]
  ------------------
 1531|      3|  for (char32_t c = 0x1C7E; c <= 0x1C7F; ++c) (*smap)[c] = U_Ol_Chiki;
  ------------------
  |  Branch (1531:29): [True: 2, False: 1]
  ------------------
 1532|    269|  for (char32_t c = 0xA500; c <= 0xA60B; ++c) (*smap)[c] = U_Vai;
  ------------------
  |  Branch (1532:29): [True: 268, False: 1]
  ------------------
 1533|      1|  (*smap)[0xA60C] = U_Vai;
 1534|      4|  for (char32_t c = 0xA60D; c <= 0xA60F; ++c) (*smap)[c] = U_Vai;
  ------------------
  |  Branch (1534:29): [True: 3, False: 1]
  ------------------
 1535|     17|  for (char32_t c = 0xA610; c <= 0xA61F; ++c) (*smap)[c] = U_Vai;
  ------------------
  |  Branch (1535:29): [True: 16, False: 1]
  ------------------
 1536|     11|  for (char32_t c = 0xA620; c <= 0xA629; ++c) (*smap)[c] = U_Vai;
  ------------------
  |  Branch (1536:29): [True: 10, False: 1]
  ------------------
 1537|      3|  for (char32_t c = 0xA62A; c <= 0xA62B; ++c) (*smap)[c] = U_Vai;
  ------------------
  |  Branch (1537:29): [True: 2, False: 1]
  ------------------
 1538|      3|  for (char32_t c = 0xA880; c <= 0xA881; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1538:29): [True: 2, False: 1]
  ------------------
 1539|     51|  for (char32_t c = 0xA882; c <= 0xA8B3; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1539:29): [True: 50, False: 1]
  ------------------
 1540|     17|  for (char32_t c = 0xA8B4; c <= 0xA8C3; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1540:29): [True: 16, False: 1]
  ------------------
 1541|      3|  for (char32_t c = 0xA8C4; c <= 0xA8C5; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1541:29): [True: 2, False: 1]
  ------------------
 1542|      3|  for (char32_t c = 0xA8CE; c <= 0xA8CF; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1542:29): [True: 2, False: 1]
  ------------------
 1543|     11|  for (char32_t c = 0xA8D0; c <= 0xA8D9; ++c) (*smap)[c] = U_Saurashtra;
  ------------------
  |  Branch (1543:29): [True: 10, False: 1]
  ------------------
 1544|     11|  for (char32_t c = 0xA900; c <= 0xA909; ++c) (*smap)[c] = U_Kayah_Li;
  ------------------
  |  Branch (1544:29): [True: 10, False: 1]
  ------------------
 1545|     29|  for (char32_t c = 0xA90A; c <= 0xA925; ++c) (*smap)[c] = U_Kayah_Li;
  ------------------
  |  Branch (1545:29): [True: 28, False: 1]
  ------------------
 1546|      9|  for (char32_t c = 0xA926; c <= 0xA92D; ++c) (*smap)[c] = U_Kayah_Li;
  ------------------
  |  Branch (1546:29): [True: 8, False: 1]
  ------------------
 1547|      1|  (*smap)[0xA92F] = U_Kayah_Li;
 1548|     24|  for (char32_t c = 0xA930; c <= 0xA946; ++c) (*smap)[c] = U_Rejang;
  ------------------
  |  Branch (1548:29): [True: 23, False: 1]
  ------------------
 1549|     12|  for (char32_t c = 0xA947; c <= 0xA951; ++c) (*smap)[c] = U_Rejang;
  ------------------
  |  Branch (1549:29): [True: 11, False: 1]
  ------------------
 1550|      3|  for (char32_t c = 0xA952; c <= 0xA953; ++c) (*smap)[c] = U_Rejang;
  ------------------
  |  Branch (1550:29): [True: 2, False: 1]
  ------------------
 1551|      1|  (*smap)[0xA95F] = U_Rejang;
 1552|     30|  for (char32_t c = 0x10280; c <= 0x1029C; ++c) (*smap)[c] = U_Lycian;
  ------------------
  |  Branch (1552:30): [True: 29, False: 1]
  ------------------
 1553|     50|  for (char32_t c = 0x102A0; c <= 0x102D0; ++c) (*smap)[c] = U_Carian;
  ------------------
  |  Branch (1553:30): [True: 49, False: 1]
  ------------------
 1554|     27|  for (char32_t c = 0x10920; c <= 0x10939; ++c) (*smap)[c] = U_Lydian;
  ------------------
  |  Branch (1554:30): [True: 26, False: 1]
  ------------------
 1555|      1|  (*smap)[0x1093F] = U_Lydian;
 1556|     42|  for (char32_t c = 0xAA00; c <= 0xAA28; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1556:29): [True: 41, False: 1]
  ------------------
 1557|      7|  for (char32_t c = 0xAA29; c <= 0xAA2E; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1557:29): [True: 6, False: 1]
  ------------------
 1558|      3|  for (char32_t c = 0xAA2F; c <= 0xAA30; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1558:29): [True: 2, False: 1]
  ------------------
 1559|      3|  for (char32_t c = 0xAA31; c <= 0xAA32; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1559:29): [True: 2, False: 1]
  ------------------
 1560|      3|  for (char32_t c = 0xAA33; c <= 0xAA34; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1560:29): [True: 2, False: 1]
  ------------------
 1561|      3|  for (char32_t c = 0xAA35; c <= 0xAA36; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1561:29): [True: 2, False: 1]
  ------------------
 1562|      4|  for (char32_t c = 0xAA40; c <= 0xAA42; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1562:29): [True: 3, False: 1]
  ------------------
 1563|      1|  (*smap)[0xAA43] = U_Cham;
 1564|      9|  for (char32_t c = 0xAA44; c <= 0xAA4B; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1564:29): [True: 8, False: 1]
  ------------------
 1565|      1|  (*smap)[0xAA4C] = U_Cham;
 1566|      1|  (*smap)[0xAA4D] = U_Cham;
 1567|     11|  for (char32_t c = 0xAA50; c <= 0xAA59; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1567:29): [True: 10, False: 1]
  ------------------
 1568|      5|  for (char32_t c = 0xAA5C; c <= 0xAA5F; ++c) (*smap)[c] = U_Cham;
  ------------------
  |  Branch (1568:29): [True: 4, False: 1]
  ------------------
 1569|     54|  for (char32_t c = 0x1A20; c <= 0x1A54; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1569:29): [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_t c = 0x1A58; c <= 0x1A5E; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1573:29): [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_t c = 0x1A63; c <= 0x1A64; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1577:29): [True: 2, False: 1]
  ------------------
 1578|      9|  for (char32_t c = 0x1A65; c <= 0x1A6C; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1578:29): [True: 8, False: 1]
  ------------------
 1579|      7|  for (char32_t c = 0x1A6D; c <= 0x1A72; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1579:29): [True: 6, False: 1]
  ------------------
 1580|     11|  for (char32_t c = 0x1A73; c <= 0x1A7C; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1580:29): [True: 10, False: 1]
  ------------------
 1581|      1|  (*smap)[0x1A7F] = U_Tai_Tham;
 1582|     11|  for (char32_t c = 0x1A80; c <= 0x1A89; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1582:29): [True: 10, False: 1]
  ------------------
 1583|     11|  for (char32_t c = 0x1A90; c <= 0x1A99; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1583:29): [True: 10, False: 1]
  ------------------
 1584|      8|  for (char32_t c = 0x1AA0; c <= 0x1AA6; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1584:29): [True: 7, False: 1]
  ------------------
 1585|      1|  (*smap)[0x1AA7] = U_Tai_Tham;
 1586|      7|  for (char32_t c = 0x1AA8; c <= 0x1AAD; ++c) (*smap)[c] = U_Tai_Tham;
  ------------------
  |  Branch (1586:29): [True: 6, False: 1]
  ------------------
 1587|     49|  for (char32_t c = 0xAA80; c <= 0xAAAF; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1587:29): [True: 48, False: 1]
  ------------------
 1588|      1|  (*smap)[0xAAB0] = U_Tai_Viet;
 1589|      1|  (*smap)[0xAAB1] = U_Tai_Viet;
 1590|      4|  for (char32_t c = 0xAAB2; c <= 0xAAB4; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1590:29): [True: 3, False: 1]
  ------------------
 1591|      3|  for (char32_t c = 0xAAB5; c <= 0xAAB6; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1591:29): [True: 2, False: 1]
  ------------------
 1592|      3|  for (char32_t c = 0xAAB7; c <= 0xAAB8; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1592:29): [True: 2, False: 1]
  ------------------
 1593|      6|  for (char32_t c = 0xAAB9; c <= 0xAABD; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1593:29): [True: 5, False: 1]
  ------------------
 1594|      3|  for (char32_t c = 0xAABE; c <= 0xAABF; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1594:29): [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_t c = 0xAADB; c <= 0xAADC; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1598:29): [True: 2, False: 1]
  ------------------
 1599|      1|  (*smap)[0xAADD] = U_Tai_Viet;
 1600|      3|  for (char32_t c = 0xAADE; c <= 0xAADF; ++c) (*smap)[c] = U_Tai_Viet;
  ------------------
  |  Branch (1600:29): [True: 2, False: 1]
  ------------------
 1601|     55|  for (char32_t c = 0x10B00; c <= 0x10B35; ++c) (*smap)[c] = U_Avestan;
  ------------------
  |  Branch (1601:30): [True: 54, False: 1]
  ------------------
 1602|      8|  for (char32_t c = 0x10B39; c <= 0x10B3F; ++c) (*smap)[c] = U_Avestan;
  ------------------
  |  Branch (1602:30): [True: 7, False: 1]
  ------------------
 1603|  1.07k|  for (char32_t c = 0x13000; c <= 0x1342E; ++c)
  ------------------
  |  Branch (1603:30): [True: 1.07k, False: 1]
  ------------------
 1604|  1.07k|    (*smap)[c] = U_Egyptian_Hieroglyphs;
 1605|     23|  for (char32_t c = 0x0800; c <= 0x0815; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1605:29): [True: 22, False: 1]
  ------------------
 1606|      5|  for (char32_t c = 0x0816; c <= 0x0819; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1606:29): [True: 4, False: 1]
  ------------------
 1607|      1|  (*smap)[0x081A] = U_Samaritan;
 1608|     10|  for (char32_t c = 0x081B; c <= 0x0823; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1608:29): [True: 9, False: 1]
  ------------------
 1609|      1|  (*smap)[0x0824] = U_Samaritan;
 1610|      4|  for (char32_t c = 0x0825; c <= 0x0827; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1610:29): [True: 3, False: 1]
  ------------------
 1611|      1|  (*smap)[0x0828] = U_Samaritan;
 1612|      6|  for (char32_t c = 0x0829; c <= 0x082D; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1612:29): [True: 5, False: 1]
  ------------------
 1613|     16|  for (char32_t c = 0x0830; c <= 0x083E; ++c) (*smap)[c] = U_Samaritan;
  ------------------
  |  Branch (1613:29): [True: 15, False: 1]
  ------------------
 1614|     41|  for (char32_t c = 0xA4D0; c <= 0xA4F7; ++c) (*smap)[c] = U_Lisu;
  ------------------
  |  Branch (1614:29): [True: 40, False: 1]
  ------------------
 1615|      7|  for (char32_t c = 0xA4F8; c <= 0xA4FD; ++c) (*smap)[c] = U_Lisu;
  ------------------
  |  Branch (1615:29): [True: 6, False: 1]
  ------------------
 1616|      3|  for (char32_t c = 0xA4FE; c <= 0xA4FF; ++c) (*smap)[c] = U_Lisu;
  ------------------
  |  Branch (1616:29): [True: 2, False: 1]
  ------------------
 1617|     71|  for (char32_t c = 0xA6A0; c <= 0xA6E5; ++c) (*smap)[c] = U_Bamum;
  ------------------
  |  Branch (1617:29): [True: 70, False: 1]
  ------------------
 1618|     11|  for (char32_t c = 0xA6E6; c <= 0xA6EF; ++c) (*smap)[c] = U_Bamum;
  ------------------
  |  Branch (1618:29): [True: 10, False: 1]
  ------------------
 1619|      3|  for (char32_t c = 0xA6F0; c <= 0xA6F1; ++c) (*smap)[c] = U_Bamum;
  ------------------
  |  Branch (1619:29): [True: 2, False: 1]
  ------------------
 1620|      7|  for (char32_t c = 0xA6F2; c <= 0xA6F7; ++c) (*smap)[c] = U_Bamum;
  ------------------
  |  Branch (1620:29): [True: 6, False: 1]
  ------------------
 1621|    570|  for (char32_t c = 0x16800; c <= 0x16A38; ++c) (*smap)[c] = U_Bamum;
  ------------------
  |  Branch (1621:30): [True: 569, False: 1]
  ------------------
 1622|      4|  for (char32_t c = 0xA980; c <= 0xA982; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1622:29): [True: 3, False: 1]
  ------------------
 1623|      1|  (*smap)[0xA983] = U_Javanese;
 1624|     48|  for (char32_t c = 0xA984; c <= 0xA9B2; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1624:29): [True: 47, False: 1]
  ------------------
 1625|      1|  (*smap)[0xA9B3] = U_Javanese;
 1626|      3|  for (char32_t c = 0xA9B4; c <= 0xA9B5; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1626:29): [True: 2, False: 1]
  ------------------
 1627|      5|  for (char32_t c = 0xA9B6; c <= 0xA9B9; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1627:29): [True: 4, False: 1]
  ------------------
 1628|      3|  for (char32_t c = 0xA9BA; c <= 0xA9BB; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1628:29): [True: 2, False: 1]
  ------------------
 1629|      1|  (*smap)[0xA9BC] = U_Javanese;
 1630|      5|  for (char32_t c = 0xA9BD; c <= 0xA9C0; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1630:29): [True: 4, False: 1]
  ------------------
 1631|     14|  for (char32_t c = 0xA9C1; c <= 0xA9CD; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1631:29): [True: 13, False: 1]
  ------------------
 1632|     11|  for (char32_t c = 0xA9D0; c <= 0xA9D9; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1632:29): [True: 10, False: 1]
  ------------------
 1633|      3|  for (char32_t c = 0xA9DE; c <= 0xA9DF; ++c) (*smap)[c] = U_Javanese;
  ------------------
  |  Branch (1633:29): [True: 2, False: 1]
  ------------------
 1634|     12|  for (char32_t c = 0xAAE0; c <= 0xAAEA; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1634:29): [True: 11, False: 1]
  ------------------
 1635|      1|  (*smap)[0xAAEB] = U_Meetei_Mayek;
 1636|      3|  for (char32_t c = 0xAAEC; c <= 0xAAED; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1636:29): [True: 2, False: 1]
  ------------------
 1637|      3|  for (char32_t c = 0xAAEE; c <= 0xAAEF; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1637:29): [True: 2, False: 1]
  ------------------
 1638|      3|  for (char32_t c = 0xAAF0; c <= 0xAAF1; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1638:29): [True: 2, False: 1]
  ------------------
 1639|      1|  (*smap)[0xAAF2] = U_Meetei_Mayek;
 1640|      3|  for (char32_t c = 0xAAF3; c <= 0xAAF4; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1640:29): [True: 2, False: 1]
  ------------------
 1641|      1|  (*smap)[0xAAF5] = U_Meetei_Mayek;
 1642|      1|  (*smap)[0xAAF6] = U_Meetei_Mayek;
 1643|     36|  for (char32_t c = 0xABC0; c <= 0xABE2; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1643:29): [True: 35, False: 1]
  ------------------
 1644|      3|  for (char32_t c = 0xABE3; c <= 0xABE4; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1644:29): [True: 2, False: 1]
  ------------------
 1645|      1|  (*smap)[0xABE5] = U_Meetei_Mayek;
 1646|      3|  for (char32_t c = 0xABE6; c <= 0xABE7; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1646:29): [True: 2, False: 1]
  ------------------
 1647|      1|  (*smap)[0xABE8] = U_Meetei_Mayek;
 1648|      3|  for (char32_t c = 0xABE9; c <= 0xABEA; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1648:29): [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_t c = 0xABF0; c <= 0xABF9; ++c) (*smap)[c] = U_Meetei_Mayek;
  ------------------
  |  Branch (1652:29): [True: 10, False: 1]
  ------------------
 1653|     23|  for (char32_t c = 0x10840; c <= 0x10855; ++c) (*smap)[c] = U_Imperial_Aramaic;
  ------------------
  |  Branch (1653:30): [True: 22, False: 1]
  ------------------
 1654|      1|  (*smap)[0x10857] = U_Imperial_Aramaic;
 1655|      9|  for (char32_t c = 0x10858; c <= 0x1085F; ++c) (*smap)[c] = U_Imperial_Aramaic;
  ------------------
  |  Branch (1655:30): [True: 8, False: 1]
  ------------------
 1656|     30|  for (char32_t c = 0x10A60; c <= 0x10A7C; ++c) (*smap)[c] = U_Old_South_Arabian;
  ------------------
  |  Branch (1656:30): [True: 29, False: 1]
  ------------------
 1657|      3|  for (char32_t c = 0x10A7D; c <= 0x10A7E; ++c) (*smap)[c] = U_Old_South_Arabian;
  ------------------
  |  Branch (1657:30): [True: 2, False: 1]
  ------------------
 1658|      1|  (*smap)[0x10A7F] = U_Old_South_Arabian;
 1659|     23|  for (char32_t c = 0x10B40; c <= 0x10B55; ++c)
  ------------------
  |  Branch (1659:30): [True: 22, False: 1]
  ------------------
 1660|     22|    (*smap)[c] = U_Inscriptional_Parthian;
 1661|      9|  for (char32_t c = 0x10B58; c <= 0x10B5F; ++c)
  ------------------
  |  Branch (1661:30): [True: 8, False: 1]
  ------------------
 1662|      8|    (*smap)[c] = U_Inscriptional_Parthian;
 1663|     20|  for (char32_t c = 0x10B60; c <= 0x10B72; ++c)
  ------------------
  |  Branch (1663:30): [True: 19, False: 1]
  ------------------
 1664|     19|    (*smap)[c] = U_Inscriptional_Pahlavi;
 1665|      9|  for (char32_t c = 0x10B78; c <= 0x10B7F; ++c)
  ------------------
  |  Branch (1665:30): [True: 8, False: 1]
  ------------------
 1666|      8|    (*smap)[c] = U_Inscriptional_Pahlavi;
 1667|     74|  for (char32_t c = 0x10C00; c <= 0x10C48; ++c) (*smap)[c] = U_Old_Turkic;
  ------------------
  |  Branch (1667:30): [True: 73, False: 1]
  ------------------
 1668|      3|  for (char32_t c = 0x11080; c <= 0x11081; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1668:30): [True: 2, False: 1]
  ------------------
 1669|      1|  (*smap)[0x11082] = U_Kaithi;
 1670|     46|  for (char32_t c = 0x11083; c <= 0x110AF; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1670:30): [True: 45, False: 1]
  ------------------
 1671|      4|  for (char32_t c = 0x110B0; c <= 0x110B2; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1671:30): [True: 3, False: 1]
  ------------------
 1672|      5|  for (char32_t c = 0x110B3; c <= 0x110B6; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1672:30): [True: 4, False: 1]
  ------------------
 1673|      3|  for (char32_t c = 0x110B7; c <= 0x110B8; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1673:30): [True: 2, False: 1]
  ------------------
 1674|      3|  for (char32_t c = 0x110B9; c <= 0x110BA; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1674:30): [True: 2, False: 1]
  ------------------
 1675|      3|  for (char32_t c = 0x110BB; c <= 0x110BC; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1675:30): [True: 2, False: 1]
  ------------------
 1676|      1|  (*smap)[0x110BD] = U_Kaithi;
 1677|      5|  for (char32_t c = 0x110BE; c <= 0x110C1; ++c) (*smap)[c] = U_Kaithi;
  ------------------
  |  Branch (1677:30): [True: 4, False: 1]
  ------------------
 1678|     39|  for (char32_t c = 0x1BC0; c <= 0x1BE5; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1678:29): [True: 38, False: 1]
  ------------------
 1679|      1|  (*smap)[0x1BE6] = U_Batak;
 1680|      1|  (*smap)[0x1BE7] = U_Batak;
 1681|      3|  for (char32_t c = 0x1BE8; c <= 0x1BE9; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1681:29): [True: 2, False: 1]
  ------------------
 1682|      4|  for (char32_t c = 0x1BEA; c <= 0x1BEC; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1682:29): [True: 3, False: 1]
  ------------------
 1683|      1|  (*smap)[0x1BED] = U_Batak;
 1684|      1|  (*smap)[0x1BEE] = U_Batak;
 1685|      4|  for (char32_t c = 0x1BEF; c <= 0x1BF1; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1685:29): [True: 3, False: 1]
  ------------------
 1686|      3|  for (char32_t c = 0x1BF2; c <= 0x1BF3; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1686:29): [True: 2, False: 1]
  ------------------
 1687|      5|  for (char32_t c = 0x1BFC; c <= 0x1BFF; ++c) (*smap)[c] = U_Batak;
  ------------------
  |  Branch (1687:29): [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_t c = 0x11003; c <= 0x11037; ++c) (*smap)[c] = U_Brahmi;
  ------------------
  |  Branch (1691:30): [True: 53, False: 1]
  ------------------
 1692|     16|  for (char32_t c = 0x11038; c <= 0x11046; ++c) (*smap)[c] = U_Brahmi;
  ------------------
  |  Branch (1692:30): [True: 15, False: 1]
  ------------------
 1693|      8|  for (char32_t c = 0x11047; c <= 0x1104D; ++c) (*smap)[c] = U_Brahmi;
  ------------------
  |  Branch (1693:30): [True: 7, False: 1]
  ------------------
 1694|     21|  for (char32_t c = 0x11052; c <= 0x11065; ++c) (*smap)[c] = U_Brahmi;
  ------------------
  |  Branch (1694:30): [True: 20, False: 1]
  ------------------
 1695|     11|  for (char32_t c = 0x11066; c <= 0x1106F; ++c) (*smap)[c] = U_Brahmi;
  ------------------
  |  Branch (1695:30): [True: 10, False: 1]
  ------------------
 1696|      1|  (*smap)[0x1107F] = U_Brahmi;
 1697|     26|  for (char32_t c = 0x0840; c <= 0x0858; ++c) (*smap)[c] = U_Mandaic;
  ------------------
  |  Branch (1697:29): [True: 25, False: 1]
  ------------------
 1698|      4|  for (char32_t c = 0x0859; c <= 0x085B; ++c) (*smap)[c] = U_Mandaic;
  ------------------
  |  Branch (1698:29): [True: 3, False: 1]
  ------------------
 1699|      1|  (*smap)[0x085E] = U_Mandaic;
 1700|      4|  for (char32_t c = 0x11100; c <= 0x11102; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1700:30): [True: 3, False: 1]
  ------------------
 1701|     37|  for (char32_t c = 0x11103; c <= 0x11126; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1701:30): [True: 36, False: 1]
  ------------------
 1702|      6|  for (char32_t c = 0x11127; c <= 0x1112B; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1702:30): [True: 5, False: 1]
  ------------------
 1703|      1|  (*smap)[0x1112C] = U_Chakma;
 1704|      9|  for (char32_t c = 0x1112D; c <= 0x11134; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1704:30): [True: 8, False: 1]
  ------------------
 1705|     11|  for (char32_t c = 0x11136; c <= 0x1113F; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1705:30): [True: 10, False: 1]
  ------------------
 1706|      5|  for (char32_t c = 0x11140; c <= 0x11143; ++c) (*smap)[c] = U_Chakma;
  ------------------
  |  Branch (1706:30): [True: 4, False: 1]
  ------------------
 1707|     25|  for (char32_t c = 0x109A0; c <= 0x109B7; ++c) (*smap)[c] = U_Meroitic_Cursive;
  ------------------
  |  Branch (1707:30): [True: 24, False: 1]
  ------------------
 1708|      3|  for (char32_t c = 0x109BC; c <= 0x109BD; ++c) (*smap)[c] = U_Meroitic_Cursive;
  ------------------
  |  Branch (1708:30): [True: 2, False: 1]
  ------------------
 1709|      3|  for (char32_t c = 0x109BE; c <= 0x109BF; ++c) (*smap)[c] = U_Meroitic_Cursive;
  ------------------
  |  Branch (1709:30): [True: 2, False: 1]
  ------------------
 1710|     17|  for (char32_t c = 0x109C0; c <= 0x109CF; ++c) (*smap)[c] = U_Meroitic_Cursive;
  ------------------
  |  Branch (1710:30): [True: 16, False: 1]
  ------------------
 1711|     47|  for (char32_t c = 0x109D2; c <= 0x109FF; ++c) (*smap)[c] = U_Meroitic_Cursive;
  ------------------
  |  Branch (1711:30): [True: 46, False: 1]
  ------------------
 1712|     33|  for (char32_t c = 0x10980; c <= 0x1099F; ++c)
  ------------------
  |  Branch (1712:30): [True: 32, False: 1]
  ------------------
 1713|     32|    (*smap)[c] = U_Meroitic_Hieroglyphs;
 1714|     70|  for (char32_t c = 0x16F00; c <= 0x16F44; ++c) (*smap)[c] = U_Miao;
  ------------------
  |  Branch (1714:30): [True: 69, False: 1]
  ------------------
 1715|      1|  (*smap)[0x16F50] = U_Miao;
 1716|     47|  for (char32_t c = 0x16F51; c <= 0x16F7E; ++c) (*smap)[c] = U_Miao;
  ------------------
  |  Branch (1716:30): [True: 46, False: 1]
  ------------------
 1717|      5|  for (char32_t c = 0x16F8F; c <= 0x16F92; ++c) (*smap)[c] = U_Miao;
  ------------------
  |  Branch (1717:30): [True: 4, False: 1]
  ------------------
 1718|     14|  for (char32_t c = 0x16F93; c <= 0x16F9F; ++c) (*smap)[c] = U_Miao;
  ------------------
  |  Branch (1718:30): [True: 13, False: 1]
  ------------------
 1719|      3|  for (char32_t c = 0x11180; c <= 0x11181; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1719:30): [True: 2, False: 1]
  ------------------
 1720|      1|  (*smap)[0x11182] = U_Sharada;
 1721|     49|  for (char32_t c = 0x11183; c <= 0x111B2; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1721:30): [True: 48, False: 1]
  ------------------
 1722|      4|  for (char32_t c = 0x111B3; c <= 0x111B5; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1722:30): [True: 3, False: 1]
  ------------------
 1723|     10|  for (char32_t c = 0x111B6; c <= 0x111BE; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1723:30): [True: 9, False: 1]
  ------------------
 1724|      3|  for (char32_t c = 0x111BF; c <= 0x111C0; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1724:30): [True: 2, False: 1]
  ------------------
 1725|      5|  for (char32_t c = 0x111C1; c <= 0x111C4; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1725:30): [True: 4, False: 1]
  ------------------
 1726|      6|  for (char32_t c = 0x111C5; c <= 0x111C9; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1726:30): [True: 5, False: 1]
  ------------------
 1727|      4|  for (char32_t c = 0x111CA; c <= 0x111CC; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1727:30): [True: 3, False: 1]
  ------------------
 1728|      1|  (*smap)[0x111CD] = U_Sharada;
 1729|     11|  for (char32_t c = 0x111D0; c <= 0x111D9; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1729:30): [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_t c = 0x111DD; c <= 0x111DF; ++c) (*smap)[c] = U_Sharada;
  ------------------
  |  Branch (1733:30): [True: 3, False: 1]
  ------------------
 1734|     26|  for (char32_t c = 0x110D0; c <= 0x110E8; ++c) (*smap)[c] = U_Sora_Sompeng;
  ------------------
  |  Branch (1734:30): [True: 25, False: 1]
  ------------------
 1735|     11|  for (char32_t c = 0x110F0; c <= 0x110F9; ++c) (*smap)[c] = U_Sora_Sompeng;
  ------------------
  |  Branch (1735:30): [True: 10, False: 1]
  ------------------
 1736|     44|  for (char32_t c = 0x11680; c <= 0x116AA; ++c) (*smap)[c] = U_Takri;
  ------------------
  |  Branch (1736:30): [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_t c = 0x116AE; c <= 0x116AF; ++c) (*smap)[c] = U_Takri;
  ------------------
  |  Branch (1740:30): [True: 2, False: 1]
  ------------------
 1741|      7|  for (char32_t c = 0x116B0; c <= 0x116B5; ++c) (*smap)[c] = U_Takri;
  ------------------
  |  Branch (1741:30): [True: 6, False: 1]
  ------------------
 1742|      1|  (*smap)[0x116B6] = U_Takri;
 1743|      1|  (*smap)[0x116B7] = U_Takri;
 1744|     11|  for (char32_t c = 0x116C0; c <= 0x116C9; ++c) (*smap)[c] = U_Takri;
  ------------------
  |  Branch (1744:30): [True: 10, False: 1]
  ------------------
 1745|     53|  for (char32_t c = 0x10530; c <= 0x10563; ++c) (*smap)[c] = U_Caucasian_Albanian;
  ------------------
  |  Branch (1745:30): [True: 52, False: 1]
  ------------------
 1746|      1|  (*smap)[0x1056F] = U_Caucasian_Albanian;
 1747|     31|  for (char32_t c = 0x16AD0; c <= 0x16AED; ++c) (*smap)[c] = U_Bassa_Vah;
  ------------------
  |  Branch (1747:30): [True: 30, False: 1]
  ------------------
 1748|      6|  for (char32_t c = 0x16AF0; c <= 0x16AF4; ++c) (*smap)[c] = U_Bassa_Vah;
  ------------------
  |  Branch (1748:30): [True: 5, False: 1]
  ------------------
 1749|      1|  (*smap)[0x16AF5] = U_Bassa_Vah;
 1750|    108|  for (char32_t c = 0x1BC00; c <= 0x1BC6A; ++c) (*smap)[c] = U_Duployan;
  ------------------
  |  Branch (1750:30): [True: 107, False: 1]
  ------------------
 1751|     14|  for (char32_t c = 0x1BC70; c <= 0x1BC7C; ++c) (*smap)[c] = U_Duployan;
  ------------------
  |  Branch (1751:30): [True: 13, False: 1]
  ------------------
 1752|     10|  for (char32_t c = 0x1BC80; c <= 0x1BC88; ++c) (*smap)[c] = U_Duployan;
  ------------------
  |  Branch (1752:30): [True: 9, False: 1]
  ------------------
 1753|     11|  for (char32_t c = 0x1BC90; c <= 0x1BC99; ++c) (*smap)[c] = U_Duployan;
  ------------------
  |  Branch (1753:30): [True: 10, False: 1]
  ------------------
 1754|      1|  (*smap)[0x1BC9C] = U_Duployan;
 1755|      3|  for (char32_t c = 0x1BC9D; c <= 0x1BC9E; ++c) (*smap)[c] = U_Duployan;
  ------------------
  |  Branch (1755:30): [True: 2, False: 1]
  ------------------
 1756|      1|  (*smap)[0x1BC9F] = U_Duployan;
 1757|     41|  for (char32_t c = 0x10500; c <= 0x10527; ++c) (*smap)[c] = U_Elbasan;
  ------------------
  |  Branch (1757:30): [True: 40, False: 1]
  ------------------
 1758|      3|  for (char32_t c = 0x11300; c <= 0x11301; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1758:30): [True: 2, False: 1]
  ------------------
 1759|      3|  for (char32_t c = 0x11302; c <= 0x11303; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1759:30): [True: 2, False: 1]
  ------------------
 1760|      9|  for (char32_t c = 0x11305; c <= 0x1130C; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1760:30): [True: 8, False: 1]
  ------------------
 1761|      3|  for (char32_t c = 0x1130F; c <= 0x11310; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1761:30): [True: 2, False: 1]
  ------------------
 1762|     23|  for (char32_t c = 0x11313; c <= 0x11328; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1762:30): [True: 22, False: 1]
  ------------------
 1763|      8|  for (char32_t c = 0x1132A; c <= 0x11330; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1763:30): [True: 7, False: 1]
  ------------------
 1764|      3|  for (char32_t c = 0x11332; c <= 0x11333; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1764:30): [True: 2, False: 1]
  ------------------
 1765|      6|  for (char32_t c = 0x11335; c <= 0x11339; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1765:30): [True: 5, False: 1]
  ------------------
 1766|      1|  (*smap)[0x1133C] = U_Grantha;
 1767|      1|  (*smap)[0x1133D] = U_Grantha;
 1768|      3|  for (char32_t c = 0x1133E; c <= 0x1133F; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1768:30): [True: 2, False: 1]
  ------------------
 1769|      1|  (*smap)[0x11340] = U_Grantha;
 1770|      5|  for (char32_t c = 0x11341; c <= 0x11344; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1770:30): [True: 4, False: 1]
  ------------------
 1771|      3|  for (char32_t c = 0x11347; c <= 0x11348; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1771:30): [True: 2, False: 1]
  ------------------
 1772|      4|  for (char32_t c = 0x1134B; c <= 0x1134D; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1772:30): [True: 3, False: 1]
  ------------------
 1773|      1|  (*smap)[0x11350] = U_Grantha;
 1774|      1|  (*smap)[0x11357] = U_Grantha;
 1775|      6|  for (char32_t c = 0x1135D; c <= 0x11361; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1775:30): [True: 5, False: 1]
  ------------------
 1776|      3|  for (char32_t c = 0x11362; c <= 0x11363; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1776:30): [True: 2, False: 1]
  ------------------
 1777|      8|  for (char32_t c = 0x11366; c <= 0x1136C; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1777:30): [True: 7, False: 1]
  ------------------
 1778|      6|  for (char32_t c = 0x11370; c <= 0x11374; ++c) (*smap)[c] = U_Grantha;
  ------------------
  |  Branch (1778:30): [True: 5, False: 1]
  ------------------
 1779|     49|  for (char32_t c = 0x16B00; c <= 0x16B2F; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1779:30): [True: 48, False: 1]
  ------------------
 1780|      8|  for (char32_t c = 0x16B30; c <= 0x16B36; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1780:30): [True: 7, False: 1]
  ------------------
 1781|      6|  for (char32_t c = 0x16B37; c <= 0x16B3B; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1781:30): [True: 5, False: 1]
  ------------------
 1782|      5|  for (char32_t c = 0x16B3C; c <= 0x16B3F; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1782:30): [True: 4, False: 1]
  ------------------
 1783|      5|  for (char32_t c = 0x16B40; c <= 0x16B43; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1783:30): [True: 4, False: 1]
  ------------------
 1784|      1|  (*smap)[0x16B44] = U_Pahawh_Hmong;
 1785|      1|  (*smap)[0x16B45] = U_Pahawh_Hmong;
 1786|     11|  for (char32_t c = 0x16B50; c <= 0x16B59; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1786:30): [True: 10, False: 1]
  ------------------
 1787|      8|  for (char32_t c = 0x16B5B; c <= 0x16B61; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1787:30): [True: 7, False: 1]
  ------------------
 1788|     22|  for (char32_t c = 0x16B63; c <= 0x16B77; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1788:30): [True: 21, False: 1]
  ------------------
 1789|     20|  for (char32_t c = 0x16B7D; c <= 0x16B8F; ++c) (*smap)[c] = U_Pahawh_Hmong;
  ------------------
  |  Branch (1789:30): [True: 19, False: 1]
  ------------------
 1790|     19|  for (char32_t c = 0x11200; c <= 0x11211; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1790:30): [True: 18, False: 1]
  ------------------
 1791|     26|  for (char32_t c = 0x11213; c <= 0x1122B; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1791:30): [True: 25, False: 1]
  ------------------
 1792|      4|  for (char32_t c = 0x1122C; c <= 0x1122E; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1792:30): [True: 3, False: 1]
  ------------------
 1793|      4|  for (char32_t c = 0x1122F; c <= 0x11231; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1793:30): [True: 3, False: 1]
  ------------------
 1794|      3|  for (char32_t c = 0x11232; c <= 0x11233; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1794:30): [True: 2, False: 1]
  ------------------
 1795|      1|  (*smap)[0x11234] = U_Khojki;
 1796|      1|  (*smap)[0x11235] = U_Khojki;
 1797|      3|  for (char32_t c = 0x11236; c <= 0x11237; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1797:30): [True: 2, False: 1]
  ------------------
 1798|      7|  for (char32_t c = 0x11238; c <= 0x1123D; ++c) (*smap)[c] = U_Khojki;
  ------------------
  |  Branch (1798:30): [True: 6, False: 1]
  ------------------
 1799|      1|  (*smap)[0x1123E] = U_Khojki;
 1800|    312|  for (char32_t c = 0x10600; c <= 0x10736; ++c) (*smap)[c] = U_Linear_A;
  ------------------
  |  Branch (1800:30): [True: 311, False: 1]
  ------------------
 1801|     23|  for (char32_t c = 0x10740; c <= 0x10755; ++c) (*smap)[c] = U_Linear_A;
  ------------------
  |  Branch (1801:30): [True: 22, False: 1]
  ------------------
 1802|      9|  for (char32_t c = 0x10760; c <= 0x10767; ++c) (*smap)[c] = U_Linear_A;
  ------------------
  |  Branch (1802:30): [True: 8, False: 1]
  ------------------
 1803|     36|  for (char32_t c = 0x11150; c <= 0x11172; ++c) (*smap)[c] = U_Mahajani;
  ------------------
  |  Branch (1803:30): [True: 35, False: 1]
  ------------------
 1804|      1|  (*smap)[0x11173] = U_Mahajani;
 1805|      3|  for (char32_t c = 0x11174; c <= 0x11175; ++c) (*smap)[c] = U_Mahajani;
  ------------------
  |  Branch (1805:30): [True: 2, False: 1]
  ------------------
 1806|      1|  (*smap)[0x11176] = U_Mahajani;
 1807|      9|  for (char32_t c = 0x10AC0; c <= 0x10AC7; ++c) (*smap)[c] = U_Manichaean;
  ------------------
  |  Branch (1807:30): [True: 8, False: 1]
  ------------------
 1808|      1|  (*smap)[0x10AC8] = U_Manichaean;
 1809|     29|  for (char32_t c = 0x10AC9; c <= 0x10AE4; ++c) (*smap)[c] = U_Manichaean;
  ------------------
  |  Branch (1809:30): [True: 28, False: 1]
  ------------------
 1810|      3|  for (char32_t c = 0x10AE5; c <= 0x10AE6; ++c) (*smap)[c] = U_Manichaean;
  ------------------
  |  Branch (1810:30): [True: 2, False: 1]
  ------------------
 1811|      6|  for (char32_t c = 0x10AEB; c <= 0x10AEF; ++c) (*smap)[c] = U_Manichaean;
  ------------------
  |  Branch (1811:30): [True: 5, False: 1]
  ------------------
 1812|      8|  for (char32_t c = 0x10AF0; c <= 0x10AF6; ++c) (*smap)[c] = U_Manichaean;
  ------------------
  |  Branch (1812:30): [True: 7, False: 1]
  ------------------
 1813|    198|  for (char32_t c = 0x1E800; c <= 0x1E8C4; ++c) (*smap)[c] = U_Mende_Kikakui;
  ------------------
  |  Branch (1813:30): [True: 197, False: 1]
  ------------------
 1814|     10|  for (char32_t c = 0x1E8C7; c <= 0x1E8CF; ++c) (*smap)[c] = U_Mende_Kikakui;
  ------------------
  |  Branch (1814:30): [True: 9, False: 1]
  ------------------
 1815|      8|  for (char32_t c = 0x1E8D0; c <= 0x1E8D6; ++c) (*smap)[c] = U_Mende_Kikakui;
  ------------------
  |  Branch (1815:30): [True: 7, False: 1]
  ------------------
 1816|     49|  for (char32_t c = 0x11600; c <= 0x1162F; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1816:30): [True: 48, False: 1]
  ------------------
 1817|      4|  for (char32_t c = 0x11630; c <= 0x11632; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1817:30): [True: 3, False: 1]
  ------------------
 1818|      9|  for (char32_t c = 0x11633; c <= 0x1163A; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1818:30): [True: 8, False: 1]
  ------------------
 1819|      3|  for (char32_t c = 0x1163B; c <= 0x1163C; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1819:30): [True: 2, False: 1]
  ------------------
 1820|      1|  (*smap)[0x1163D] = U_Modi;
 1821|      1|  (*smap)[0x1163E] = U_Modi;
 1822|      3|  for (char32_t c = 0x1163F; c <= 0x11640; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1822:30): [True: 2, False: 1]
  ------------------
 1823|      4|  for (char32_t c = 0x11641; c <= 0x11643; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1823:30): [True: 3, False: 1]
  ------------------
 1824|      1|  (*smap)[0x11644] = U_Modi;
 1825|     11|  for (char32_t c = 0x11650; c <= 0x11659; ++c) (*smap)[c] = U_Modi;
  ------------------
  |  Branch (1825:30): [True: 10, False: 1]
  ------------------
 1826|     32|  for (char32_t c = 0x16A40; c <= 0x16A5E; ++c) (*smap)[c] = U_Mro;
  ------------------
  |  Branch (1826:30): [True: 31, False: 1]
  ------------------
 1827|     11|  for (char32_t c = 0x16A60; c <= 0x16A69; ++c) (*smap)[c] = U_Mro;
  ------------------
  |  Branch (1827:30): [True: 10, False: 1]
  ------------------
 1828|      3|  for (char32_t c = 0x16A6E; c <= 0x16A6F; ++c) (*smap)[c] = U_Mro;
  ------------------
  |  Branch (1828:30): [True: 2, False: 1]
  ------------------
 1829|     30|  for (char32_t c = 0x10A80; c <= 0x10A9C; ++c) (*smap)[c] = U_Old_North_Arabian;
  ------------------
  |  Branch (1829:30): [True: 29, False: 1]
  ------------------
 1830|      4|  for (char32_t c = 0x10A9D; c <= 0x10A9F; ++c) (*smap)[c] = U_Old_North_Arabian;
  ------------------
  |  Branch (1830:30): [True: 3, False: 1]
  ------------------
 1831|     32|  for (char32_t c = 0x10880; c <= 0x1089E; ++c) (*smap)[c] = U_Nabataean;
  ------------------
  |  Branch (1831:30): [True: 31, False: 1]
  ------------------
 1832|     10|  for (char32_t c = 0x108A7; c <= 0x108AF; ++c) (*smap)[c] = U_Nabataean;
  ------------------
  |  Branch (1832:30): [True: 9, False: 1]
  ------------------
 1833|     24|  for (char32_t c = 0x10860; c <= 0x10876; ++c) (*smap)[c] = U_Palmyrene;
  ------------------
  |  Branch (1833:30): [True: 23, False: 1]
  ------------------
 1834|      3|  for (char32_t c = 0x10877; c <= 0x10878; ++c) (*smap)[c] = U_Palmyrene;
  ------------------
  |  Branch (1834:30): [True: 2, False: 1]
  ------------------
 1835|      8|  for (char32_t c = 0x10879; c <= 0x1087F; ++c) (*smap)[c] = U_Palmyrene;
  ------------------
  |  Branch (1835:30): [True: 7, False: 1]
  ------------------
 1836|     58|  for (char32_t c = 0x11AC0; c <= 0x11AF8; ++c) (*smap)[c] = U_Pau_Cin_Hau;
  ------------------
  |  Branch (1836:30): [True: 57, False: 1]
  ------------------
 1837|     39|  for (char32_t c = 0x10350; c <= 0x10375; ++c) (*smap)[c] = U_Old_Permic;
  ------------------
  |  Branch (1837:30): [True: 38, False: 1]
  ------------------
 1838|      6|  for (char32_t c = 0x10376; c <= 0x1037A; ++c) (*smap)[c] = U_Old_Permic;
  ------------------
  |  Branch (1838:30): [True: 5, False: 1]
  ------------------
 1839|     19|  for (char32_t c = 0x10B80; c <= 0x10B91; ++c) (*smap)[c] = U_Psalter_Pahlavi;
  ------------------
  |  Branch (1839:30): [True: 18, False: 1]
  ------------------
 1840|      5|  for (char32_t c = 0x10B99; c <= 0x10B9C; ++c) (*smap)[c] = U_Psalter_Pahlavi;
  ------------------
  |  Branch (1840:30): [True: 4, False: 1]
  ------------------
 1841|      8|  for (char32_t c = 0x10BA9; c <= 0x10BAF; ++c) (*smap)[c] = U_Psalter_Pahlavi;
  ------------------
  |  Branch (1841:30): [True: 7, False: 1]
  ------------------
 1842|     48|  for (char32_t c = 0x11580; c <= 0x115AE; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1842:30): [True: 47, False: 1]
  ------------------
 1843|      4|  for (char32_t c = 0x115AF; c <= 0x115B1; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1843:30): [True: 3, False: 1]
  ------------------
 1844|      5|  for (char32_t c = 0x115B2; c <= 0x115B5; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1844:30): [True: 4, False: 1]
  ------------------
 1845|      5|  for (char32_t c = 0x115B8; c <= 0x115BB; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1845:30): [True: 4, False: 1]
  ------------------
 1846|      3|  for (char32_t c = 0x115BC; c <= 0x115BD; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1846:30): [True: 2, False: 1]
  ------------------
 1847|      1|  (*smap)[0x115BE] = U_Siddham;
 1848|      3|  for (char32_t c = 0x115BF; c <= 0x115C0; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1848:30): [True: 2, False: 1]
  ------------------
 1849|     24|  for (char32_t c = 0x115C1; c <= 0x115D7; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1849:30): [True: 23, False: 1]
  ------------------
 1850|      5|  for (char32_t c = 0x115D8; c <= 0x115DB; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1850:30): [True: 4, False: 1]
  ------------------
 1851|      3|  for (char32_t c = 0x115DC; c <= 0x115DD; ++c) (*smap)[c] = U_Siddham;
  ------------------
  |  Branch (1851:30): [True: 2, False: 1]
  ------------------
 1852|     48|  for (char32_t c = 0x112B0; c <= 0x112DE; ++c) (*smap)[c] = U_Khudawadi;
  ------------------
  |  Branch (1852:30): [True: 47, False: 1]
  ------------------
 1853|      1|  (*smap)[0x112DF] = U_Khudawadi;
 1854|      4|  for (char32_t c = 0x112E0; c <= 0x112E2; ++c) (*smap)[c] = U_Khudawadi;
  ------------------
  |  Branch (1854:30): [True: 3, False: 1]
  ------------------
 1855|      9|  for (char32_t c = 0x112E3; c <= 0x112EA; ++c) (*smap)[c] = U_Khudawadi;
  ------------------
  |  Branch (1855:30): [True: 8, False: 1]
  ------------------
 1856|     11|  for (char32_t c = 0x112F0; c <= 0x112F9; ++c) (*smap)[c] = U_Khudawadi;
  ------------------
  |  Branch (1856:30): [True: 10, False: 1]
  ------------------
 1857|     49|  for (char32_t c = 0x11480; c <= 0x114AF; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1857:30): [True: 48, False: 1]
  ------------------
 1858|      4|  for (char32_t c = 0x114B0; c <= 0x114B2; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1858:30): [True: 3, False: 1]
  ------------------
 1859|      7|  for (char32_t c = 0x114B3; c <= 0x114B8; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1859:30): [True: 6, False: 1]
  ------------------
 1860|      1|  (*smap)[0x114B9] = U_Tirhuta;
 1861|      1|  (*smap)[0x114BA] = U_Tirhuta;
 1862|      5|  for (char32_t c = 0x114BB; c <= 0x114BE; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1862:30): [True: 4, False: 1]
  ------------------
 1863|      3|  for (char32_t c = 0x114BF; c <= 0x114C0; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1863:30): [True: 2, False: 1]
  ------------------
 1864|      1|  (*smap)[0x114C1] = U_Tirhuta;
 1865|      3|  for (char32_t c = 0x114C2; c <= 0x114C3; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1865:30): [True: 2, False: 1]
  ------------------
 1866|      3|  for (char32_t c = 0x114C4; c <= 0x114C5; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1866:30): [True: 2, False: 1]
  ------------------
 1867|      1|  (*smap)[0x114C6] = U_Tirhuta;
 1868|      1|  (*smap)[0x114C7] = U_Tirhuta;
 1869|     11|  for (char32_t c = 0x114D0; c <= 0x114D9; ++c) (*smap)[c] = U_Tirhuta;
  ------------------
  |  Branch (1869:30): [True: 10, False: 1]
  ------------------
 1870|     65|  for (char32_t c = 0x118A0; c <= 0x118DF; ++c) (*smap)[c] = U_Warang_Citi;
  ------------------
  |  Branch (1870:30): [True: 64, False: 1]
  ------------------
 1871|     11|  for (char32_t c = 0x118E0; c <= 0x118E9; ++c) (*smap)[c] = U_Warang_Citi;
  ------------------
  |  Branch (1871:30): [True: 10, False: 1]
  ------------------
 1872|     10|  for (char32_t c = 0x118EA; c <= 0x118F2; ++c) (*smap)[c] = U_Warang_Citi;
  ------------------
  |  Branch (1872:30): [True: 9, False: 1]
  ------------------
 1873|      1|  (*smap)[0x118FF] = U_Warang_Citi;
 1874|     27|  for (char32_t c = 0x11700; c <= 0x11719; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1874:30): [True: 26, False: 1]
  ------------------
 1875|      4|  for (char32_t c = 0x1171D; c <= 0x1171F; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1875:30): [True: 3, False: 1]
  ------------------
 1876|      3|  for (char32_t c = 0x11720; c <= 0x11721; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1876:30): [True: 2, False: 1]
  ------------------
 1877|      5|  for (char32_t c = 0x11722; c <= 0x11725; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1877:30): [True: 4, False: 1]
  ------------------
 1878|      1|  (*smap)[0x11726] = U_Ahom;
 1879|      6|  for (char32_t c = 0x11727; c <= 0x1172B; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1879:30): [True: 5, False: 1]
  ------------------
 1880|     11|  for (char32_t c = 0x11730; c <= 0x11739; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1880:30): [True: 10, False: 1]
  ------------------
 1881|      3|  for (char32_t c = 0x1173A; c <= 0x1173B; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1881:30): [True: 2, False: 1]
  ------------------
 1882|      4|  for (char32_t c = 0x1173C; c <= 0x1173E; ++c) (*smap)[c] = U_Ahom;
  ------------------
  |  Branch (1882:30): [True: 3, False: 1]
  ------------------
 1883|      1|  (*smap)[0x1173F] = U_Ahom;
 1884|    584|  for (char32_t c = 0x14400; c <= 0x14646; ++c)
  ------------------
  |  Branch (1884:30): [True: 583, False: 1]
  ------------------
 1885|    583|    (*smap)[c] = U_Anatolian_Hieroglyphs;
 1886|     20|  for (char32_t c = 0x108E0; c <= 0x108F2; ++c) (*smap)[c] = U_Hatran;
  ------------------
  |  Branch (1886:30): [True: 19, False: 1]
  ------------------
 1887|      3|  for (char32_t c = 0x108F4; c <= 0x108F5; ++c) (*smap)[c] = U_Hatran;
  ------------------
  |  Branch (1887:30): [True: 2, False: 1]
  ------------------
 1888|      6|  for (char32_t c = 0x108FB; c <= 0x108FF; ++c) (*smap)[c] = U_Hatran;
  ------------------
  |  Branch (1888:30): [True: 5, False: 1]
  ------------------
 1889|      8|  for (char32_t c = 0x11280; c <= 0x11286; ++c) (*smap)[c] = U_Multani;
  ------------------
  |  Branch (1889:30): [True: 7, False: 1]
  ------------------
 1890|      1|  (*smap)[0x11288] = U_Multani;
 1891|      5|  for (char32_t c = 0x1128A; c <= 0x1128D; ++c) (*smap)[c] = U_Multani;
  ------------------
  |  Branch (1891:30): [True: 4, False: 1]
  ------------------
 1892|     16|  for (char32_t c = 0x1128F; c <= 0x1129D; ++c) (*smap)[c] = U_Multani;
  ------------------
  |  Branch (1892:30): [True: 15, False: 1]
  ------------------
 1893|     11|  for (char32_t c = 0x1129F; c <= 0x112A8; ++c) (*smap)[c] = U_Multani;
  ------------------
  |  Branch (1893:30): [True: 10, False: 1]
  ------------------
 1894|      1|  (*smap)[0x112A9] = U_Multani;
 1895|     52|  for (char32_t c = 0x10C80; c <= 0x10CB2; ++c) (*smap)[c] = U_Old_Hungarian;
  ------------------
  |  Branch (1895:30): [True: 51, False: 1]
  ------------------
 1896|     52|  for (char32_t c = 0x10CC0; c <= 0x10CF2; ++c) (*smap)[c] = U_Old_Hungarian;
  ------------------
  |  Branch (1896:30): [True: 51, False: 1]
  ------------------
 1897|      7|  for (char32_t c = 0x10CFA; c <= 0x10CFF; ++c) (*smap)[c] = U_Old_Hungarian;
  ------------------
  |  Branch (1897:30): [True: 6, False: 1]
  ------------------
 1898|    513|  for (char32_t c = 0x1D800; c <= 0x1D9FF; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1898:30): [True: 512, False: 1]
  ------------------
 1899|     56|  for (char32_t c = 0x1DA00; c <= 0x1DA36; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1899:30): [True: 55, False: 1]
  ------------------
 1900|      5|  for (char32_t c = 0x1DA37; c <= 0x1DA3A; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1900:30): [True: 4, False: 1]
  ------------------
 1901|     51|  for (char32_t c = 0x1DA3B; c <= 0x1DA6C; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1901:30): [True: 50, False: 1]
  ------------------
 1902|      9|  for (char32_t c = 0x1DA6D; c <= 0x1DA74; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1902:30): [True: 8, False: 1]
  ------------------
 1903|      1|  (*smap)[0x1DA75] = U_SignWriting;
 1904|     15|  for (char32_t c = 0x1DA76; c <= 0x1DA83; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1904:30): [True: 14, False: 1]
  ------------------
 1905|      1|  (*smap)[0x1DA84] = U_SignWriting;
 1906|      3|  for (char32_t c = 0x1DA85; c <= 0x1DA86; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1906:30): [True: 2, False: 1]
  ------------------
 1907|      6|  for (char32_t c = 0x1DA87; c <= 0x1DA8B; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1907:30): [True: 5, False: 1]
  ------------------
 1908|      6|  for (char32_t c = 0x1DA9B; c <= 0x1DA9F; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1908:30): [True: 5, False: 1]
  ------------------
 1909|     16|  for (char32_t c = 0x1DAA1; c <= 0x1DAAF; ++c) (*smap)[c] = U_SignWriting;
  ------------------
  |  Branch (1909:30): [True: 15, False: 1]
  ------------------
 1910|     69|  for (char32_t c = 0x1E900; c <= 0x1E943; ++c) (*smap)[c] = U_Adlam;
  ------------------
  |  Branch (1910:30): [True: 68, False: 1]
  ------------------
 1911|      8|  for (char32_t c = 0x1E944; c <= 0x1E94A; ++c) (*smap)[c] = U_Adlam;
  ------------------
  |  Branch (1911:30): [True: 7, False: 1]
  ------------------
 1912|     11|  for (char32_t c = 0x1E950; c <= 0x1E959; ++c) (*smap)[c] = U_Adlam;
  ------------------
  |  Branch (1912:30): [True: 10, False: 1]
  ------------------
 1913|      3|  for (char32_t c = 0x1E95E; c <= 0x1E95F; ++c) (*smap)[c] = U_Adlam;
  ------------------
  |  Branch (1913:30): [True: 2, False: 1]
  ------------------
 1914|     10|  for (char32_t c = 0x11C00; c <= 0x11C08; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1914:30): [True: 9, False: 1]
  ------------------
 1915|     38|  for (char32_t c = 0x11C0A; c <= 0x11C2E; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1915:30): [True: 37, False: 1]
  ------------------
 1916|      1|  (*smap)[0x11C2F] = U_Bhaiksuki;
 1917|      8|  for (char32_t c = 0x11C30; c <= 0x11C36; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1917:30): [True: 7, False: 1]
  ------------------
 1918|      7|  for (char32_t c = 0x11C38; c <= 0x11C3D; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1918:30): [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_t c = 0x11C41; c <= 0x11C45; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1922:30): [True: 5, False: 1]
  ------------------
 1923|     11|  for (char32_t c = 0x11C50; c <= 0x11C59; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1923:30): [True: 10, False: 1]
  ------------------
 1924|     20|  for (char32_t c = 0x11C5A; c <= 0x11C6C; ++c) (*smap)[c] = U_Bhaiksuki;
  ------------------
  |  Branch (1924:30): [True: 19, False: 1]
  ------------------
 1925|      3|  for (char32_t c = 0x11C70; c <= 0x11C71; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1925:30): [True: 2, False: 1]
  ------------------
 1926|     31|  for (char32_t c = 0x11C72; c <= 0x11C8F; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1926:30): [True: 30, False: 1]
  ------------------
 1927|     23|  for (char32_t c = 0x11C92; c <= 0x11CA7; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1927:30): [True: 22, False: 1]
  ------------------
 1928|      1|  (*smap)[0x11CA9] = U_Marchen;
 1929|      8|  for (char32_t c = 0x11CAA; c <= 0x11CB0; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1929:30): [True: 7, False: 1]
  ------------------
 1930|      1|  (*smap)[0x11CB1] = U_Marchen;
 1931|      3|  for (char32_t c = 0x11CB2; c <= 0x11CB3; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1931:30): [True: 2, False: 1]
  ------------------
 1932|      1|  (*smap)[0x11CB4] = U_Marchen;
 1933|      3|  for (char32_t c = 0x11CB5; c <= 0x11CB6; ++c) (*smap)[c] = U_Marchen;
  ------------------
  |  Branch (1933:30): [True: 2, False: 1]
  ------------------
 1934|     54|  for (char32_t c = 0x11400; c <= 0x11434; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1934:30): [True: 53, False: 1]
  ------------------
 1935|      4|  for (char32_t c = 0x11435; c <= 0x11437; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1935:30): [True: 3, False: 1]
  ------------------
 1936|      9|  for (char32_t c = 0x11438; c <= 0x1143F; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1936:30): [True: 8, False: 1]
  ------------------
 1937|      3|  for (char32_t c = 0x11440; c <= 0x11441; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1937:30): [True: 2, False: 1]
  ------------------
 1938|      4|  for (char32_t c = 0x11442; c <= 0x11444; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1938:30): [True: 3, False: 1]
  ------------------
 1939|      1|  (*smap)[0x11445] = U_Newa;
 1940|      1|  (*smap)[0x11446] = U_Newa;
 1941|      5|  for (char32_t c = 0x11447; c <= 0x1144A; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1941:30): [True: 4, False: 1]
  ------------------
 1942|      6|  for (char32_t c = 0x1144B; c <= 0x1144F; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1942:30): [True: 5, False: 1]
  ------------------
 1943|     11|  for (char32_t c = 0x11450; c <= 0x11459; ++c) (*smap)[c] = U_Newa;
  ------------------
  |  Branch (1943:30): [True: 10, False: 1]
  ------------------
 1944|      1|  (*smap)[0x1145B] = U_Newa;
 1945|      1|  (*smap)[0x1145D] = U_Newa;
 1946|     37|  for (char32_t c = 0x104B0; c <= 0x104D3; ++c) (*smap)[c] = U_Osage;
  ------------------
  |  Branch (1946:30): [True: 36, False: 1]
  ------------------
 1947|     37|  for (char32_t c = 0x104D8; c <= 0x104FB; ++c) (*smap)[c] = U_Osage;
  ------------------
  |  Branch (1947:30): [True: 36, False: 1]
  ------------------
 1948|      1|  (*smap)[0x16FE0] = U_Tangut;
 1949|  6.12k|  for (char32_t c = 0x17000; c <= 0x187EC; ++c) (*smap)[c] = U_Tangut;
  ------------------
  |  Branch (1949:30): [True: 6.12k, False: 1]
  ------------------
 1950|    756|  for (char32_t c = 0x18800; c <= 0x18AF2; ++c) (*smap)[c] = U_Tangut;
  ------------------
  |  Branch (1950:30): [True: 755, False: 1]
  ------------------
 1951|      1|}

_ZN13sentencepiece7unigram7LatticeC2Ev:
   92|  51.1k|Lattice::Lattice() : node_allocator_(kPreallocateLatticeNodeSize) {}
_ZN13sentencepiece7unigram7LatticeD2Ev:
   93|  51.1k|Lattice::~Lattice() {}
_ZNK13sentencepiece7unigram7Lattice11begin_nodesEi:
   95|  4.57M|const std::vector<Lattice::Node *> &Lattice::begin_nodes(int pos) const {
   96|  4.57M|  return begin_nodes_[pos];
   97|  4.57M|}
_ZNK13sentencepiece7unigram7Lattice9end_nodesEi:
   99|  42.8M|const std::vector<Lattice::Node *> &Lattice::end_nodes(int pos) const {
  100|  42.8M|  return end_nodes_[pos];
  101|  42.8M|}
_ZNK13sentencepiece7unigram7Lattice4sizeEv:
  103|  21.4M|int Lattice::size() const {
  104|       |  // -1 because surface_ may include the EOS.
  105|  21.4M|  return std::max<int>(0, surface_.size() - 1);
  106|  21.4M|}
_ZNK13sentencepiece7unigram7Lattice9utf8_sizeEv:
  108|  4.57M|int Lattice::utf8_size() const { return sentence_.size(); }
_ZNK13sentencepiece7unigram7Lattice8sentenceEv:
  110|  4.57M|const char *Lattice::sentence() const { return sentence_.data(); }
_ZNK13sentencepiece7unigram7Lattice7surfaceEi:
  112|  1.75G|const char *Lattice::surface(int pos) const { return surface_[pos]; }
_ZNK13sentencepiece7unigram7Lattice8bos_nodeEv:
  114|  11.9M|Lattice::Node *Lattice::bos_node() const { return end_nodes_[0][0]; }
_ZNK13sentencepiece7unigram7Lattice8eos_nodeEv:
  116|  1.77M|Lattice::Node *Lattice::eos_node() const { return begin_nodes_[size()][0]; }
_ZN13sentencepiece7unigram7Lattice7NewNodeEv:
  118|   230M|Lattice::Node *Lattice::NewNode() {
  119|   230M|  Node *node = node_allocator_.Allocate();
  120|   230M|  node->node_id = node_allocator_.size() - 1;
  121|   230M|  return node;
  122|   230M|}
_ZN13sentencepiece7unigram7Lattice5ClearEv:
  124|  4.57M|void Lattice::Clear() {
  125|  4.57M|  begin_nodes_.clear();
  126|  4.57M|  end_nodes_.clear();
  127|  4.57M|  sentence_ = absl::string_view("");
  128|  4.57M|  surface_.clear();
  129|  4.57M|  node_allocator_.Free();
  130|  4.57M|}
_ZN13sentencepiece7unigram7Lattice11SetSentenceENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  132|  4.57M|void Lattice::SetSentence(absl::string_view sentence) {
  133|  4.57M|  Clear();
  134|       |
  135|  4.57M|  sentence_ = sentence;
  136|  4.57M|  surface_.reserve(sentence.size() + 1);
  137|       |
  138|   114M|  while (!sentence.empty()) {
  ------------------
  |  Branch (138:10): [True: 110M, False: 4.57M]
  ------------------
  139|   110M|    const int mblen = std::min<int>(string_util::OneCharLen(sentence.data()),
  140|   110M|                                    sentence.size());
  141|   110M|    surface_.push_back(sentence.data());
  142|   110M|    sentence.remove_prefix(mblen);
  143|   110M|  }
  144|  4.57M|  surface_.push_back(sentence.data());
  145|       |
  146|  4.57M|  const size_t len = size();
  147|  4.57M|  begin_nodes_.resize(len + 1);
  148|  4.57M|  end_nodes_.resize(len + 1);
  149|       |
  150|  4.57M|  constexpr size_t kReservedNodeSize = 16;
  151|   119M|  for (size_t i = 0; i <= len; ++i) {
  ------------------
  |  Branch (151:22): [True: 114M, False: 4.57M]
  ------------------
  152|   114M|    begin_nodes_[i].reserve(kReservedNodeSize);
  153|   114M|    end_nodes_[i].reserve(kReservedNodeSize);
  154|   114M|  }
  155|       |
  156|  4.57M|  Node *bos = NewNode();
  157|  4.57M|  bos->id = -1;
  158|  4.57M|  bos->pos = 0;
  159|  4.57M|  end_nodes_[0].push_back(bos);
  160|       |
  161|  4.57M|  Node *eos = NewNode();
  162|  4.57M|  eos->id = -1;
  163|  4.57M|  eos->pos = len;
  164|  4.57M|  begin_nodes_[len].push_back(eos);
  165|  4.57M|}
_ZN13sentencepiece7unigram7Lattice6InsertEii:
  167|   221M|Lattice::Node *Lattice::Insert(int pos, int length) {
  168|   221M|  Node *node = NewNode();
  169|   221M|  node->pos = pos;
  170|   221M|  node->length = length;
  171|   221M|  const int utf8_length =
  172|   221M|      static_cast<int>(surface(pos + length) - surface(pos));
  173|   221M|  node->piece = absl::string_view(surface(pos), utf8_length);
  174|   221M|  begin_nodes_[pos].push_back(node);
  175|   221M|  end_nodes_[pos + node->length].push_back(node);
  176|       |
  177|   221M|  return node;
  178|   221M|}
_ZN13sentencepiece7unigram7Lattice7ViterbiEv:
  180|  4.57M|Lattice::LatticePathWithScore Lattice::Viterbi() {
  181|  4.57M|  const size_t len = size();
  182|       |
  183|   119M|  for (size_t pos = 0; pos <= len; ++pos) {
  ------------------
  |  Branch (183:24): [True: 114M, False: 4.57M]
  ------------------
  184|   225M|    for (Node *rnode : begin_nodes_[pos]) {
  ------------------
  |  Branch (184:22): [True: 225M, False: 114M]
  ------------------
  185|   225M|      rnode->prev = nullptr;
  186|   225M|      float best_score = 0.0;
  187|   225M|      Node *best_node = nullptr;
  188|   818M|      for (Node *lnode : end_nodes_[pos]) {
  ------------------
  |  Branch (188:24): [True: 818M, False: 225M]
  ------------------
  189|   818M|        const float score = lnode->backtrace_score + rnode->score;
  190|   818M|        if (best_node == nullptr || score > best_score) {
  ------------------
  |  Branch (190:13): [True: 225M, False: 593M]
  |  Branch (190:37): [True: 66.9M, False: 526M]
  ------------------
  191|   292M|          best_node = lnode;
  192|   292M|          best_score = score;
  193|   292M|        }
  194|   818M|      }
  195|   225M|      if (best_node == nullptr) {
  ------------------
  |  Branch (195:11): [True: 0, False: 225M]
  ------------------
  196|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  197|      0|        return {};
  198|      0|      }
  199|   225M|      rnode->prev = best_node;
  200|   225M|      rnode->backtrace_score = best_score;
  201|   225M|    }
  202|   114M|  }
  203|       |
  204|       |  // backtrace
  205|  4.57M|  std::vector<Node *> results;
  206|  4.57M|  float score = begin_nodes(len)[0]->backtrace_score;
  207|  59.1M|  for (Node *node = begin_nodes_[len][0]->prev; node->prev != nullptr;
  ------------------
  |  Branch (207:49): [True: 54.6M, False: 4.57M]
  ------------------
  208|  54.6M|       node = node->prev) {
  209|  54.6M|    results.push_back(node);
  210|  54.6M|  }
  211|       |
  212|  4.57M|  std::reverse(results.begin(), results.end());
  213|       |
  214|  4.57M|  LatticePathWithScore retval = {results, score};
  215|       |
  216|  4.57M|  return retval;
  217|  4.57M|}
_ZNK13sentencepiece7unigram7Lattice16ForwardAlgorithmEf:
  219|  1.97M|std::vector<float> Lattice::ForwardAlgorithm(float inv_theta) const {
  220|  1.97M|  const size_t len = size();
  221|  1.97M|  std::vector<float> alpha(node_allocator_.size(), 0.0);
  222|       |
  223|  75.9M|  for (size_t pos = 0; pos <= len; ++pos) {
  ------------------
  |  Branch (223:24): [True: 73.9M, False: 1.97M]
  ------------------
  224|   149M|    for (Node *rnode : begin_nodes_[pos]) {
  ------------------
  |  Branch (224:22): [True: 149M, False: 73.9M]
  ------------------
  225|   580M|      for (Node *lnode : end_nodes_[pos]) {
  ------------------
  |  Branch (225:24): [True: 580M, False: 149M]
  ------------------
  226|   580M|        alpha[rnode->node_id] =
  227|   580M|            LogSumExp(alpha[rnode->node_id],
  228|   580M|                      inv_theta * lnode->score + alpha[lnode->node_id],
  229|   580M|                      lnode == end_nodes_[pos][0]);
  230|   580M|      }
  231|   149M|    }
  232|  73.9M|  }
  233|       |
  234|  1.97M|  return alpha;
  235|  1.97M|}
_ZNK13sentencepiece7unigram7Lattice17BackwardAlgorithmEf:
  237|  1.97M|std::vector<float> Lattice::BackwardAlgorithm(float inv_theta) const {
  238|  1.97M|  const size_t len = size();
  239|  1.97M|  std::vector<float> beta(node_allocator_.size(), 0.0);
  240|       |
  241|  75.9M|  for (int pos = len; pos >= 0; --pos) {
  ------------------
  |  Branch (241:23): [True: 73.9M, False: 1.97M]
  ------------------
  242|   149M|    for (Node *lnode : end_nodes_[pos]) {
  ------------------
  |  Branch (242:22): [True: 149M, False: 73.9M]
  ------------------
  243|   580M|      for (Node *rnode : begin_nodes_[pos]) {
  ------------------
  |  Branch (243:24): [True: 580M, False: 149M]
  ------------------
  244|   580M|        beta[lnode->node_id] =
  245|   580M|            LogSumExp(beta[lnode->node_id], rnode->score + beta[rnode->node_id],
  246|   580M|                      rnode == begin_nodes_[pos][0]);
  247|   580M|      }
  248|   149M|    }
  249|  73.9M|  }
  250|       |
  251|  1.97M|  return beta;
  252|  1.97M|}
_ZNK13sentencepiece7unigram7Lattice16PopulateMarginalEfPNSt3__16vectorIfNS2_9allocatorIfEEEE:
  255|  1.97M|                                std::vector<float> *expected) const {
  256|  1.97M|  if (expected == nullptr) return 0.0;
  ------------------
  |  Branch (256:7): [True: 0, False: 1.97M]
  ------------------
  257|       |
  258|  1.97M|  const size_t len = size();
  259|       |
  260|       |  // alpha and beta (accumulative log prob) in Forward Backward.
  261|       |  // the index of alpha/beta is Node::node_id.
  262|       |
  263|  1.97M|  const auto alpha = ForwardAlgorithm(1.0);
  264|  1.97M|  const auto beta = BackwardAlgorithm(1.0);
  265|       |
  266|  1.97M|  const float Z = alpha[begin_nodes_[len][0]->node_id];
  267|  73.9M|  for (size_t pos = 0; pos < len; ++pos) {
  ------------------
  |  Branch (267:24): [True: 71.9M, False: 1.97M]
  ------------------
  268|   147M|    for (Node *node : begin_nodes_[pos]) {
  ------------------
  |  Branch (268:21): [True: 147M, False: 71.9M]
  ------------------
  269|   147M|      if (node->id >= 0) {
  ------------------
  |  Branch (269:11): [True: 147M, False: 0]
  ------------------
  270|       |        // the index of |expected| is a Node::id, which is a vocabulary id.
  271|   147M|        (*expected)[node->id] +=
  272|   147M|            freq *
  273|   147M|            std::exp(static_cast<double>(alpha[node->node_id] + node->score +
  274|   147M|                                         beta[node->node_id] - Z));
  275|   147M|      }
  276|   147M|    }
  277|  71.9M|  }
  278|       |
  279|  1.97M|  return freq * Z;
  280|  1.97M|}
_ZN13sentencepiece7unigram7Lattice5NBestEmbf:
  366|  1.77M|                                                          float inv_theta) {
  367|  1.77M|  if (nbest_size < 1) {
  ------------------
  |  Branch (367:7): [True: 0, False: 1.77M]
  ------------------
  368|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  369|      0|    return {};
  370|      0|  }
  371|       |
  372|  1.77M|  if (nbest_size == 1 && !sample) {
  ------------------
  |  Branch (372:7): [True: 0, False: 1.77M]
  |  Branch (372:26): [True: 0, False: 0]
  ------------------
  373|      0|    return {Viterbi()};
  374|      0|  }
  375|       |
  376|  1.77M|  const int timeout_ms = sentencepiece::GetNBestTimeout();
  377|  1.77M|  const absl::Time start_time = absl::Now();
  378|       |
  379|       |  // Uses A* search to enumerate N-bests.
  380|       |  // Given a lattice, enumerates hypotheses (paths) from EOS.
  381|       |  // At each partial path x, compute f(x) as follows
  382|       |  //   f(x) = g(x) + h(x).
  383|       |  // g(x): the sum of scores from  EOS to the left-most node in x.
  384|       |  //       for a complete hypothesis, g(hyp) is the score of the hypothesis.
  385|       |  // h(x): a heuristic that estimates the largest score from x to BOS.
  386|       |  // f(x): the priority to pop a new hypothesis from the priority queue.
  387|       |  //
  388|       |  // As left-to-right Viterbi search can tell the *exact* value of h(x),
  389|       |  // we can obtain the exact n-best results with A*.
  390|       |
  391|  1.77M|  class HypothesisComparator {
  392|  1.77M|   public:
  393|  1.77M|    const bool operator()(Hypothesis *h1, Hypothesis *h2) {
  394|  1.77M|      return (h1->fx < h2->fx);
  395|  1.77M|    }
  396|  1.77M|  };
  397|       |
  398|  1.77M|  using Agenda = std::priority_queue<Hypothesis *, std::vector<Hypothesis *>,
  399|  1.77M|                                     HypothesisComparator>;
  400|  1.77M|  constexpr size_t kPreallocatedHypothesisSize = 512;
  401|  1.77M|  model::FreeList<Hypothesis> hypothesis_allocator(kPreallocatedHypothesisSize);
  402|       |
  403|  1.77M|  Agenda agenda;
  404|  1.77M|  std::vector<Lattice::LatticePathWithScore> results;
  405|       |
  406|  1.77M|  auto *eos = hypothesis_allocator.Allocate();
  407|  1.77M|  eos->node = eos_node();
  408|  1.77M|  eos->next = nullptr;
  409|  1.77M|  eos->gx = 0.0;
  410|       |
  411|  1.77M|  std::vector<float> alpha(node_allocator_.size(), 0.0);
  412|       |
  413|  1.77M|  if (sample) {
  ------------------
  |  Branch (413:7): [True: 0, False: 1.77M]
  ------------------
  414|       |    // Run forwards algorithm to get normalising constants
  415|      0|    alpha = ForwardAlgorithm(inv_theta);
  416|       |    // f(eos) = Gumbel(0), as it is the perturbed score of the entire lattice.
  417|      0|    eos->fx = Gumbel();
  418|  1.77M|  } else {
  419|       |    // Run Viterbi first to fill backtrace score.
  420|  1.77M|    Viterbi();
  421|  1.77M|    eos->fx = eos->node->backtrace_score;
  422|  1.77M|  }
  423|  1.77M|  agenda.push(eos);
  424|       |
  425|  1.77M|  int shrink_count = 0;  // Number of times agenda has shrunk. For logging only.
  426|  1.77M|  bool printed_memory_warning = false;  // For logging only.
  427|  12.2M|  while (!agenda.empty()) {
  ------------------
  |  Branch (427:10): [True: 11.9M, False: 307k]
  ------------------
  428|  11.9M|    auto *top = agenda.top();
  429|  11.9M|    agenda.pop();
  430|  11.9M|    auto *node = top->node;
  431|       |
  432|       |    // Reaches to BOS
  433|  11.9M|    if (node == bos_node()) {
  ------------------
  |  Branch (433:9): [True: 3.24M, False: 8.72M]
  ------------------
  434|  3.24M|      results.resize(results.size() + 1);
  435|  10.0M|      for (auto *n = top->next; n->next != nullptr; n = n->next) {
  ------------------
  |  Branch (435:33): [True: 6.81M, False: 3.24M]
  ------------------
  436|  6.81M|        results.back().first.push_back(n->node);
  437|  6.81M|      }
  438|  3.24M|      results.back().second = top->fx;
  439|  3.24M|      if (results.size() == nbest_size) {
  ------------------
  |  Branch (439:11): [True: 1.46M, False: 1.77M]
  ------------------
  440|  1.46M|        break;
  441|  1.46M|      }
  442|  1.77M|      continue;
  443|  3.24M|    }
  444|       |
  445|  8.72M|    const size_t end_nodes_size = end_nodes(node->pos).size();
  446|  8.72M|    std::vector<float> probs(end_nodes_size, 0.0);
  447|  8.72M|    std::vector<float> perturbed_probs(end_nodes_size, 0.0);
  448|  8.72M|    std::vector<double> adjusted_probs(end_nodes_size, 0.0);
  449|  8.72M|    const float Z = alpha[node->node_id];
  450|  8.72M|    if (sample) {
  ------------------
  |  Branch (450:9): [True: 0, False: 8.72M]
  ------------------
  451|      0|      float max_score = -1e8;
  452|       |      // Calculate the marginal and perturbed scores for stochastic search
  453|      0|      for (size_t i = 0; i < end_nodes(node->pos).size(); i++) {
  ------------------
  |  Branch (453:26): [True: 0, False: 0]
  ------------------
  454|      0|        Node *lnode = end_nodes(node->pos)[i];
  455|       |        // Calculate backwards transition score
  456|      0|        probs[i] =
  457|      0|            top->gx + alpha[lnode->node_id] + (inv_theta * lnode->score) - Z;
  458|      0|        perturbed_probs[i] = probs[i] + Gumbel();
  459|      0|        if (perturbed_probs[i] > max_score) {
  ------------------
  |  Branch (459:13): [True: 0, False: 0]
  ------------------
  460|      0|          max_score = perturbed_probs[i];
  461|      0|        }
  462|      0|      }
  463|       |      // Now constrain the sampled continuations to match the score of parent
  464|      0|      for (size_t i = 0; i < adjusted_probs.size(); i++) {
  ------------------
  |  Branch (464:26): [True: 0, False: 0]
  ------------------
  465|       |        // Use numerically stable version of truncated Gumbel:
  466|       |        // https://arxiv.org/pdf/1903.06059.pdf appendix B.3
  467|      0|        const float v = top->fx - perturbed_probs[i] +
  468|      0|                        std::log1p(-std::exp(perturbed_probs[i] - max_score));
  469|      0|        adjusted_probs[i] = top->fx - std::max(static_cast<float>(0.0), v) -
  470|      0|                            std::log1p(std::exp(-std::abs(v)));
  471|      0|      }
  472|      0|    }
  473|       |
  474|       |    // Expands new node ending at node->pos
  475|  21.4M|    for (size_t i = 0; i < end_nodes(node->pos).size(); i++) {
  ------------------
  |  Branch (475:24): [True: 12.6M, False: 8.72M]
  ------------------
  476|  12.6M|      Node *lnode = end_nodes(node->pos)[i];
  477|  12.6M|      auto *hyp = hypothesis_allocator.Allocate();
  478|  12.6M|      hyp->node = lnode;
  479|  12.6M|      if (sample) {
  ------------------
  |  Branch (479:11): [True: 0, False: 12.6M]
  ------------------
  480|      0|        hyp->gx = probs[i];
  481|      0|        hyp->fx = adjusted_probs[i];
  482|  12.6M|      } else {
  483|  12.6M|        hyp->gx = lnode->score + top->gx;  // just adds node->score
  484|  12.6M|        hyp->fx =
  485|  12.6M|            lnode->backtrace_score + top->gx;  // backtrace_score is h(node).
  486|  12.6M|      }
  487|  12.6M|      hyp->next = top;
  488|  12.6M|      agenda.push(hyp);
  489|  12.6M|    }
  490|       |
  491|  8.72M|    static constexpr int kOneBillion = 1000000000;  // 10^9.
  492|  8.72M|    if (hypothesis_allocator.size() >= kOneBillion) {
  ------------------
  |  Branch (492:9): [True: 0, False: 8.72M]
  ------------------
  493|      0|      if (!printed_memory_warning) {
  ------------------
  |  Branch (493:11): [True: 0, False: 0]
  ------------------
  494|      0|        printed_memory_warning = true;
  495|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  496|      0|                     << " with an example of length " << this->size();
  497|      0|      }
  498|      0|    }
  499|       |
  500|       |    // When the input is too long or contains duplicated phrases,
  501|       |    // `agenda` will get extremely big. Here we avoid this case by
  502|       |    // dynamically shrinking the agenda.
  503|  8.72M|    constexpr int kMaxAgendaSize = 10000;
  504|  8.72M|    constexpr int kMinAgendaSize = 512;
  505|  8.72M|    if (agenda.size() >= kMaxAgendaSize) {
  ------------------
  |  Branch (505:9): [True: 0, False: 8.72M]
  ------------------
  506|      0|      if (timeout_ms > 0) {
  ------------------
  |  Branch (506:11): [True: 0, False: 0]
  ------------------
  507|      0|        const auto elapsed =
  508|      0|            absl::ToInt64Milliseconds(absl::Now() - start_time);
  509|      0|        if (elapsed >= timeout_ms) {
  ------------------
  |  Branch (509:13): [True: 0, False: 0]
  ------------------
  510|      0|          LOG(WARNING) << "NBest search timed out after " << elapsed << " ms. "
  ------------------
  |  |  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|                       << "Falling back to Viterbi best path.";
  512|      0|          return {Viterbi()};
  513|      0|        }
  514|      0|      }
  515|       |      // Keeps the top `kMinAgendaSize` hypothesis.
  516|      0|      Agenda new_agenda;
  517|       |      // Keeps the top hypothesis and the ones on their "next" paths.
  518|      0|      model::FreeList<Hypothesis> new_allocator(kPreallocatedHypothesisSize);
  519|       |      // Map between old Hypothesis* and new Hypothesis*.
  520|      0|      absl::flat_hash_map<const Hypothesis *, Hypothesis *> clone_map;
  521|       |
  522|      0|      const size_t size = std::min<size_t>(kMinAgendaSize, nbest_size * 10);
  523|      0|      shrink_count++;
  524|      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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  525|      0|                   << ". Shrinking (round " << shrink_count << ") down to "
  526|      0|                   << size << ".";
  527|      0|      for (size_t i = 0; i < size; ++i) {
  ------------------
  |  Branch (527:26): [True: 0, False: 0]
  ------------------
  528|      0|        const Hypothesis *top_hyp = agenda.top();
  529|      0|        Hypothesis *cloned_hyp =
  530|      0|            CloneHypAndDependents(top_hyp, &clone_map, &new_allocator);
  531|      0|        new_agenda.push(cloned_hyp);
  532|      0|        agenda.pop();
  533|      0|      }
  534|      0|      agenda = std::move(new_agenda);
  535|      0|      hypothesis_allocator = std::move(new_allocator);
  536|      0|    }
  537|  8.72M|  }
  538|       |
  539|  1.77M|  return results;
  540|  1.77M|}
_ZNK13sentencepiece7unigram5Model13PopulateNodesEPNS0_7LatticeE:
  575|  4.57M|void Model::PopulateNodes(Lattice *lattice) const {
  576|  4.57M|  auto get_chars_length = [&lattice](int begin_pos, const char *end) {
  577|  4.57M|    int pos = begin_pos;
  578|  4.57M|    while (lattice->surface(pos) < end) ++pos;
  579|  4.57M|    return pos - begin_pos;
  580|  4.57M|  };
  581|       |
  582|  4.57M|  const float unk_score = min_score() - kUnkPenalty;
  583|       |
  584|  4.57M|  const size_t len = lattice->size();
  585|  4.57M|  const char *end = lattice->sentence() + lattice->utf8_size();
  586|       |
  587|       |  // +1 just in case.
  588|  4.57M|  std::vector<Darts::DoubleArray::result_pair_type> trie_results(
  589|  4.57M|      trie_results_size_ + 1);
  590|       |
  591|   114M|  for (size_t begin_pos = 0; begin_pos < len; ++begin_pos) {
  ------------------
  |  Branch (591:30): [True: 110M, False: 4.57M]
  ------------------
  592|   110M|    const char *begin = lattice->surface(begin_pos);
  593|       |
  594|       |    // Finds all pieces which are prefix of surface(begin_pos).
  595|   110M|    size_t num_nodes = trie_->commonPrefixSearch(begin, trie_results.data(),
  596|   110M|                                                 trie_results.size(),
  597|   110M|                                                 static_cast<int>(end - begin));
  598|   110M|    if (num_nodes > trie_results.size()) {
  ------------------
  |  Branch (598:9): [True: 0, False: 110M]
  ------------------
  599|      0|      trie_results.resize(num_nodes + 1);
  600|      0|      num_nodes = trie_->commonPrefixSearch(begin, trie_results.data(),
  601|      0|                                            trie_results.size(),
  602|      0|                                            static_cast<int>(end - begin));
  603|      0|    }
  604|       |
  605|   110M|    bool has_single_node = false;
  606|       |
  607|       |    // Inserts pieces to the lattice.
  608|   321M|    for (size_t k = 0; k < num_nodes; ++k) {
  ------------------
  |  Branch (608:24): [True: 211M, False: 110M]
  ------------------
  609|   211M|      const int length =
  610|   211M|          get_chars_length(begin_pos, begin + trie_results[k].length);
  611|   211M|      const int id = trie_results[k].value;
  612|   211M|      if (IsUnusedInlined(id)) continue;
  ------------------
  |  Branch (612:11): [True: 0, False: 211M]
  ------------------
  613|   211M|      Lattice::Node *node = lattice->Insert(begin_pos, length);
  614|   211M|      node->id = id;  // the value of Trie stores vocab_id.
  615|       |      // User defined symbol receives extra bonus to always be selected.
  616|   211M|      node->score = IsUserDefinedInlined(id) ? GetUserDefinedScore(length)
  ------------------
  |  Branch (616:21): [True: 0, False: 211M]
  ------------------
  617|   211M|                                             : GetScoreInlined(id);
  618|   211M|      if (!has_single_node && node->length == 1) {
  ------------------
  |  Branch (618:11): [True: 105M, False: 106M]
  |  Branch (618:31): [True: 100M, False: 4.69M]
  ------------------
  619|   100M|        has_single_node = true;
  620|   100M|      }
  621|   211M|    }
  622|       |
  623|   110M|    if (!has_single_node) {
  ------------------
  |  Branch (623:9): [True: 9.57M, False: 100M]
  ------------------
  624|  9.57M|      Lattice::Node *node = lattice->Insert(begin_pos, 1);
  625|  9.57M|      node->id = unk_id_;  // add UNK node.
  626|  9.57M|      node->score = unk_score;
  627|  9.57M|    }
  628|   110M|  }
  629|  4.57M|}
_ZN13sentencepiece7unigram5Model9BuildTrieEPNSt3__16vectorINS2_4pairINS2_17basic_string_viewIcNS2_11char_traitsIcEEEEiEENS2_9allocatorIS9_EEEE:
  641|  47.1k|void Model::BuildTrie(std::vector<std::pair<absl::string_view, int>> *pieces) {
  642|  47.1k|  if (!status().ok()) return;
  ------------------
  |  Branch (642:7): [True: 0, False: 47.1k]
  ------------------
  643|       |
  644|  47.1k|  if (pieces->empty()) {
  ------------------
  |  Branch (644:7): [True: 5, False: 47.1k]
  ------------------
  645|      5|    status_ = absl::InternalError("no pieces are loaded.");
  646|      5|    return;
  647|      5|  }
  648|       |
  649|       |  // sort by sentencepiece since DoubleArray::build()
  650|       |  // only accepts sorted strings.
  651|  47.1k|  sort(pieces->begin(), pieces->end());
  652|       |
  653|       |  // Makes key/value/length set for DoubleArrayTrie.
  654|  47.1k|  std::vector<const char *> key(pieces->size());
  655|  47.1k|  std::vector<size_t> length(pieces->size());
  656|  47.1k|  std::vector<int> value(pieces->size());
  657|  7.45M|  for (size_t i = 0; i < pieces->size(); ++i) {
  ------------------
  |  Branch (657:22): [True: 7.40M, False: 47.1k]
  ------------------
  658|  7.40M|    key[i] = (*pieces)[i].first.data();  // sorted piece.
  659|  7.40M|    length[i] = (*pieces)[i].first.size();
  660|  7.40M|    value[i] = (*pieces)[i].second;  // vocab_id
  661|  7.40M|  }
  662|       |
  663|  47.1k|  trie_ = std::make_unique<Darts::DoubleArray>();
  664|  47.1k|  if (trie_->build(key.size(), const_cast<char **>(&key[0]),
  ------------------
  |  Branch (664:7): [True: 0, False: 47.1k]
  ------------------
  665|  47.1k|                   const_cast<size_t *>(&length[0]), &value[0]) != 0) {
  666|      0|    status_ = absl::InternalError("cannot build double-array.");
  667|      0|    return;
  668|      0|  }
  669|       |
  670|       |  // Computes the maximum number of shared prefixes in the trie.
  671|  47.1k|  const int kMaxTrieResultsSize = 1024;
  672|  47.1k|  std::vector<Darts::DoubleArray::result_pair_type> results(
  673|  47.1k|      kMaxTrieResultsSize);
  674|  47.1k|  trie_results_size_ = 0;
  675|  7.40M|  for (const auto &p : *pieces) {
  ------------------
  |  Branch (675:22): [True: 7.40M, False: 47.1k]
  ------------------
  676|  7.40M|    const int num_nodes = trie_->commonPrefixSearch(
  677|  7.40M|        p.first.data(), results.data(), results.size(), p.first.size());
  678|  7.40M|    trie_results_size_ = std::max(trie_results_size_, num_nodes);
  679|  7.40M|  }
  680|       |
  681|  47.1k|  pieces_.clear();
  682|       |
  683|  47.1k|  if (trie_results_size_ == 0)
  ------------------
  |  Branch (683:7): [True: 0, False: 47.1k]
  ------------------
  684|      0|    status_ = absl::InternalError("no entry is found in the trie.");
  685|  47.1k|}
_ZN13sentencepiece7unigram5ModelD2Ev:
  705|  5.90k|Model::~Model() {}
unigram_model.cc:_ZN13sentencepiece7unigram12_GLOBAL__N_19LogSumExpEffb:
   52|  1.16G|inline float LogSumExp(float x, float y, bool init_mode) {
   53|  1.16G|  if (init_mode) {
  ------------------
  |  Branch (53:7): [True: 298M, False: 863M]
  ------------------
   54|   298M|    return y;
   55|   298M|  }
   56|   863M|  const float vmin = std::min(x, y);
   57|   863M|  const float vmax = std::max(x, y);
   58|   863M|  constexpr float kMinusLogEpsilon = 50;
   59|   863M|  if (vmax > vmin + kMinusLogEpsilon) {
  ------------------
  |  Branch (59:7): [True: 1.60M, False: 861M]
  ------------------
   60|  1.60M|    return vmax;
   61|   861M|  } else {
   62|   861M|    return vmax + log(std::exp(static_cast<double>(vmin - vmax)) + 1.0);
   63|   861M|  }
   64|   863M|}
unigram_model.cc:_ZZNK13sentencepiece7unigram5Model13PopulateNodesEPNS0_7LatticeEENK3$_0clEiPKc:
  576|   211M|  auto get_chars_length = [&lattice](int begin_pos, const char *end) {
  577|   211M|    int pos = begin_pos;
  578|   981M|    while (lattice->surface(pos) < end) ++pos;
  ------------------
  |  Branch (578:12): [True: 769M, False: 211M]
  ------------------
  579|   211M|    return pos - begin_pos;
  580|   211M|  };
unigram_model.cc:_ZZN13sentencepiece7unigram7Lattice5NBestEmbfEN20HypothesisComparatorclEPNS0_12_GLOBAL__N_110HypothesisES5_:
  393|  15.0M|    const bool operator()(Hypothesis *h1, Hypothesis *h2) {
  394|  15.0M|      return (h1->fx < h2->fx);
  395|  15.0M|    }

_ZN13sentencepiece7unigram5ModelC2Ev:
  131|  5.90k|  Model() {}
_ZNK13sentencepiece7unigram5Model9min_scoreEv:
  159|  4.61M|  float min_score() const { return min_score_; }

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

_ZN13sentencepiece7unigram7TrainerC2ERKNS_11TrainerSpecERKNS_14NormalizerSpecES7_:
   69|  5.91k|      : TrainerInterface::TrainerInterface(trainer_spec, normalizer_spec,
   70|  5.91k|                                           denormalizer_spec) {}

_ZN13sentencepiece15GetNBestTimeoutEv:
   63|  1.77M|int GetNBestTimeout() { return g_nbest_timeout_ms.load(); }
_ZN13sentencepiece11string_util10DecodeUTF8EPKcS2_Pm:
   68|   254M|char32_t DecodeUTF8(const char* begin, const char* end, size_t* mblen) {
   69|   254M|  const size_t len = end - begin;
   70|       |
   71|   254M|  if (static_cast<unsigned char>(begin[0]) < 0x80) {
  ------------------
  |  Branch (71:7): [True: 167M, False: 87.2M]
  ------------------
   72|   167M|    *mblen = 1;
   73|   167M|    return static_cast<unsigned char>(begin[0]);
   74|   167M|  } else if (len >= 2 && (begin[0] & 0xE0) == 0xC0) {
  ------------------
  |  Branch (74:14): [True: 87.2M, False: 17.2k]
  |  Branch (74:26): [True: 18.8M, False: 68.3M]
  ------------------
   75|  18.8M|    const char32_t cp = (((begin[0] & 0x1F) << 6) | ((begin[1] & 0x3F)));
   76|  18.8M|    if (IsTrailByte(begin[1]) && cp >= 0x0080 && IsValidCodepoint(cp)) {
  ------------------
  |  Branch (76:9): [True: 18.4M, False: 403k]
  |  Branch (76:34): [True: 18.4M, False: 7.13k]
  |  Branch (76:50): [True: 18.4M, False: 0]
  ------------------
   77|  18.4M|      *mblen = 2;
   78|  18.4M|      return cp;
   79|  18.4M|    }
   80|  68.3M|  } else if (len >= 3 && (begin[0] & 0xF0) == 0xE0) {
  ------------------
  |  Branch (80:14): [True: 68.3M, False: 29.3k]
  |  Branch (80:26): [True: 66.5M, False: 1.76M]
  ------------------
   81|  66.5M|    const char32_t cp = (((begin[0] & 0x0F) << 12) | ((begin[1] & 0x3F) << 6) |
   82|  66.5M|                       ((begin[2] & 0x3F)));
   83|  66.5M|    if (IsTrailByte(begin[1]) && IsTrailByte(begin[2]) && cp >= 0x0800 &&
  ------------------
  |  Branch (83:9): [True: 66.3M, False: 198k]
  |  Branch (83:34): [True: 66.3M, False: 27.1k]
  |  Branch (83:59): [True: 66.3M, False: 169]
  ------------------
   84|  66.3M|        IsValidCodepoint(cp)) {
  ------------------
  |  Branch (84:9): [True: 66.3M, False: 17.2k]
  ------------------
   85|  66.3M|      *mblen = 3;
   86|  66.3M|      return cp;
   87|  66.3M|    }
   88|  66.5M|  } else if (len >= 4 && (begin[0] & 0xf8) == 0xF0) {
  ------------------
  |  Branch (88:14): [True: 1.75M, False: 39.5k]
  |  Branch (88:26): [True: 210k, False: 1.54M]
  ------------------
   89|   210k|    const char32_t cp = (((begin[0] & 0x07) << 18) | ((begin[1] & 0x3F) << 12) |
   90|   210k|                       ((begin[2] & 0x3F) << 6) | ((begin[3] & 0x3F)));
   91|   210k|    if (IsTrailByte(begin[1]) && IsTrailByte(begin[2]) &&
  ------------------
  |  Branch (91:9): [True: 162k, False: 47.9k]
  |  Branch (91:34): [True: 131k, False: 30.2k]
  ------------------
   92|   131k|        IsTrailByte(begin[3]) && cp >= 0x10000 && IsValidCodepoint(cp)) {
  ------------------
  |  Branch (92:9): [True: 126k, False: 5.65k]
  |  Branch (92:34): [True: 125k, False: 408]
  |  Branch (92:51): [True: 120k, False: 5.02k]
  ------------------
   93|   120k|      *mblen = 4;
   94|   120k|      return cp;
   95|   120k|    }
   96|   210k|  }
   97|       |
   98|       |  // Invalid UTF-8.
   99|  2.32M|  *mblen = 1;
  100|  2.32M|  return kUnicodeError;
  101|   254M|}
_ZN13sentencepiece11string_util19IsStructurallyValidENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  103|   356k|bool IsStructurallyValid(absl::string_view str) {
  104|   356k|  const char* begin = str.data();
  105|   356k|  const char* end = str.data() + str.size();
  106|   356k|  size_t mblen = 0;
  107|  1.38M|  while (begin < end) {
  ------------------
  |  Branch (107:10): [True: 1.02M, False: 356k]
  ------------------
  108|  1.02M|    const char32_t c = DecodeUTF8(begin, end, &mblen);
  109|  1.02M|    if (c == kUnicodeError && mblen != 3) return false;
  ------------------
  |  Branch (109:9): [True: 243k, False: 781k]
  |  Branch (109:31): [True: 0, False: 243k]
  ------------------
  110|  1.02M|    if (!IsValidCodepoint(c)) return false;
  ------------------
  |  Branch (110:9): [True: 0, False: 1.02M]
  ------------------
  111|  1.02M|    begin += mblen;
  112|  1.02M|  }
  113|   356k|  return true;
  114|   356k|}
_ZN13sentencepiece11string_util10EncodeUTF8EDiPc:
  116|   234M|size_t EncodeUTF8(char32_t c, char* output) {
  117|   234M|  if (c <= 0x7F) {
  ------------------
  |  Branch (117:7): [True: 153M, False: 81.0M]
  ------------------
  118|   153M|    *output = static_cast<char>(c);
  119|   153M|    return 1;
  120|   153M|  }
  121|       |
  122|  81.0M|  if (c <= 0x7FF) {
  ------------------
  |  Branch (122:7): [True: 17.7M, False: 63.2M]
  ------------------
  123|  17.7M|    output[1] = 0x80 | (c & 0x3F);
  124|  17.7M|    c >>= 6;
  125|  17.7M|    output[0] = 0xC0 | c;
  126|  17.7M|    return 2;
  127|  17.7M|  }
  128|       |
  129|       |  // if `c` is out-of-range, convert it to REPLACEMENT CHARACTER (U+FFFD).
  130|       |  // This treatment is the same as the original runetochar.
  131|  63.2M|  if (c > 0x10FFFF) c = kUnicodeError;
  ------------------
  |  Branch (131:7): [True: 0, False: 63.2M]
  ------------------
  132|       |
  133|  63.2M|  if (c <= 0xFFFF) {
  ------------------
  |  Branch (133:7): [True: 63.1M, False: 102k]
  ------------------
  134|  63.1M|    output[2] = 0x80 | (c & 0x3F);
  135|  63.1M|    c >>= 6;
  136|  63.1M|    output[1] = 0x80 | (c & 0x3F);
  137|  63.1M|    c >>= 6;
  138|  63.1M|    output[0] = 0xE0 | c;
  139|  63.1M|    return 3;
  140|  63.1M|  }
  141|       |
  142|   102k|  output[3] = 0x80 | (c & 0x3F);
  143|   102k|  c >>= 6;
  144|   102k|  output[2] = 0x80 | (c & 0x3F);
  145|   102k|  c >>= 6;
  146|   102k|  output[1] = 0x80 | (c & 0x3F);
  147|   102k|  c >>= 6;
  148|   102k|  output[0] = 0xF0 | c;
  149|       |
  150|   102k|  return 4;
  151|  63.2M|}
_ZN13sentencepiece11string_util17UnicodeCharToUTF8EDi:
  153|  5.99M|std::string UnicodeCharToUTF8(const char32_t c) {
  154|  5.99M|  return UnicodeTextToUTF8({c});
  155|  5.99M|}
_ZN13sentencepiece11string_util17UTF8ToUnicodeTextENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  157|  11.3M|UnicodeText UTF8ToUnicodeText(absl::string_view utf8) {
  158|  11.3M|  UnicodeText uc;
  159|  11.3M|  const char* begin = utf8.data();
  160|  11.3M|  const char* end = utf8.data() + utf8.size();
  161|   255M|  while (begin < end) {
  ------------------
  |  Branch (161:10): [True: 244M, False: 11.3M]
  ------------------
  162|   244M|    size_t mblen;
  163|   244M|    const char32_t c = DecodeUTF8(begin, end, &mblen);
  164|   244M|    uc.push_back(c);
  165|   244M|    begin += mblen;
  166|   244M|  }
  167|  11.3M|  return uc;
  168|  11.3M|}
_ZN13sentencepiece11string_util17UnicodeTextToUTF8ERKNSt3__16vectorIDiNS1_9allocatorIDiEEEE:
  170|  10.4M|std::string UnicodeTextToUTF8(const UnicodeText& utext) {
  171|  10.4M|  char buf[8];
  172|  10.4M|  std::string result;
  173|   234M|  for (const char32_t c : utext) {
  ------------------
  |  Branch (173:25): [True: 234M, False: 10.4M]
  ------------------
  174|   234M|    const size_t mblen = EncodeUTF8(c, buf);
  175|   234M|    result.append(buf, mblen);
  176|   234M|  }
  177|  10.4M|  return result;
  178|  10.4M|}
_ZN13sentencepiece10ThreadPoolC2Em:
  334|  49.8k|    : impl_(std::make_unique<Impl>(num_threads)) {}
_ZN13sentencepiece10ThreadPoolD2Ev:
  336|  49.8k|ThreadPool::~ThreadPool() {}
_ZN13sentencepiece10ThreadPool8ScheduleENSt3__18functionIFvvEEE:
  338|  49.8k|void ThreadPool::Schedule(std::function<void()> func) {
  339|  49.8k|  impl_->Schedule(std::move(func));
  340|  49.8k|}
_ZN13sentencepiece10ThreadPool4Impl8ScheduleEN4absl12lts_2026052612AnyInvocableIFvvEEE:
  300|  49.8k|  void Schedule(absl::AnyInvocable<void()> func) {
  301|  49.8k|    absl::MutexLock l(mu_);
  302|  49.8k|    queue_.push(std::move(func));
  303|  49.8k|  }
_ZN13sentencepiece10ThreadPool4ImplC2Ei:
  282|  49.8k|  explicit Impl(int num_threads) {
  283|  49.8k|    num_threads = std::min<int>(std::max<int>(1, num_threads), 65536);
  284|  49.8k|    threads_.reserve(num_threads);
  285|  99.6k|    for (int i = 0; i < num_threads; ++i) {
  ------------------
  |  Branch (285:21): [True: 49.8k, False: 49.8k]
  ------------------
  286|  49.8k|      threads_.push_back(std::thread(&Impl::WorkLoop, this));
  287|  49.8k|    }
  288|  49.8k|  }
_ZN13sentencepiece10ThreadPool4Impl8WorkLoopEv:
  312|  49.8k|  void WorkLoop() {
  313|  99.6k|    while (true) {
  ------------------
  |  Branch (313:12): [True: 99.6k, Folded]
  ------------------
  314|  99.6k|      absl::AnyInvocable<void()> func;
  315|  99.6k|      {
  316|  99.6k|        absl::MutexLock l(mu_);
  317|  99.6k|        mu_.Await(absl::Condition(this, &Impl::WorkAvailable));
  318|  99.6k|        func = std::move(queue_.front());
  319|  99.6k|        queue_.pop();
  320|  99.6k|      }
  321|  99.6k|      if (func == nullptr) {  // Shutdown signal.
  ------------------
  |  Branch (321:11): [True: 49.8k, False: 49.8k]
  ------------------
  322|  49.8k|        break;
  323|  49.8k|      }
  324|  49.8k|      func();
  325|  49.8k|    }
  326|  49.8k|  }
_ZNK13sentencepiece10ThreadPool4Impl13WorkAvailableEv:
  308|  99.6k|  bool WorkAvailable() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
  309|  99.6k|    return !queue_.empty();
  310|  99.6k|  }
_ZN13sentencepiece10ThreadPool4ImplD2Ev:
  290|  49.8k|  ~Impl() {
  291|  49.8k|    {
  292|  49.8k|      absl::MutexLock l(mu_);
  293|  99.6k|      for (size_t i = 0; i < threads_.size(); i++) {
  ------------------
  |  Branch (293:26): [True: 49.8k, False: 49.8k]
  ------------------
  294|  49.8k|        queue_.push(nullptr);  // Shutdown signal.
  295|  49.8k|      }
  296|  49.8k|    }
  297|  49.8k|    for (auto& thread : threads_) thread.join();
  ------------------
  |  Branch (297:23): [True: 49.8k, False: 49.8k]
  ------------------
  298|  49.8k|  }

_ZN13sentencepiece11string_util10OneCharLenEPKc:
  112|   340M|inline size_t OneCharLen(const char* src) {
  113|   340M|  return "\1\1\1\1\1\1\1\1\1\1\1\1\2\2\3\4"[(*src & 0xFF) >> 4];
  114|   340M|}
_ZN13sentencepiece11string_util11IsTrailByteEc:
  118|   152M|inline bool IsTrailByte(char x) { return static_cast<signed char>(x) < -0x40; }
_ZN13sentencepiece11string_util16IsValidCodepointEDi:
  120|   141M|inline bool IsValidCodepoint(char32_t c) {
  121|   141M|  return (static_cast<uint32_t>(c) < 0xD800) || (c >= 0xE000 && c <= 0x10FFFF);
  ------------------
  |  Branch (121:10): [True: 80.2M, False: 61.4M]
  |  Branch (121:50): [True: 61.4M, False: 17.2k]
  |  Branch (121:65): [True: 61.4M, False: 5.02k]
  ------------------
  122|   141M|}
_ZN13sentencepiece11string_util10DecodeUTF8ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPm:
  130|  8.84M|inline char32_t DecodeUTF8(absl::string_view input, size_t* mblen) {
  131|  8.84M|  return DecodeUTF8(input.data(), input.data() + input.size(), mblen);
  132|  8.84M|}
_ZN13sentencepiece11string_util17IsValidDecodeUTF8ENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPm:
  134|  8.84M|inline bool IsValidDecodeUTF8(absl::string_view input, size_t* mblen) {
  135|  8.84M|  const char32_t c = DecodeUTF8(input, mblen);
  136|  8.84M|  return c != kUnicodeError || *mblen == 3;
  ------------------
  |  Branch (136:10): [True: 6.51M, False: 2.32M]
  |  Branch (136:32): [True: 0, False: 2.32M]
  ------------------
  137|  8.84M|}
_ZN13sentencepiece6random16ReservoirSamplerINSt3__14pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEEEC2EPNS2_6vectorISA_NS7_ISA_EEEEmm:
  225|  1.25k|      : sampled_(sampled), size_(size), gen_(std::seed_seq{seed}) {}
_ZN13sentencepiece6random16ReservoirSamplerINSt3__14pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEEED2Ev:
  226|  1.25k|  virtual ~ReservoirSampler() = default;
_ZN13sentencepiece6random16ReservoirSamplerINSt3__14pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEEE3AddERKSA_:
  228|  10.0k|  void Add(const T& item) {
  229|  10.0k|    if (size_ == 0) {
  ------------------
  |  Branch (229:9): [True: 0, False: 10.0k]
  ------------------
  230|      0|      return;
  231|      0|    }
  232|       |
  233|  10.0k|    ++total_;
  234|  10.0k|    if (sampled_->size() < size_) {
  ------------------
  |  Branch (234:9): [True: 10.0k, False: 0]
  ------------------
  235|  10.0k|      sampled_->push_back(item);
  236|  10.0k|    } else {
  237|      0|      const auto n = absl::Uniform<uint64_t>(gen_, 0, total_ - 1);
  238|      0|      if (n < sampled_->size()) {
  ------------------
  |  Branch (238:11): [True: 0, False: 0]
  ------------------
  239|      0|        (*sampled_)[n] = item;
  240|      0|      }
  241|      0|    }
  242|  10.0k|  }
_ZNK13sentencepiece6random16ReservoirSamplerINSt3__14pairINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElEEE10total_sizeEv:
  244|  21.3k|  [[nodiscard]] uint64_t total_size() const { return total_; }
_ZN13sentencepiece6random16ReservoirSamplerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEED2Ev:
  226|  8.53k|  virtual ~ReservoirSampler() = default;
_ZN13sentencepiece6random16ReservoirSamplerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPNS2_6vectorIS8_NS6_IS8_EEEEm:
  222|  8.53k|      : sampled_(sampled), size_(size) {}
_ZN13sentencepiece6random16ReservoirSamplerINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE3AddERKS8_:
  228|  58.9k|  void Add(const T& item) {
  229|  58.9k|    if (size_ == 0) {
  ------------------
  |  Branch (229:9): [True: 58.9k, False: 0]
  ------------------
  230|  58.9k|      return;
  231|  58.9k|    }
  232|       |
  233|      0|    ++total_;
  234|      0|    if (sampled_->size() < size_) {
  ------------------
  |  Branch (234:9): [True: 0, False: 0]
  ------------------
  235|      0|      sampled_->push_back(item);
  236|      0|    } else {
  237|      0|      const auto n = absl::Uniform<uint64_t>(gen_, 0, total_ - 1);
  238|      0|      if (n < sampled_->size()) {
  ------------------
  |  Branch (238:11): [True: 0, False: 0]
  ------------------
  239|      0|        (*sampled_)[n] = item;
  240|      0|      }
  241|      0|    }
  242|      0|  }
_ZN13sentencepiece4port11ContainsKeyIN4absl12lts_2026052613flat_hash_mapIDilNS3_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS8_9allocatorINS8_4pairIKDilEEEEEEDiEEbRKT_RKT0_:
  164|  9.03M|bool ContainsKey(const Collection& collection, const Key& key) {
  165|  9.03M|  return collection.find(key) != collection.end();
  166|  9.03M|}
_ZN13sentencepiece4port11ContainsKeyIN4absl12lts_2026052613flat_hash_mapINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEElNS3_18container_internal10StringHashENSC_8StringEqENS9_INS5_4pairIKSB_lEEEEEESB_EEbRKT_RKT0_:
  164|  1.77M|bool ContainsKey(const Collection& collection, const Key& key) {
  165|  1.77M|  return collection.find(key) != collection.end();
  166|  1.77M|}
_ZN13sentencepiece4port11ContainsKeyIN4absl12lts_2026052613flat_hash_mapINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEfNS3_18container_internal10StringHashENSC_8StringEqENS9_INS5_4pairIKSB_fEEEEEESB_EEbRKT_RKT0_:
  164|   310k|bool ContainsKey(const Collection& collection, const Key& key) {
  165|   310k|  return collection.find(key) != collection.end();
  166|   310k|}
_ZN13sentencepiece4port15FindWithDefaultIN4absl12lts_2026052613flat_hash_mapIDilNS3_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS8_9allocatorINS8_4pairIKDilEEEEEEEERKNT_10value_type11second_typeERKSH_RKNSI_10first_typeESL_:
  183|  1.10M|    const typename Collection::value_type::second_type& value) {
  184|  1.10M|  if (const auto it = collection.find(key); it != collection.end()) {
  ------------------
  |  Branch (184:45): [True: 1.07M, False: 35.9k]
  ------------------
  185|  1.07M|    return it->second;
  186|  1.07M|  }
  187|  35.9k|  return value;
  188|  1.10M|}
_ZN13sentencepiece4port11InsertOrDieIN4absl12lts_2026052613flat_hash_mapImPNS_3bpe7Trainer6SymbolENS3_13hash_internal4HashImEENSt3__18equal_toImEENSC_9allocatorINSC_4pairIKmS8_EEEEEEEEvPT_RKNSL_10value_type10first_typeERKNSN_11second_typeE:
  208|   293k|                 const typename Collection::value_type::second_type& data) {
  209|   586k|  CHECK(InsertIfNotPresent(collection, key, data)) << "duplicate key";
  ------------------
  |  |   58|   293k|#define CHECK(condition) ABSL_LOG_INTERNAL_CHECK_IMPL((condition), #condition)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION_FATAL(STATELESS,                        \
  |  |  |  |  ------------------
  |  |  |  |  |  |  180|   293k|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|   586k|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|   586k|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 293k, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|   293k|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 293k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|   586k|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [True: 293k, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [Folded, False: 293k]
  |  |  |  |  |  |  |  |  |  Branch (68:7): [True: 0, False: 293k]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|                                    ABSL_PREDICT_FALSE(!(condition))) \
  |  |  |  |   29|   293k|  ABSL_LOG_INTERNAL_CHECK(condition_text).InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   84|   293k|  ::absl::log_internal::LogMessageFatal(__FILE__, __LINE__, failure_message)
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  210|   293k|}
_ZN13sentencepiece4port18InsertIfNotPresentIN4absl12lts_2026052613flat_hash_mapImPNS_3bpe7Trainer6SymbolENS3_13hash_internal4HashImEENSt3__18equal_toImEENSC_9allocatorINSC_4pairIKmS8_EEEEEEEEbPT_RKNSL_10value_type10first_typeERKNSN_11second_typeE:
  200|   293k|    const typename Collection::value_type::second_type& value) {
  201|   293k|  return InsertIfNotPresent(collection,
  202|   293k|                            typename Collection::value_type(key, value));
  203|   293k|}
_ZN13sentencepiece4port18InsertIfNotPresentIN4absl12lts_2026052613flat_hash_mapImPNS_3bpe7Trainer6SymbolENS3_13hash_internal4HashImEENSt3__18equal_toImEENSC_9allocatorINSC_4pairIKmS8_EEEEEEEEbPT_RKNSL_10value_typeE:
  192|   293k|                        const typename Collection::value_type& vt) {
  193|   293k|  return collection->insert(vt).second;
  194|   293k|}
_ZN13sentencepiece4port15FindWithDefaultIN4absl12lts_2026052613flat_hash_mapIDiNS_14unicode_script10ScriptTypeENS3_13hash_internal4HashIDiEENSt3__18equal_toIDiEENSA_9allocatorINSA_4pairIKDiS6_EEEEEEEERKNT_10value_type11second_typeERKSJ_RKNSK_10first_typeESN_:
  183|  40.3M|    const typename Collection::value_type::second_type& value) {
  184|  40.3M|  if (const auto it = collection.find(key); it != collection.end()) {
  ------------------
  |  Branch (184:45): [True: 39.1M, False: 1.21M]
  ------------------
  185|  39.1M|    return it->second;
  186|  39.1M|  }
  187|  1.21M|  return value;
  188|  40.3M|}
_ZN13sentencepiece11string_util9DecodePODIjEEbNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPT_:
   74|  17.0k|inline bool DecodePOD(absl::string_view str, T* result) {
   75|  17.0k|  static_assert(std::is_trivially_copyable_v<T>,
   76|  17.0k|                "T must be trivially copyable");
   77|  17.0k|  if (sizeof(*result) != str.size()) {
  ------------------
  |  Branch (77:7): [True: 0, False: 17.0k]
  ------------------
   78|      0|    return false;
   79|      0|  }
   80|  17.0k|  std::memcpy(result, str.data(), sizeof(T));
   81|  17.0k|  return true;
   82|  17.0k|}

_ZN13sentencepiece4word7Trainer5TrainEv:
   29|    933|absl::Status Trainer::Train() {
   30|    933|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|    933|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|    933|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  1.86k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  1.86k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  1.86k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 933, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|    933|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 933]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  1.86k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 932, False: 1]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  1.86k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  1.86k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|    932|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  1.86k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   31|       |
   32|    932|  RET_CHECK(normalizer_spec_.escape_whitespaces());
  ------------------
  |  |  285|    932|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 932, False: 0]
  |  |  ------------------
  |  |  286|    932|  } else /* NOLINT */                                         \
  |  |  287|    932|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   33|    932|  RET_CHECK_EQ(TrainerSpec::WORD, trainer_spec_.model_type());
  ------------------
  |  |  290|    932|#define RET_CHECK_EQ(a, b) RET_CHECK((a) == (b))
  |  |  ------------------
  |  |  |  |  285|    932|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 932, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  286|    932|  } else /* NOLINT */                                         \
  |  |  |  |  287|    932|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   34|       |
   35|    932|  RETURN_IF_ERROR(LoadSentences());
  ------------------
  |  |   44|    932|#define RETURN_IF_ERROR(...) ABSL_RETURN_IF_ERROR(__VA_ARGS__)
  |  |  ------------------
  |  |  |  |   90|    932|  ABSL_INTERNAL_STATUS_MACROS_RETURN_IF_ERROR_IMPL_(return, expr)
  |  |  |  |  ------------------
  |  |  |  |  |  |  162|  2.79k|  ABSL_INTERNAL_STATUS_MACROS_IMPL_ELSE_BLOCKER_                          \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  349|  1.86k|  switch (0)                                           \
  |  |  |  |  |  |  |  |  350|  1.86k|  case 0:                                              \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (350:3): [True: 932, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  351|    932|  default:  // NOLINT
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (351:3): [True: 0, False: 932]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  163|  2.79k|  if (auto status_macro_internal_adaptor =                                \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (163:12): [True: 929, False: 3]
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  164|  2.79k|          absl::status_macro_internal::MacroAdaptor(                      \
  |  |  |  |  |  |  165|  2.79k|              (expr), absl::SourceLocation::current())) {                 \
  |  |  |  |  |  |  166|    929|  } else /* NOLINT */                                                     \
  |  |  |  |  |  |  167|  2.79k|    return_keyword status_macro_internal_adaptor.Consume()
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   36|       |
   37|    929|  absl::flat_hash_map<std::string, uint64_t> freq;
   38|  8.51k|  for (const auto& it : sentences_) {
  ------------------
  |  Branch (38:23): [True: 8.51k, False: 929]
  ------------------
   39|   146k|    for (const auto& s : SplitIntoWords(it.first)) {
  ------------------
  |  Branch (39:24): [True: 146k, False: 8.51k]
  ------------------
   40|   146k|      freq[s] += it.second;
   41|   146k|    }
   42|  8.51k|  }
   43|       |
   44|    929|  const int vocab_size = trainer_spec_.vocab_size() - meta_pieces_.size();
   45|    929|  RET_CHECK_GE(vocab_size, 0);
  ------------------
  |  |  292|    929|#define RET_CHECK_GE(a, b) RET_CHECK((a) >= (b))
  |  |  ------------------
  |  |  |  |  285|    929|  if (condition) {                                            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (285:7): [True: 913, False: 16]
  |  |  |  |  ------------------
  |  |  |  |  286|    913|  } else /* NOLINT */                                         \
  |  |  |  |  287|    929|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  |  |  288|     16|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
   46|       |
   47|    913|  uint64_t sum = 0;
   48|  92.8k|  for (const auto& it : freq) {
  ------------------
  |  Branch (48:23): [True: 92.8k, False: 913]
  ------------------
   49|  92.8k|    sum += it.second;
   50|  92.8k|  }
   51|       |
   52|    913|  const auto logsum = std::log(static_cast<float>(sum));
   53|       |
   54|    913|  RET_CHECK(final_pieces_.empty());
  ------------------
  |  |  285|    913|  if (condition) {                                            \
  |  |  ------------------
  |  |  |  Branch (285:7): [True: 913, False: 0]
  |  |  ------------------
  |  |  286|    913|  } else /* NOLINT */                                         \
  |  |  287|    913|    return absl::StatusBuilder(::absl::StatusCode::kInternal) \
  |  |  288|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
   55|  32.6k|  for (const auto& it : Sorted(freq)) {
  ------------------
  |  Branch (55:23): [True: 32.6k, False: 601]
  ------------------
   56|  32.6k|    if (it.first.find(kUNKStr) != std::string::npos) {
  ------------------
  |  Branch (56:9): [True: 6.76k, False: 25.8k]
  ------------------
   57|  6.76k|      continue;
   58|  6.76k|    }
   59|  25.8k|    if (!trainer_spec_.use_all_vocab() &&
  ------------------
  |  Branch (59:9): [True: 25.8k, False: 0]
  ------------------
   60|  25.8k|        final_pieces_.size() == static_cast<size_t>(vocab_size)) {
  ------------------
  |  Branch (60:9): [True: 312, False: 25.5k]
  ------------------
   61|    312|      break;
   62|    312|    }
   63|  25.5k|    final_pieces_.emplace_back(
   64|  25.5k|        it.first, std::log(static_cast<float>(it.second)) - logsum);
   65|  25.5k|  }
   66|       |
   67|    913|  if (trainer_spec_.use_all_vocab()) {
  ------------------
  |  Branch (67:7): [True: 0, False: 913]
  ------------------
   68|      0|    trainer_spec_.set_vocab_size(final_pieces_.size() + meta_pieces_.size());
   69|      0|  }
   70|       |
   71|    913|  return Save();
   72|    913|}

_ZN13sentencepiece4word7TrainerC2ERKNS_11TrainerSpecERKNS_14NormalizerSpecES7_:
   35|    933|      : TrainerInterface::TrainerInterface(trainer_spec, normalizer_spec,
   36|    933|                                           denormalizer_spec) {}

_ZN4absl12lts_2026052613base_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_2026052613base_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_2026052613base_internal11ControlWordEPNS0_9once_flagE:
  195|   642k|    once_flag* absl_nonnull flag) {
  196|   642k|  return &flag->control_;
  197|   642k|}
_ZN4absl12lts_202605269call_onceIRFvvEJEEEvRNS0_9once_flagEOT_DpOT0_:
  215|  8.53k|    call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  216|  8.53k|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  217|  8.53k|  uint32_t s = once->load(std::memory_order_acquire);
  218|  8.53k|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  190|  8.53k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 8.53k]
  |  |  |  Branch (190:49): [Folded, False: 8.53k]
  |  |  |  Branch (190:58): [True: 1, False: 8.53k]
  |  |  ------------------
  ------------------
  219|      1|    base_internal::CallOnceImpl(
  220|      1|        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
  221|      1|        std::forward<Callable>(fn), std::forward<Args>(args)...);
  222|      1|  }
  223|  8.53k|}
_ZN4absl12lts_2026052613base_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|       |      // Memory corruption may cause this error.
  164|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  165|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  166|       |    }
  167|       |  }
  168|       |#endif  // NDEBUG
  169|      2|  static const base_internal::SpinLockWaitTransition trans[] = {
  170|      2|      {kOnceInit, kOnceRunning, true},
  171|      2|      {kOnceRunning, kOnceWaiter, false},
  172|      2|      {kOnceDone, kOnceDone, true}};
  173|       |
  174|       |  // Must do this before potentially modifying control word's state.
  175|      2|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  176|       |  // Short circuit the simplest case to avoid procedure call overhead.
  177|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  178|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  179|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  180|      2|  uint32_t old_control = kOnceInit;
  181|      2|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (181:7): [True: 2, False: 0]
  ------------------
  182|      2|                                       std::memory_order_relaxed) ||
  183|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   46|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (183:7): [True: 0, False: 0]
  ------------------
  184|      2|                                  scheduling_mode) == kOnceInit) {
  185|      2|    std::invoke(std::forward<Callable>(fn), std::forward<Args>(args)...);
  186|      2|    old_control =
  187|      2|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  188|      2|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (188:9): [True: 0, False: 2]
  ------------------
  189|      0|      base_internal::SpinLockWake(control, true);
  190|      0|    }
  191|      2|  }  // else *control is already kOnceDone
  192|      2|}
mutex.cc:_ZN4absl12lts_2026052613base_internal16LowLevelCallOnceIZNS0_12_GLOBAL__N_115GetMutexGlobalsEvE3$_0JEEEvPNS0_9once_flagEOT_DpOT0_:
  201|  21.5k|                      Args&&... args) {
  202|  21.5k|  std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
  203|  21.5k|  uint32_t s = once->load(std::memory_order_acquire);
  204|  21.5k|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  190|  21.5k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 21.5k]
  |  |  |  Branch (190:49): [Folded, False: 21.5k]
  |  |  |  Branch (190:58): [True: 1, False: 21.5k]
  |  |  ------------------
  ------------------
  205|      1|    base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
  206|      1|                                std::forward<Callable>(fn),
  207|      1|                                std::forward<Args>(args)...);
  208|      1|  }
  209|  21.5k|}
mutex.cc:_ZN4absl12lts_2026052613base_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|       |      // Memory corruption may cause this error.
  164|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  165|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  166|       |    }
  167|       |  }
  168|       |#endif  // NDEBUG
  169|      1|  static const base_internal::SpinLockWaitTransition trans[] = {
  170|      1|      {kOnceInit, kOnceRunning, true},
  171|      1|      {kOnceRunning, kOnceWaiter, false},
  172|      1|      {kOnceDone, kOnceDone, true}};
  173|       |
  174|       |  // Must do this before potentially modifying control word's state.
  175|      1|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  176|       |  // Short circuit the simplest case to avoid procedure call overhead.
  177|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  178|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  179|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  180|      1|  uint32_t old_control = kOnceInit;
  181|      1|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (181:7): [True: 1, False: 0]
  ------------------
  182|      1|                                       std::memory_order_relaxed) ||
  183|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   46|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (183:7): [True: 0, False: 0]
  ------------------
  184|      1|                                  scheduling_mode) == kOnceInit) {
  185|      1|    std::invoke(std::forward<Callable>(fn), std::forward<Args>(args)...);
  186|      1|    old_control =
  187|      1|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  188|      1|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (188:9): [True: 0, False: 1]
  ------------------
  189|      0|      base_internal::SpinLockWake(control, true);
  190|      0|    }
  191|      1|  }  // else *control is already kOnceDone
  192|      1|}
sysinfo.cc:_ZN4absl12lts_2026052613base_internal16LowLevelCallOnceIZNS1_7NumCPUsEvE3$_0JEEEvPNS0_9once_flagEOT_DpOT0_:
  201|      2|                      Args&&... args) {
  202|      2|  std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
  203|      2|  uint32_t s = once->load(std::memory_order_acquire);
  204|      2|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 1, False: 1]
  |  |  ------------------
  ------------------
  205|      1|    base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
  206|      1|                                std::forward<Callable>(fn),
  207|      1|                                std::forward<Args>(args)...);
  208|      1|  }
  209|      2|}
sysinfo.cc:_ZN4absl12lts_2026052613base_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|       |      // Memory corruption may cause this error.
  164|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  165|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  166|       |    }
  167|       |  }
  168|       |#endif  // NDEBUG
  169|      1|  static const base_internal::SpinLockWaitTransition trans[] = {
  170|      1|      {kOnceInit, kOnceRunning, true},
  171|      1|      {kOnceRunning, kOnceWaiter, false},
  172|      1|      {kOnceDone, kOnceDone, true}};
  173|       |
  174|       |  // Must do this before potentially modifying control word's state.
  175|      1|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  176|       |  // Short circuit the simplest case to avoid procedure call overhead.
  177|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  178|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  179|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  180|      1|  uint32_t old_control = kOnceInit;
  181|      1|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (181:7): [True: 1, False: 0]
  ------------------
  182|      1|                                       std::memory_order_relaxed) ||
  183|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   46|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (183:7): [True: 0, False: 0]
  ------------------
  184|      1|                                  scheduling_mode) == kOnceInit) {
  185|      1|    std::invoke(std::forward<Callable>(fn), std::forward<Args>(args)...);
  186|      1|    old_control =
  187|      1|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  188|      1|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (188:9): [True: 0, False: 1]
  ------------------
  189|      0|      base_internal::SpinLockWake(control, true);
  190|      0|    }
  191|      1|  }  // else *control is already kOnceDone
  192|      1|}
sysinfo.cc:_ZN4absl12lts_2026052613base_internal16LowLevelCallOnceIZNS1_19NominalCPUFrequencyEvE3$_0JEEEvPNS0_9once_flagEOT_DpOT0_:
  201|     12|                      Args&&... args) {
  202|     12|  std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
  203|     12|  uint32_t s = once->load(std::memory_order_acquire);
  204|     12|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  190|     12|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 11]
  |  |  |  Branch (190:49): [Folded, False: 12]
  |  |  |  Branch (190:58): [True: 1, False: 11]
  |  |  ------------------
  ------------------
  205|      1|    base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
  206|      1|                                std::forward<Callable>(fn),
  207|      1|                                std::forward<Args>(args)...);
  208|      1|  }
  209|     12|}
sysinfo.cc:_ZN4absl12lts_2026052613base_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|       |      // Memory corruption may cause this error.
  164|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  165|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  166|       |    }
  167|       |  }
  168|       |#endif  // NDEBUG
  169|      1|  static const base_internal::SpinLockWaitTransition trans[] = {
  170|      1|      {kOnceInit, kOnceRunning, true},
  171|      1|      {kOnceRunning, kOnceWaiter, false},
  172|      1|      {kOnceDone, kOnceDone, true}};
  173|       |
  174|       |  // Must do this before potentially modifying control word's state.
  175|      1|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  176|       |  // Short circuit the simplest case to avoid procedure call overhead.
  177|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  178|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  179|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  180|      1|  uint32_t old_control = kOnceInit;
  181|      1|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (181:7): [True: 1, False: 0]
  ------------------
  182|      1|                                       std::memory_order_relaxed) ||
  183|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   46|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (183:7): [True: 0, False: 0]
  ------------------
  184|      1|                                  scheduling_mode) == kOnceInit) {
  185|      1|    std::invoke(std::forward<Callable>(fn), std::forward<Args>(args)...);
  186|      1|    old_control =
  187|      1|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  188|      1|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (188:9): [True: 0, False: 1]
  ------------------
  189|      0|      base_internal::SpinLockWake(control, true);
  190|      0|    }
  191|      1|  }  // else *control is already kOnceDone
  192|      1|}
_ZN4absl12lts_202605269call_onceIRFvPFvPvEEJRS4_EEEvRNS0_9once_flagEOT_DpOT0_:
  215|     14|    call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  216|     14|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  217|     14|  uint32_t s = once->load(std::memory_order_acquire);
  218|     14|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  190|     14|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 13]
  |  |  |  Branch (190:49): [Folded, False: 14]
  |  |  |  Branch (190:58): [True: 1, False: 13]
  |  |  ------------------
  ------------------
  219|      1|    base_internal::CallOnceImpl(
  220|      1|        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
  221|      1|        std::forward<Callable>(fn), std::forward<Args>(args)...);
  222|      1|  }
  223|     14|}
_ZN4absl12lts_2026052613base_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|       |      // Memory corruption may cause this error.
  164|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  165|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  166|       |    }
  167|       |  }
  168|       |#endif  // NDEBUG
  169|      1|  static const base_internal::SpinLockWaitTransition trans[] = {
  170|      1|      {kOnceInit, kOnceRunning, true},
  171|      1|      {kOnceRunning, kOnceWaiter, false},
  172|      1|      {kOnceDone, kOnceDone, true}};
  173|       |
  174|       |  // Must do this before potentially modifying control word's state.
  175|      1|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  176|       |  // Short circuit the simplest case to avoid procedure call overhead.
  177|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  178|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  179|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  180|      1|  uint32_t old_control = kOnceInit;
  181|      1|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (181:7): [True: 1, False: 0]
  ------------------
  182|      1|                                       std::memory_order_relaxed) ||
  183|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   46|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (183:7): [True: 0, False: 0]
  ------------------
  184|      1|                                  scheduling_mode) == kOnceInit) {
  185|      1|    std::invoke(std::forward<Callable>(fn), std::forward<Args>(args)...);
  186|      1|    old_control =
  187|      1|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  188|      1|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (188:9): [True: 0, False: 1]
  ------------------
  189|      0|      base_internal::SpinLockWake(control, true);
  190|      0|    }
  191|      1|  }  // else *control is already kOnceDone
  192|      1|}
_ZN4absl12lts_2026052613base_internal16LowLevelCallOnceIRFvvEJEEEvPNS0_9once_flagEOT_DpOT0_:
  201|      2|                      Args&&... args) {
  202|      2|  std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
  203|      2|  uint32_t s = once->load(std::memory_order_acquire);
  204|      2|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  Branch (190:58): [True: 1, False: 1]
  |  |  ------------------
  ------------------
  205|      1|    base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
  206|      1|                                std::forward<Callable>(fn),
  207|      1|                                std::forward<Args>(args)...);
  208|      1|  }
  209|      2|}
log_sink_set.cc:_ZN4absl12lts_202605269call_onceIZNS0_12log_internal12_GLOBAL__N_113StderrLogSink4SendERKNS0_8LogEntryEEUlvE_JEEEvRNS0_9once_flagEOT_DpOT0_:
  215|   612k|    call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
  216|   612k|  std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
  217|   612k|  uint32_t s = once->load(std::memory_order_acquire);
  218|   612k|  if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
  ------------------
  |  |  190|   612k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 612k]
  |  |  |  Branch (190:49): [Folded, False: 612k]
  |  |  |  Branch (190:58): [True: 1, False: 612k]
  |  |  ------------------
  ------------------
  219|      1|    base_internal::CallOnceImpl(
  220|      1|        once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
  221|      1|        std::forward<Callable>(fn), std::forward<Args>(args)...);
  222|      1|  }
  223|   612k|}
log_sink_set.cc:_ZN4absl12lts_2026052613base_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|       |      // Memory corruption may cause this error.
  164|       |      ABSL_RAW_LOG(FATAL, "Unexpected value for control word: 0x%lx",
  165|       |                   static_cast<unsigned long>(old_control));  // NOLINT
  166|       |    }
  167|       |  }
  168|       |#endif  // NDEBUG
  169|      1|  static const base_internal::SpinLockWaitTransition trans[] = {
  170|      1|      {kOnceInit, kOnceRunning, true},
  171|      1|      {kOnceRunning, kOnceWaiter, false},
  172|      1|      {kOnceDone, kOnceDone, true}};
  173|       |
  174|       |  // Must do this before potentially modifying control word's state.
  175|      1|  base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
  176|       |  // Short circuit the simplest case to avoid procedure call overhead.
  177|       |  // The base_internal::SpinLockWait() call returns either kOnceInit or
  178|       |  // kOnceDone. If it returns kOnceDone, it must have loaded the control word
  179|       |  // with std::memory_order_acquire and seen a value of kOnceDone.
  180|      1|  uint32_t old_control = kOnceInit;
  181|      1|  if (control->compare_exchange_strong(old_control, kOnceRunning,
  ------------------
  |  Branch (181:7): [True: 1, False: 0]
  ------------------
  182|      1|                                       std::memory_order_relaxed) ||
  183|      0|      base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
  ------------------
  |  |   46|      0|  (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
  ------------------
  |  Branch (183:7): [True: 0, False: 0]
  ------------------
  184|      1|                                  scheduling_mode) == kOnceInit) {
  185|      1|    std::invoke(std::forward<Callable>(fn), std::forward<Args>(args)...);
  186|      1|    old_control =
  187|      1|        control->exchange(base_internal::kOnceDone, std::memory_order_release);
  188|      1|    if (old_control == base_internal::kOnceWaiter) {
  ------------------
  |  Branch (188:9): [True: 0, False: 1]
  ------------------
  189|      0|      base_internal::SpinLockWake(control, true);
  190|      0|    }
  191|      1|  }  // else *control is already kOnceDone
  192|      1|}

_ZN4absl12lts_202605268bit_castImlTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  190|     84|inline constexpr Dest bit_cast(const Source& source) {
  191|     84|  return __builtin_bit_cast(Dest, source);
  192|     84|}
_ZN4absl12lts_202605268bit_castIlmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  190|     42|inline constexpr Dest bit_cast(const Source& source) {
  191|     42|  return __builtin_bit_cast(Dest, source);
  192|     42|}
_ZN4absl12lts_202605268bit_castIdmTnNSt3__19enable_ifIXaaaaeqstT_stT0_sr3std21is_trivially_copyableIS5_EE5valuesr3std21is_trivially_copyableIS4_EE5valueEiE4typeELi0EEES4_RKS5_:
  190|  2.17k|inline constexpr Dest bit_cast(const Source& source) {
  191|  2.17k|  return __builtin_bit_cast(Dest, source);
  192|  2.17k|}

_Z49AbslInternalAnnotateIgnoreReadsBegin_lts_20260526v:
  328|     22|    ABSL_INTERNAL_IGNORE_READS_BEGIN_ATTRIBUTE {}
_Z47AbslInternalAnnotateIgnoreReadsEnd_lts_20260526v:
  332|     22|    ABSL_INTERNAL_IGNORE_READS_END_ATTRIBUTE {}

_ZN4absl12lts_2026052613base_internal10AtomicHookIPFvlEE13DummyFunctionEl:
  135|      2|  static ReturnType DummyFunction(Args...) {
  136|      2|    return ReturnType();
  137|      2|  }
_ZN4absl12lts_2026052613base_internal10AtomicHookIPFvPKcPKvlEE13DummyFunctionES4_S6_l:
  135|      2|  static ReturnType DummyFunction(Args...) {
  136|      2|    return ReturnType();
  137|      2|  }
_ZNK4absl12lts_2026052613base_internal10AtomicHookIPFvPKcPKvlEEclIJRA13_S3_PNS0_5MutexERlEEEvDpOT_:
  116|      2|  ReturnType operator()(CallArgs&&... args) const {
  117|      2|    return DoLoad()(std::forward<CallArgs>(args)...);
  118|      2|  }
_ZNK4absl12lts_2026052613base_internal10AtomicHookIPFvPKcPKvlEE6DoLoadEv:
  148|      2|  FnPtr DoLoad() const { return hook_.load(std::memory_order_acquire); }
_ZNK4absl12lts_2026052613base_internal10AtomicHookIPFvlEEclIJRlEEEvDpOT_:
  116|      2|  ReturnType operator()(CallArgs&&... args) const {
  117|      2|    return DoLoad()(std::forward<CallArgs>(args)...);
  118|      2|  }
_ZNK4absl12lts_2026052613base_internal10AtomicHookIPFvlEE6DoLoadEv:
  148|      2|  FnPtr DoLoad() const { return hook_.load(std::memory_order_acquire); }

_ZN4absl12lts_2026052613base_internal10CycleClock9FrequencyEv:
  134|     12|inline double CycleClock::Frequency() {
  135|     12|  return kFrequencyScale * base_internal::UnscaledCycleClock::Frequency();
  136|     12|}
_ZN4absl12lts_2026052613base_internal10CycleClock3NowEv:
  125|     39|inline int64_t CycleClock::Now() {
  126|     39|  auto fn = LoadCycleClockSource();
  127|     39|  if (fn == nullptr) {
  ------------------
  |  Branch (127:7): [True: 39, False: 0]
  ------------------
  128|     39|    return base_internal::UnscaledCycleClock::Now() >> kShift;
  129|     39|  }
  130|      0|  return fn() >> kShift;
  131|     39|}
_ZN4absl12lts_2026052613base_internal10CycleClock20LoadCycleClockSourceEv:
  107|     39|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|     39|  return cycle_clock_source_.load(std::memory_order_acquire);
  121|     39|}

_ZN4absl12lts_2026052613little_endian10FromHost16Et:
  103|   612k|inline uint16_t FromHost16(uint16_t x) { return x; }
_ZN4absl12lts_2026052613little_endian10FromHost64Em:
  109|  2.67M|inline uint64_t FromHost64(uint64_t x) { return x; }
_ZN4absl12lts_2026052613little_endian7Store16EPvt:
  164|   612k|inline void Store16(void* absl_nonnull p, uint16_t v) {
  165|   612k|  ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
  ------------------
  |  |   81|   612k|  (absl::base_internal::UnalignedStore16(_p, _val))
  ------------------
  166|   612k|}
_ZN4absl12lts_2026052613little_endian6Load64EPKv:
  176|  93.5k|inline uint64_t Load64(const void* absl_nonnull p) {
  177|  93.5k|  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
  ------------------
  |  |   78|  93.5k|  (absl::base_internal::UnalignedLoad64(_p))
  ------------------
  178|  93.5k|}
_ZN4absl12lts_2026052613little_endian7Store64EPvm:
  180|  2.67M|inline void Store64(void* absl_nonnull p, uint64_t v) {
  181|  2.67M|  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
  ------------------
  |  |   85|  2.67M|  (absl::base_internal::UnalignedStore64(_p, _val))
  ------------------
  182|  2.67M|}

_ZN4absl12lts_2026052613base_internal10ErrnoSaverC2Ev:
   31|   612k|  ErrnoSaver() : saved_errno_(errno) {}
_ZN4absl12lts_2026052613base_internal10ErrnoSaverD2Ev:
   32|   612k|  ~ErrnoSaver() { errno = saved_errno_; }

_ZN4absl12lts_2026052613base_internal17HardeningAssertGEImEEvT_S3_:
   78|  30.2M|constexpr void HardeningAssertGE(T val1, T val2) {
   79|  30.2M|  ABSL_ASSERT(val1 >= val2);
  ------------------
  |  |  127|  30.2M|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|  30.2M|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 30.2M]
  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   80|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
   81|       |  if (!ABSL_PREDICT_TRUE(val1 >= val2)) {
   82|       |    base_internal::HardeningAbort();
   83|       |  }
   84|       |#endif
   85|  30.2M|}

_ZN4absl12lts_2026052613base_internal13LowLevelAlloc12DefaultArenaEv:
  305|      2|LowLevelAlloc::Arena *LowLevelAlloc::DefaultArena() {
  306|      2|  base_internal::LowLevelCallOnce(&create_globals_once, CreateGlobalArenas);
  307|      2|  return reinterpret_cast<LowLevelAlloc::Arena *>(&default_arena_storage);
  308|      2|}
_ZN4absl12lts_2026052613base_internal13LowLevelAlloc5ArenaC2Ej:
  386|      3|    : mu(base_internal::SCHEDULE_KERNEL_ONLY),
  387|      3|      allocation_count(0),
  388|      3|      flags(flags_value),
  389|      3|      pagesize(GetPageSize()),
  390|      3|      round_up(RoundedUpBlockSize()),
  391|      3|      min_size(2 * round_up),
  392|      3|      random(0) {
  393|      3|  freelist.header.size = 0;
  394|      3|  freelist.header.magic = Magic(kMagicUnallocated, &freelist.header);
  395|      3|  freelist.header.arena = this;
  396|      3|  freelist.levels = 0;
  397|      3|  memset(freelist.next, 0, sizeof(freelist.next));
  398|      3|}
_ZN4absl12lts_2026052613base_internal13LowLevelAlloc5AllocEm:
  652|      2|void *LowLevelAlloc::Alloc(size_t request) {
  653|      2|  void *result = DoAllocWithArena(request, DefaultArena());
  654|      2|  return result;
  655|      2|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internal12_GLOBAL__N_118CreateGlobalArenasEv:
  275|      1|void CreateGlobalArenas() {
  276|      1|  new (&default_arena_storage)
  277|      1|      LowLevelAlloc::Arena(LowLevelAlloc::kCallMallocHook);
  278|      1|  new (&unhooked_arena_storage) LowLevelAlloc::Arena(0);
  279|      1|#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
  280|      1|  new (&unhooked_async_sig_safe_arena_storage)
  281|      1|      LowLevelAlloc::Arena(LowLevelAlloc::kAsyncSignalSafe);
  282|      1|#endif
  283|      1|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internal12_GLOBAL__N_111GetPageSizeEv:
  362|      3|size_t GetPageSize() {
  363|       |#ifdef _WIN32
  364|       |  SYSTEM_INFO system_info;
  365|       |  GetSystemInfo(&system_info);
  366|       |  return std::max(system_info.dwPageSize, system_info.dwAllocationGranularity);
  367|       |#elif defined(__wasm__) || defined(__asmjs__) || defined(__hexagon__)
  368|       |  return static_cast<size_t>(getpagesize());
  369|       |#else
  370|       |  return static_cast<size_t>(sysconf(_SC_PAGESIZE));
  371|      3|#endif
  372|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internal12_GLOBAL__N_118RoundedUpBlockSizeEv:
  374|      3|size_t RoundedUpBlockSize() {
  375|       |  // Round up block sizes to a power of two close to the header size.
  376|      3|  size_t round_up = 16;
  377|      6|  while (round_up < sizeof(AllocList::Header)) {
  ------------------
  |  Branch (377:10): [True: 3, False: 3]
  ------------------
  378|      3|    round_up += round_up;
  379|      3|  }
  380|      3|  return round_up;
  381|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL5MagicEmPNS1_12_GLOBAL__N_19AllocList6HeaderE:
  357|     16|inline static uintptr_t Magic(uintptr_t magic, AllocList::Header *ptr) {
  358|     16|  return magic ^ reinterpret_cast<uintptr_t>(ptr);
  359|     16|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internal12_GLOBAL__N_19ArenaLockC2EPNS1_13LowLevelAlloc5ArenaE:
  319|      2|      : arena_(arena) {
  320|      2|#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
  321|      2|    if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
  ------------------
  |  Branch (321:9): [True: 0, False: 2]
  ------------------
  322|      0|      sigset_t all;
  323|      0|      sigfillset(&all);
  324|       |      mask_valid_ = pthread_sigmask(SIG_BLOCK, &all, &mask_) == 0;
  325|      0|    }
  326|      2|#endif
  327|      2|    arena_->mu.lock();
  328|      2|  }
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internal12_GLOBAL__N_19ArenaLock5LeaveEv:
  330|      2|  void Leave() ABSL_UNLOCK_FUNCTION() {
  331|      2|    arena_->mu.unlock();
  332|      2|#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
  333|      2|    if (mask_valid_) {
  ------------------
  |  Branch (333:9): [True: 0, False: 2]
  ------------------
  334|      0|      const int err = pthread_sigmask(SIG_SETMASK, &mask_, nullptr);
  335|      0|      if (err != 0) {
  ------------------
  |  Branch (335:11): [True: 0, False: 0]
  ------------------
  336|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  337|      0|      }
  338|      0|    }
  339|      2|#endif
  340|      2|    left_ = true;
  341|      2|  }
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internal12_GLOBAL__N_19ArenaLockD2Ev:
  329|      2|  ~ArenaLock() { ABSL_RAW_CHECK(left_, "haven't left Arena region"); }
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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_2026052613base_internalL13AddToFreelistEPvPNS1_13LowLevelAlloc5ArenaE:
  526|      3|    ABSL_EXCLUSIVE_LOCKS_REQUIRED(arena->mu) {
  527|      3|  AllocList *f = reinterpret_cast<AllocList *>(reinterpret_cast<char *>(v) -
  528|      3|                                               sizeof(f->header));
  529|      3|  ABSL_RAW_CHECK(f->header.magic == Magic(kMagicAllocated, &f->header),
  ------------------
  |  |   60|      3|  do {                                                                 \
  |  |   61|      3|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      3|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 3]
  |  |  |  |  |  Branch (190:49): [Folded, False: 3]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
  530|      3|                 "bad magic number in AddToFreelist()");
  531|      3|  ABSL_RAW_CHECK(f->header.arena == arena,
  ------------------
  |  |   60|      3|  do {                                                                 \
  |  |   61|      3|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      3|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 3]
  |  |  |  |  |  Branch (190:49): [Folded, False: 3]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
  532|      3|                 "bad arena pointer in AddToFreelist()");
  533|      3|  f->levels =
  534|      3|      LLA_SkiplistLevels(f->header.size, arena->min_size, &arena->random);
  535|      3|  AllocList *prev[kMaxLevel];
  536|      3|  LLA_SkiplistInsert(&arena->freelist, f, prev);
  537|      3|  f->header.magic = Magic(kMagicUnallocated, &f->header);
  538|      3|  Coalesce(f);        // maybe coalesce with successor
  539|      3|  Coalesce(prev[0]);  // maybe coalesce with predecessor
  540|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL18LLA_SkiplistLevelsEmmPj:
  149|      6|static int LLA_SkiplistLevels(size_t size, size_t base, uint32_t *random) {
  150|       |  // max_fit is the maximum number of levels that will fit in a node for the
  151|       |  // given size.   We can't return more than max_fit, no matter what the
  152|       |  // random number generator says.
  153|      6|  size_t max_fit = (size - offsetof(AllocList, next)) / sizeof(AllocList *);
  154|      6|  int level = IntLog2(size, base) + (random != nullptr ? Random(random) : 1);
  ------------------
  |  Branch (154:38): [True: 3, False: 3]
  ------------------
  155|      6|  if (static_cast<size_t>(level) > max_fit) level = static_cast<int>(max_fit);
  ------------------
  |  Branch (155:7): [True: 0, False: 6]
  ------------------
  156|      6|  if (level > kMaxLevel - 1) level = kMaxLevel - 1;
  ------------------
  |  Branch (156:7): [True: 0, False: 6]
  ------------------
  157|      6|  ABSL_RAW_CHECK(level >= 1, "block not big enough for even one level");
  ------------------
  |  |   60|      6|  do {                                                                 \
  |  |   61|      6|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      6|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 6]
  |  |  |  |  |  Branch (190:49): [Folded, False: 6]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
  158|      6|  return level;
  159|      6|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL7IntLog2Emm:
  119|      6|static int IntLog2(size_t size, size_t base) {
  120|      6|  int result = 0;
  121|     48|  for (size_t i = size; i > base; i >>= 1) {  // i == floor(size/2**result)
  ------------------
  |  Branch (121:25): [True: 42, False: 6]
  ------------------
  122|     42|    result++;
  123|     42|  }
  124|       |  //    floor(size / 2**result) <= base < floor(size / 2**(result-1))
  125|       |  // =>     log2(size/(base+1)) <= result < 1+log2(size/base)
  126|       |  // => result ~= log2(size/base)
  127|      6|  return result;
  128|      6|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL6RandomEPj:
  131|      3|static int Random(uint32_t *state) {
  132|      3|  uint32_t r = *state;
  133|      3|  int result = 1;
  134|      6|  while ((((r = r * 1103515245 + 12345) >> 30) & 1) == 0) {
  ------------------
  |  Branch (134:10): [True: 3, False: 3]
  ------------------
  135|      3|    result++;
  136|      3|  }
  137|      3|  *state = r;
  138|      3|  return result;
  139|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL18LLA_SkiplistInsertEPNS1_12_GLOBAL__N_19AllocListES4_PS4_:
  180|      3|                               AllocList **prev) {
  181|      3|  LLA_SkiplistSearch(head, e, prev);
  182|     39|  for (; head->levels < e->levels; head->levels++) {  // extend prev pointers
  ------------------
  |  Branch (182:10): [True: 36, False: 3]
  ------------------
  183|     36|    prev[head->levels] = head;                        // to all *e's levels
  184|     36|  }
  185|     39|  for (int i = 0; i != e->levels; i++) {  // add element to list
  ------------------
  |  Branch (185:19): [True: 36, False: 3]
  ------------------
  186|     36|    e->next[i] = prev[i]->next[i];
  187|     36|    prev[i]->next[i] = e;
  188|     36|  }
  189|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL18LLA_SkiplistSearchEPNS1_12_GLOBAL__N_19AllocListES4_PS4_:
  166|      5|                                     AllocList **prev) {
  167|      5|  AllocList *p = head;
  168|     29|  for (int level = head->levels - 1; level >= 0; level--) {
  ------------------
  |  Branch (168:38): [True: 24, False: 5]
  ------------------
  169|     24|    for (AllocList *n; (n = p->next[level]) != nullptr && n < e; p = n) {
  ------------------
  |  Branch (169:24): [True: 24, False: 0]
  |  Branch (169:59): [True: 0, False: 24]
  ------------------
  170|      0|    }
  171|     24|    prev[level] = p;
  172|     24|  }
  173|      5|  return (head->levels == 0) ? nullptr : prev[0]->next[0];
  ------------------
  |  Branch (173:10): [True: 3, False: 2]
  ------------------
  174|      5|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL8CoalesceEPNS1_12_GLOBAL__N_19AllocListE:
  506|      6|static void Coalesce(AllocList *a) {
  507|      6|  AllocList *n = a->next[0];
  508|      6|  if (n != nullptr && reinterpret_cast<char *>(a) + a->header.size ==
  ------------------
  |  Branch (508:7): [True: 3, False: 3]
  |  Branch (508:23): [True: 0, False: 3]
  ------------------
  509|      3|                          reinterpret_cast<char *>(n)) {
  510|      0|    LowLevelAlloc::Arena *arena = a->header.arena;
  511|      0|    arena->mu.AssertHeld();
  512|      0|    a->header.size += n->header.size;
  513|      0|    n->header.magic = 0;
  514|      0|    n->header.arena = nullptr;
  515|      0|    AllocList *prev[kMaxLevel];
  516|      0|    LLA_SkiplistDelete(&arena->freelist, n, prev);
  517|      0|    LLA_SkiplistDelete(&arena->freelist, a, prev);
  518|      0|    a->levels =
  519|      0|        LLA_SkiplistLevels(a->header.size, arena->min_size, &arena->random);
  520|      0|    LLA_SkiplistInsert(&arena->freelist, a, prev);
  521|      0|  }
  522|      6|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL18LLA_SkiplistDeleteEPNS1_12_GLOBAL__N_19AllocListES4_PS4_:
  195|      2|                               AllocList **prev) {
  196|      2|  AllocList *found = LLA_SkiplistSearch(head, e, prev);
  197|      2|  ABSL_RAW_CHECK(e == found, "element not in freelist");
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
  198|     26|  for (int i = 0; i != e->levels && prev[i]->next[i] == e; i++) {
  ------------------
  |  Branch (198:19): [True: 24, False: 2]
  |  Branch (198:37): [True: 24, False: 0]
  ------------------
  199|     24|    prev[i]->next[i] = e->next[i];
  200|     24|  }
  201|     26|  while (head->levels > 0 && head->next[head->levels - 1] == nullptr) {
  ------------------
  |  Branch (201:10): [True: 24, False: 2]
  |  Branch (201:30): [True: 24, False: 0]
  ------------------
  202|     24|    head->levels--;  // reduce head->levels if level unused
  203|     24|  }
  204|      2|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL16DoAllocWithArenaEmPNS1_13LowLevelAlloc5ArenaE:
  559|      2|static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
  560|      2|  void *result = nullptr;
  561|      2|  if (request != 0) {
  ------------------
  |  Branch (561:7): [True: 2, False: 0]
  ------------------
  562|      2|    AllocList *s;  // will point to region that satisfies request
  563|      2|    ArenaLock section(arena);
  564|       |    // round up with header
  565|      2|    size_t req_rnd =
  566|      2|        RoundUp(CheckedAdd(request, sizeof(s->header)), arena->round_up);
  567|      3|    for (;;) {  // loop until we find a suitable region
  568|       |      // find the minimum levels that a block of this size must have
  569|      3|      int i = LLA_SkiplistLevels(req_rnd, arena->min_size, nullptr) - 1;
  570|      3|      if (i < arena->freelist.levels) {        // potential blocks exist
  ------------------
  |  Branch (570:11): [True: 2, False: 1]
  ------------------
  571|      2|        AllocList *before = &arena->freelist;  // predecessor of s
  572|      2|        while ((s = Next(i, before, arena)) != nullptr &&
  ------------------
  |  Branch (572:16): [True: 2, False: 0]
  ------------------
  573|      2|               s->header.size < req_rnd) {
  ------------------
  |  Branch (573:16): [True: 0, False: 2]
  ------------------
  574|      0|          before = s;
  575|      0|        }
  576|      2|        if (s != nullptr) {  // we found a region
  ------------------
  |  Branch (576:13): [True: 2, False: 0]
  ------------------
  577|      2|          break;
  578|      2|        }
  579|      2|      }
  580|       |      // we unlock before mmap() both because mmap() may call a callback hook,
  581|       |      // and because it may be slow.
  582|      1|      arena->mu.unlock();
  583|       |      // mmap generous 64K chunks to decrease
  584|       |      // the chances/impact of fragmentation:
  585|      1|      size_t new_pages_size = RoundUp(req_rnd, arena->pagesize * 16);
  586|      1|      void *new_pages;
  587|       |#ifdef _WIN32
  588|       |      new_pages = VirtualAlloc(nullptr, new_pages_size,
  589|       |                               MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
  590|       |      ABSL_RAW_CHECK(new_pages != nullptr, "VirtualAlloc failed");
  591|       |#else
  592|      1|#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
  593|      1|      if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
  ------------------
  |  Branch (593:11): [True: 0, False: 1]
  ------------------
  594|      0|        new_pages = base_internal::DirectMmap(nullptr, new_pages_size,
  595|      0|            PROT_WRITE|PROT_READ, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
  596|      1|      } else {
  597|      1|        new_pages = mmap(nullptr, new_pages_size, PROT_WRITE | PROT_READ,
  598|      1|                         MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
  599|      1|      }
  600|       |#else
  601|       |      new_pages = mmap(nullptr, new_pages_size, PROT_WRITE | PROT_READ,
  602|       |                       MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
  603|       |#endif  // ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
  604|      1|      if (new_pages == MAP_FAILED) {
  ------------------
  |  Branch (604:11): [True: 0, False: 1]
  ------------------
  605|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  606|      0|      }
  607|       |
  608|      1|#ifdef __linux__
  609|      1|#if defined(PR_SET_VMA) && defined(PR_SET_VMA_ANON_NAME)
  610|       |      // Attempt to name the allocated address range in /proc/$PID/smaps on
  611|       |      // Linux.
  612|       |      //
  613|       |      // This invocation of prctl() may fail if the Linux kernel was not
  614|       |      // configured with the CONFIG_ANON_VMA_NAME option.  This is OK since
  615|       |      // the naming of arenas is primarily a debugging aid.
  616|      1|      prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, new_pages, new_pages_size,
  ------------------
  |  |   51|      1|#define PR_SET_VMA 0x53564d41
  ------------------
                    prctl(PR_SET_VMA, PR_SET_VMA_ANON_NAME, new_pages, new_pages_size,
  ------------------
  |  |   54|      1|#define PR_SET_VMA_ANON_NAME 0
  ------------------
  617|      1|            "absl");
  618|      1|#endif
  619|      1|#endif  // __linux__
  620|      1|#endif  // _WIN32
  621|      1|      arena->mu.lock();
  622|      1|      s = reinterpret_cast<AllocList *>(new_pages);
  623|      1|      s->header.size = new_pages_size;
  624|       |      // Pretend the block is allocated; call AddToFreelist() to free it.
  625|      1|      s->header.magic = Magic(kMagicAllocated, &s->header);
  626|      1|      s->header.arena = arena;
  627|      1|      AddToFreelist(&s->levels, arena);  // insert new region into free list
  628|      1|    }
  629|      2|    AllocList *prev[kMaxLevel];
  630|      2|    LLA_SkiplistDelete(&arena->freelist, s, prev);  // remove from free list
  631|       |    // s points to the first free region that's big enough
  632|      2|    if (CheckedAdd(req_rnd, arena->min_size) <= s->header.size) {
  ------------------
  |  Branch (632:9): [True: 2, False: 0]
  ------------------
  633|       |      // big enough to split
  634|      2|      AllocList *n =
  635|      2|          reinterpret_cast<AllocList *>(req_rnd + reinterpret_cast<char *>(s));
  636|      2|      n->header.size = s->header.size - req_rnd;
  637|      2|      n->header.magic = Magic(kMagicAllocated, &n->header);
  638|      2|      n->header.arena = arena;
  639|      2|      s->header.size = req_rnd;
  640|      2|      AddToFreelist(&n->levels, arena);
  641|      2|    }
  642|      2|    s->header.magic = Magic(kMagicAllocated, &s->header);
  643|      2|    ABSL_RAW_CHECK(s->header.arena == arena, "");
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
  644|      2|    arena->allocation_count++;
  645|      2|    section.Leave();
  646|      2|    result = &s->levels;
  647|      2|  }
  648|      2|  ABSL_ANNOTATE_MEMORY_IS_UNINITIALIZED(result, request);
  649|      2|  return result;
  650|      2|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL7RoundUpEmm:
  478|      3|static inline uintptr_t RoundUp(uintptr_t addr, uintptr_t align) {
  479|      3|  return CheckedAdd(addr, align - 1) & ~(align - 1);
  480|      3|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL10CheckedAddEmm:
  470|      7|static inline uintptr_t CheckedAdd(uintptr_t a, uintptr_t b) {
  471|      7|  uintptr_t sum = a + b;
  472|      7|  ABSL_RAW_CHECK(sum >= a, "LowLevelAlloc arithmetic overflow");
  ------------------
  |  |   60|      7|  do {                                                                 \
  |  |   61|      7|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      7|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 7]
  |  |  |  |  |  Branch (190:49): [Folded, False: 7]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
  473|      7|  return sum;
  474|      7|}
low_level_alloc.cc:_ZN4absl12lts_2026052613base_internalL4NextEiPNS1_12_GLOBAL__N_19AllocListEPNS1_13LowLevelAlloc5ArenaE:
  487|      2|    ABSL_EXCLUSIVE_LOCKS_REQUIRED(arena->mu) {
  488|      2|  ABSL_RAW_CHECK(i < prev->levels, "too few levels in Next()");
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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|  AllocList *next = prev->next[i];
  490|      2|  if (next != nullptr) {
  ------------------
  |  Branch (490:7): [True: 2, False: 0]
  ------------------
  491|      2|    ABSL_RAW_CHECK(
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
  492|      2|        next->header.magic == Magic(kMagicUnallocated, &next->header),
  493|      2|        "bad magic number in Next()");
  494|      2|    ABSL_RAW_CHECK(next->header.arena == arena, "bad arena pointer in Next()");
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
  495|      2|    if (prev != &arena->freelist) {
  ------------------
  |  Branch (495:9): [True: 0, False: 2]
  ------------------
  496|      0|      ABSL_RAW_CHECK(prev < next, "unordered freelist");
  ------------------
  |  |   60|      0|  do {                                                                 \
  |  |   61|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
  497|      0|      ABSL_RAW_CHECK(reinterpret_cast<char *>(prev) + prev->header.size <
  ------------------
  |  |   60|      0|  do {                                                                 \
  |  |   61|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
  498|      0|                         reinterpret_cast<char *>(next),
  499|      0|                     "malformed freelist");
  500|      0|    }
  501|      2|  }
  502|      2|  return next;
  503|      2|}

_ZN4absl12lts_2026052613base_internal15SchedulingGuard13ScopedDisableC2Ev:
   85|     37|    ScopedDisable() { disabled = SchedulingGuard::DisableRescheduling(); }
_ZN4absl12lts_2026052613base_internal15SchedulingGuard13ScopedDisableD2Ev:
   86|     37|    ~ScopedDisable() { SchedulingGuard::EnableRescheduling(disabled); }
_ZN4absl12lts_2026052613base_internal15SchedulingGuard19DisableReschedulingEv:
  126|     71|inline bool SchedulingGuard::DisableRescheduling() {
  127|     71|  ThreadIdentity* identity;
  128|     71|  identity = CurrentThreadIdentityIfPresent();
  129|     71|  if (identity != nullptr) {
  ------------------
  |  Branch (129:7): [True: 39, False: 32]
  ------------------
  130|       |    // The depth is accessed concurrently from other threads, so it must be
  131|       |    // atomic, but it's only mutated from this thread, so we don't need an
  132|       |    // atomic increment.
  133|     39|    int old_val = identity->scheduler_state.scheduling_disabled_depth.load(
  134|     39|        std::memory_order_relaxed);
  135|     39|    identity->scheduler_state.scheduling_disabled_depth.store(
  136|     39|        old_val + 1, std::memory_order_relaxed);
  137|     39|    return true;
  138|     39|  } else {
  139|     32|    return false;
  140|     32|  }
  141|     71|}
_ZN4absl12lts_2026052613base_internal15SchedulingGuard18EnableReschedulingEb:
  143|     41|inline void SchedulingGuard::EnableRescheduling(bool disable_result) {
  144|     41|  if (!disable_result) {
  ------------------
  |  Branch (144:7): [True: 2, False: 39]
  ------------------
  145|       |    // There was no installed thread identity at the time that scheduling was
  146|       |    // disabled, so we have nothing to do.  This is an implementation detail
  147|       |    // that may change in the future, clients may not depend on it.
  148|       |    // EnableRescheduling() must always be called.
  149|      2|    return;
  150|      2|  }
  151|       |
  152|     39|  ThreadIdentity* identity;
  153|       |  // A thread identity exists, see above
  154|     39|  identity = CurrentThreadIdentityIfPresent();
  155|       |  // The depth is accessed concurrently from other threads, so it must be
  156|       |  // atomic, but it's only mutated from this thread, so we don't need an atomic
  157|       |  // decrement.
  158|     39|  int old_val = identity->scheduler_state.scheduling_disabled_depth.load(
  159|     39|      std::memory_order_relaxed);
  160|     39|  identity->scheduler_state.scheduling_disabled_depth.store(
  161|     39|      old_val - 1, std::memory_order_relaxed);
  162|     39|}
_ZN4absl12lts_2026052613base_internal15SchedulingGuard12ScopedEnableC2Ev:
  164|     84|inline SchedulingGuard::ScopedEnable::ScopedEnable() {
  165|     84|  ThreadIdentity* identity;
  166|     84|  identity = CurrentThreadIdentityIfPresent();
  167|     84|  if (identity != nullptr) {
  ------------------
  |  Branch (167:7): [True: 84, False: 0]
  ------------------
  168|     84|    scheduling_disabled_depth_ =
  169|     84|        identity->scheduler_state.scheduling_disabled_depth.load(
  170|     84|            std::memory_order_relaxed);
  171|     84|    if (scheduling_disabled_depth_ != 0) {
  ------------------
  |  Branch (171:9): [True: 84, False: 0]
  ------------------
  172|       |      // The store below does not need to be compare_exchange because
  173|       |      // the value is never modified concurrently (only accessed).
  174|     84|      identity->scheduler_state.scheduling_disabled_depth.store(
  175|     84|          0, std::memory_order_relaxed);
  176|     84|    }
  177|     84|  } else {
  178|      0|    scheduling_disabled_depth_ = 0;
  179|      0|  }
  180|     84|}
_ZN4absl12lts_2026052613base_internal15SchedulingGuard12ScopedEnableD2Ev:
  182|     84|inline SchedulingGuard::ScopedEnable::~ScopedEnable() {
  183|     84|  if (scheduling_disabled_depth_ == 0) {
  ------------------
  |  Branch (183:7): [True: 0, False: 84]
  ------------------
  184|      0|    return;
  185|      0|  }
  186|     84|  ThreadIdentity* identity = CurrentThreadIdentityIfPresent();
  187|       |  // itentity is guaranteed to exist, see the constructor above.
  188|     84|  identity->scheduler_state.scheduling_disabled_depth.store(
  189|     84|      scheduling_disabled_depth_, std::memory_order_relaxed);
  190|     84|}

_ZN4absl12lts_2026052613base_internal8SpinLockC2Ev:
   62|      8|  constexpr SpinLock() : lockword_(kSpinLockCooperative) { RegisterWithTsan(); }
_ZN4absl12lts_2026052613base_internal8SpinLock16RegisterWithTsanEv:
  221|     13|  constexpr void RegisterWithTsan() {
  222|     13|#if ABSL_HAVE_BUILTIN(__builtin_is_constant_evaluated)
  223|     13|    if (!__builtin_is_constant_evaluated()) {
  ------------------
  |  Branch (223:9): [True: 13, Folded]
  ------------------
  224|     13|      ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
  225|     13|    }
  226|     13|#endif
  227|     13|  }
_ZN4absl12lts_2026052613base_internal14SpinLockHolderC2ERNS1_8SpinLockE:
  257|  8.57k|      : std::lock_guard<SpinLock>(l) {}
_ZN4absl12lts_2026052613base_internal8SpinLock4lockEv:
   98|  8.57k|  inline void lock() ABSL_EXCLUSIVE_LOCK_FUNCTION() {
   99|  8.57k|    ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
  100|  8.57k|    if (!TryLockImpl()) {
  ------------------
  |  Branch (100:9): [True: 0, False: 8.57k]
  ------------------
  101|      0|      SlowLock();
  102|      0|    }
  103|  8.57k|    ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
  104|  8.57k|  }
_ZN4absl12lts_2026052613base_internal8SpinLock11TryLockImplEv:
  238|  8.57k|  inline bool TryLockImpl() {
  239|  8.57k|    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
  240|  8.57k|    return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0;
  241|  8.57k|  }
_ZN4absl12lts_2026052613base_internal8SpinLock15TryLockInternalEjj:
  282|  8.57k|                                          uint32_t wait_cycles) {
  283|  8.57k|  if ((lock_value & kSpinLockHeld) != 0) {
  ------------------
  |  Branch (283:7): [True: 0, False: 8.57k]
  ------------------
  284|      0|    return lock_value;
  285|      0|  }
  286|       |
  287|  8.57k|  uint32_t sched_disabled_bit = 0;
  288|  8.57k|  if ((lock_value & kSpinLockCooperative) == 0) {
  ------------------
  |  Branch (288:7): [True: 30, False: 8.54k]
  ------------------
  289|       |    // For non-cooperative locks we must make sure we mark ourselves as
  290|       |    // non-reschedulable before we attempt to CompareAndSwap.
  291|     30|    if (SchedulingGuard::DisableRescheduling()) {
  ------------------
  |  Branch (291:9): [True: 0, False: 30]
  ------------------
  292|      0|      sched_disabled_bit = kSpinLockDisabledScheduling;
  293|      0|    }
  294|     30|  }
  295|       |
  296|  8.57k|  if (!lockword_.compare_exchange_strong(
  ------------------
  |  Branch (296:7): [True: 0, False: 8.57k]
  ------------------
  297|  8.57k|          lock_value,
  298|  8.57k|          kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
  299|  8.57k|          std::memory_order_acquire, std::memory_order_relaxed)) {
  300|      0|    SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
  301|      0|  }
  302|       |
  303|  8.57k|  return lock_value;
  304|  8.57k|}
_ZN4absl12lts_2026052613base_internal8SpinLock6unlockEv:
  128|  8.57k|  inline void unlock() ABSL_UNLOCK_FUNCTION() {
  129|  8.57k|    ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
  130|  8.57k|    uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
  131|  8.57k|    lock_value = lockword_.exchange(lock_value & kSpinLockCooperative,
  132|  8.57k|                                    std::memory_order_release);
  133|       |
  134|  8.57k|    if ((lock_value & kSpinLockDisabledScheduling) != 0) {
  ------------------
  |  Branch (134:9): [True: 0, False: 8.57k]
  ------------------
  135|      0|      SchedulingGuard::EnableRescheduling(true);
  136|      0|    }
  137|  8.57k|    if ((lock_value & kWaitTimeMask) != 0) {
  ------------------
  |  Branch (137:9): [True: 0, False: 8.57k]
  ------------------
  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|  8.57k|    ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
  144|  8.57k|  }
_ZN4absl12lts_2026052613base_internal8SpinLockC2ENS1_14SchedulingModeE:
   67|      5|      : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {
  ------------------
  |  Branch (67:19): [True: 0, False: 5]
  ------------------
   68|      5|    RegisterWithTsan();
   69|      5|  }
_ZN4absl12lts_2026052613base_internal8SpinLock13IsCooperativeENS1_14SchedulingModeE:
  217|      5|  static constexpr bool IsCooperative(SchedulingMode scheduling_mode) {
  218|      5|    return scheduling_mode == SCHEDULE_COOPERATIVE_AND_KERNEL;
  219|      5|  }

_ZN4absl12lts_2026052613base_internal7NumCPUsEv:
  368|      2|int NumCPUs() {
  369|      2|  base_internal::LowLevelCallOnce(
  370|      2|      &init_num_cpus_once, []() { num_cpus = GetNumCPUs(); });
  371|      2|  return num_cpus;
  372|      2|}
_ZN4absl12lts_2026052613base_internal19NominalCPUFrequencyEv:
  380|     12|double NominalCPUFrequency() {
  381|     12|  base_internal::LowLevelCallOnce(
  382|     12|      &init_nominal_cpu_frequency_once,
  383|     12|      []() { nominal_cpu_frequency = GetNominalCPUFrequency(); });
  384|     12|  return nominal_cpu_frequency;
  385|     12|}
_ZN4absl12lts_2026052613base_internal6GetTIDEv:
  399|      1|pid_t GetTID() {
  400|       |  return static_cast<pid_t>(syscall(SYS_gettid));
  401|      1|}
_ZN4absl12lts_2026052613base_internal12GetCachedTIDEv:
  482|   612k|pid_t GetCachedTID() {
  483|   612k|#ifdef ABSL_HAVE_THREAD_LOCAL
  484|   612k|  static thread_local pid_t thread_id = GetTID();
  485|   612k|  return thread_id;
  486|       |#else
  487|       |  return GetTID();
  488|       |#endif  // ABSL_HAVE_THREAD_LOCAL
  489|   612k|}
sysinfo.cc:_ZZN4absl12lts_2026052613base_internal7NumCPUsEvENK3$_0clEv:
  370|      1|      &init_num_cpus_once, []() { num_cpus = GetNumCPUs(); });
sysinfo.cc:_ZN4absl12lts_2026052613base_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_2026052613base_internal19NominalCPUFrequencyEvENK3$_0clEv:
  383|      1|      []() { nominal_cpu_frequency = GetNominalCPUFrequency(); });
sysinfo.cc:_ZN4absl12lts_2026052613base_internalL22GetNominalCPUFrequencyEv:
  320|      1|static double GetNominalCPUFrequency() {
  321|      1|  long freq = 0;
  322|       |
  323|       |  // Google's production kernel has a patch to export the TSC
  324|       |  // frequency through sysfs. If the kernel is exporting the TSC
  325|       |  // frequency use that. There are issues where cpuinfo_max_freq
  326|       |  // cannot be relied on because the BIOS may be exporting an invalid
  327|       |  // p-state (on x86) or p-states may be used to put the processor in
  328|       |  // a new mode (turbo mode). Essentially, those frequencies cannot
  329|       |  // always be relied upon. The same reasons apply to /proc/cpuinfo as
  330|       |  // well.
  331|      1|  if (ReadLongFromFile("/sys/devices/system/cpu/cpu0/tsc_freq_khz", &freq)) {
  ------------------
  |  Branch (331:7): [True: 0, False: 1]
  ------------------
  332|      0|    return freq * 1e3;  // Value is kHz.
  333|      0|  }
  334|       |
  335|      1|#if defined(ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY)
  336|       |  // On these platforms, the TSC frequency is the nominal CPU
  337|       |  // frequency.  But without having the kernel export it directly
  338|       |  // though /sys/devices/system/cpu/cpu0/tsc_freq_khz, there is no
  339|       |  // other way to reliably get the TSC frequency, so we have to
  340|       |  // measure it ourselves.  Some CPUs abuse cpuinfo_max_freq by
  341|       |  // exporting "fake" frequencies for implementing new features. For
  342|       |  // example, Intel's turbo mode is enabled by exposing a p-state
  343|       |  // value with a higher frequency than that of the real TSC
  344|       |  // rate. Because of this, we prefer to measure the TSC rate
  345|       |  // ourselves on i386 and x86-64.
  346|      1|  return MeasureTscFrequency();
  347|       |#else
  348|       |
  349|       |  // If CPU scaling is in effect, we want to use the *maximum*
  350|       |  // frequency, not whatever CPU speed some random processor happens
  351|       |  // to be using now.
  352|       |  if (ReadLongFromFile("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq",
  353|       |                       &freq)) {
  354|       |    return freq * 1e3;  // Value is kHz.
  355|       |  }
  356|       |
  357|       |  return 1.0;
  358|       |#endif  // !ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
  359|      1|}
sysinfo.cc:_ZN4absl12lts_2026052613base_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_2026052613base_internalL19MeasureTscFrequencyEv:
  301|      1|static double MeasureTscFrequency() {
  302|      1|  double last_measurement = -1.0;
  303|      1|  int sleep_nanoseconds = 1000000;  // 1 millisecond.
  304|      2|  for (int i = 0; i < 8; ++i) {
  ------------------
  |  Branch (304:19): [True: 2, False: 0]
  ------------------
  305|      2|    double measurement = MeasureTscFrequencyWithSleep(sleep_nanoseconds);
  306|      2|    if (measurement * 0.99 < last_measurement &&
  ------------------
  |  Branch (306:9): [True: 1, False: 1]
  ------------------
  307|      1|        last_measurement < measurement * 1.01) {
  ------------------
  |  Branch (307:9): [True: 1, False: 0]
  ------------------
  308|       |      // Use the current measurement if it is within 1% of the
  309|       |      // previous measurement.
  310|      1|      return measurement;
  311|      1|    }
  312|      1|    last_measurement = measurement;
  313|      1|    sleep_nanoseconds *= 2;
  314|      1|  }
  315|      0|  return last_measurement;
  316|      1|}
sysinfo.cc:_ZN4absl12lts_2026052613base_internalL28MeasureTscFrequencyWithSleepEi:
  286|      2|static double MeasureTscFrequencyWithSleep(int sleep_nanoseconds) {
  287|      2|  auto t0 = GetTimeTscPair();
  288|      2|  struct timespec ts;
  289|      2|  ts.tv_sec = 0;
  290|      2|  ts.tv_nsec = sleep_nanoseconds;
  291|      2|  while (nanosleep(&ts, &ts) != 0 && errno == EINTR) {}
  ------------------
  |  Branch (291:10): [True: 0, False: 2]
  |  Branch (291:38): [True: 0, False: 0]
  ------------------
  292|      2|  auto t1 = GetTimeTscPair();
  293|      2|  double elapsed_ticks = t1.tsc - t0.tsc;
  294|      2|  double elapsed_time = (t1.time - t0.time) * 1e-9;
  295|      2|  return elapsed_ticks / elapsed_time;
  296|      2|}
sysinfo.cc:_ZN4absl12lts_2026052613base_internalL14GetTimeTscPairEv:
  267|      4|static TimeTscPair GetTimeTscPair() {
  268|      4|  int64_t best_latency = std::numeric_limits<int64_t>::max();
  269|      4|  TimeTscPair best;
  270|     44|  for (int i = 0; i < 10; ++i) {
  ------------------
  |  Branch (270:19): [True: 40, False: 4]
  ------------------
  271|     40|    int64_t t0 = ReadMonotonicClockNanos();
  272|     40|    int64_t tsc = UnscaledCycleClockWrapperForInitializeFrequency::Now();
  273|     40|    int64_t t1 = ReadMonotonicClockNanos();
  274|     40|    int64_t latency = t1 - t0;
  275|     40|    if (latency < best_latency) {
  ------------------
  |  Branch (275:9): [True: 11, False: 29]
  ------------------
  276|     11|      best_latency = latency;
  277|     11|      best.time = t0;
  278|     11|      best.tsc = tsc;
  279|     11|    }
  280|     40|  }
  281|      4|  return best;
  282|      4|}
sysinfo.cc:_ZN4absl12lts_2026052613base_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_RAW_LOG(FATAL, "clock_gettime() failed: (%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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  248|      0|  }
  249|     80|  return int64_t{t.tv_sec} * 1000000000 + t.tv_nsec;
  250|     80|}
_ZN4absl12lts_2026052613base_internal47UnscaledCycleClockWrapperForInitializeFrequency3NowEv:
  254|     40|  static int64_t Now() { return base_internal::UnscaledCycleClock::Now(); }

_ZN4absl12lts_2026052613base_internal24SetCurrentThreadIdentityEPNS1_14ThreadIdentityEPFvPvE:
   77|     14|                              ThreadIdentityReclaimerFunction reclaimer) {
   78|     14|  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|     14|#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
   83|       |  // NOTE: Not async-safe.  But can be open-coded.
   84|     14|  absl::call_once(init_thread_identity_key_once, AllocateThreadIdentityKey,
   85|     14|                  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|     14|  sigset_t all_signals;
  103|     14|  sigset_t curr_signals;
  104|     14|  sigfillset(&all_signals);
  105|     14|  pthread_sigmask(SIG_SETMASK, &all_signals, &curr_signals);
  106|     14|  pthread_setspecific(thread_identity_pthread_key,
  107|     14|                      reinterpret_cast<void*>(identity));
  108|     14|  pthread_sigmask(SIG_SETMASK, &curr_signals, nullptr);
  109|     14|#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|     14|}
_ZN4absl12lts_2026052613base_internal26ClearCurrentThreadIdentityEv:
  139|     13|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|     13|#endif
  148|     13|}
_ZN4absl12lts_2026052613base_internal30CurrentThreadIdentityIfPresentEv:
  151|    304|ThreadIdentity* CurrentThreadIdentityIfPresent() {
  152|    304|  bool initialized = pthread_key_initialized.load(std::memory_order_acquire);
  153|    304|  if (!initialized) {
  ------------------
  |  Branch (153:7): [True: 5, False: 299]
  ------------------
  154|      5|    return nullptr;
  155|      5|  }
  156|    299|  return reinterpret_cast<ThreadIdentity*>(
  157|    299|      pthread_getspecific(thread_identity_pthread_key));
  158|    304|}
thread_identity.cc:_ZN4absl12lts_2026052613base_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_2026052613base_internal14PerThreadSynch15thread_identityEv:
   61|     12|  ThreadIdentity* thread_identity() {
   62|     12|    return reinterpret_cast<ThreadIdentity*>(this);
   63|     12|  }

_ZN4absl12lts_2026052613base_internal16UnalignedStore16EPvt:
   57|   612k|inline void UnalignedStore16(void* absl_nonnull p, uint16_t v) {
   58|   612k|  memcpy(p, &v, sizeof v);
   59|   612k|}
_ZN4absl12lts_2026052613base_internal16UnalignedStore64EPvm:
   65|  2.67M|inline void UnalignedStore64(void* absl_nonnull p, uint64_t v) {
   66|  2.67M|  memcpy(p, &v, sizeof v);
   67|  2.67M|}

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

_ZN4absl12lts_2026052613base_internal18UnscaledCycleClock3NowEv:
   87|     79|inline int64_t UnscaledCycleClock::Now() {
   88|     79|  uint64_t low, high;
   89|     79|  __asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
   90|     79|  return static_cast<int64_t>((high << 32) | low);
   91|     79|}

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

log_sink_set.cc:_ZN4absl12lts_2026052612NoDestructorINS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSetEEC2IJETnNSt3__19enable_ifIXntsr3std7is_sameIFvDpRu7__decayIT_EEFvRS5_EEE5valueEiE4typeELi0EEEDpOS9_:
  122|      1|      : impl_(std::forward<Ts>(args)...) {}
log_sink_set.cc:_ZN4absl12lts_2026052612NoDestructorINS0_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_2026052612NoDestructorINS0_12log_internal12_GLOBAL__N_113StderrLogSinkEEC2IJETnNSt3__19enable_ifIXntsr3std7is_sameIFvDpRu7__decayIT_EEFvRS5_EEE5valueEiE4typeELi0EEEDpOS9_:
  122|      1|      : impl_(std::forward<Ts>(args)...) {}
log_sink_set.cc:_ZN4absl12lts_2026052612NoDestructorINS0_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_2026052612NoDestructorINS0_12log_internal12_GLOBAL__N_113StderrLogSinkEE3getEv:
  139|      1|  T* absl_nonnull get() { return impl_.get(); }
log_sink_set.cc:_ZN4absl12lts_2026052612NoDestructorINS0_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_2026052612NoDestructorINS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSetEEdeEv:
  137|   612k|  T& operator*() { return *get(); }
log_sink_set.cc:_ZN4absl12lts_2026052612NoDestructorINS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSetEE3getEv:
  139|   612k|  T* absl_nonnull get() { return impl_.get(); }
log_sink_set.cc:_ZN4absl12lts_2026052612NoDestructorINS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSetEE13PlacementImpl3getEv:
  166|   612k|    T* absl_nonnull get() {
  167|   612k|      return std::launder(reinterpret_cast<T*>(&space_));
  168|   612k|    }

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

log_sink_set.cc:_ZN4absl12lts_2026052616cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_EC2ESD_:
   50|   612k|  explicit Storage(Callback callback) {
   51|       |    // Placement-new into a character buffer is used for eager destruction when
   52|       |    // the cleanup is invoked or cancelled. To ensure this optimizes well, the
   53|       |    // behavior is implemented locally instead of using a std::optional.
   54|   612k|    ::new (GetCallbackBuffer()) Callback(std::move(callback));
   55|   612k|    is_callback_engaged_ = true;
   56|   612k|  }
log_sink_set.cc:_ZN4absl12lts_2026052616cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E17GetCallbackBufferEv:
   73|  1.83M|  void* GetCallbackBuffer() { return static_cast<void*>(callback_buffer_); }
log_sink_set.cc:_ZNK4absl12lts_2026052616cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E17IsCallbackEngagedEv:
   79|   612k|  bool IsCallbackEngaged() const { return is_callback_engaged_; }
log_sink_set.cc:_ZN4absl12lts_2026052616cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E14InvokeCallbackEv:
   86|   612k|  void InvokeCallback() ABSL_NO_THREAD_SAFETY_ANALYSIS {
   87|   612k|    std::move(GetCallback())();
   88|   612k|  }
log_sink_set.cc:_ZN4absl12lts_2026052616cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E11GetCallbackEv:
   75|  1.22M|  Callback& GetCallback() {
   76|  1.22M|    return *reinterpret_cast<Callback*>(GetCallbackBuffer());
   77|  1.22M|  }
log_sink_set.cc:_ZN4absl12lts_2026052616cleanup_internal7StorageIZNS0_12log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbEUlvE_E15DestroyCallbackEv:
   81|   612k|  void DestroyCallback() {
   82|   612k|    is_callback_engaged_ = false;
   83|   612k|    GetCallback().~Callback();
   84|   612k|  }

_ZN4absl12lts_2026052613InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS3_EEE4dataEv:
  348|   612k|  pointer data() noexcept ABSL_ATTRIBUTE_LIFETIME_BOUND {
  349|   612k|    return storage_.GetIsAllocated() ? storage_.GetAllocatedData()
  ------------------
  |  Branch (349:12): [True: 0, False: 612k]
  ------------------
  350|   612k|                                     : storage_.GetInlinedData();
  351|   612k|  }
_ZNK4absl12lts_2026052613InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS3_EEE4sizeEv:
  314|   612k|  size_type size() const noexcept { return storage_.GetSize(); }
_ZN4absl12lts_2026052613InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS3_EEEC2Ev:
  128|   612k|  InlinedVector() noexcept(noexcept(allocator_type())) : storage_() {}
_ZN4absl12lts_2026052613InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS3_EEED2Ev:
  300|   612k|  ~InlinedVector() {}
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEED2Ev:
  300|  4.24k|  ~InlinedVector() {}
_ZNK4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEE4dataEv:
  358|     11|  const_pointer data() const noexcept ABSL_ATTRIBUTE_LIFETIME_BOUND {
  359|     11|    return storage_.GetIsAllocated() ? storage_.GetAllocatedData()
  ------------------
  |  Branch (359:12): [True: 0, False: 11]
  ------------------
  360|     11|                                     : storage_.GetInlinedData();
  361|     11|  }
_ZNK4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEE4sizeEv:
  314|     11|  size_type size() const noexcept { return storage_.GetSize(); }
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEEC2Ev:
  128|  4.24k|  InlinedVector() noexcept(noexcept(allocator_type())) : storage_() {}
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEE9push_backERKS2_:
  753|  12.6k|  void push_back(const_reference v) { static_cast<void>(emplace_back(v)); }
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEE12emplace_backIJRKS2_EEERS2_DpOT_:
  746|  12.6k|  reference emplace_back(Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
  747|  12.6k|    return storage_.EmplaceBack(std::forward<Args>(args)...);
  748|  12.6k|  }
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEEaSERKS6_:
  535|     11|  InlinedVector& operator=(const InlinedVector& other) {
  536|     11|    if (ABSL_PREDICT_TRUE(this != std::addressof(other))) {
  ------------------
  |  |  191|     11|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 11, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 11]
  |  |  |  Branch (191:57): [True: 11, False: 0]
  |  |  ------------------
  ------------------
  537|     11|      const_pointer other_data = other.data();
  538|     11|      assign(other_data, other_data + other.size());
  539|     11|    }
  540|       |
  541|     11|    return *this;
  542|     11|  }
_ZN4absl12lts_2026052613InlinedVectorINS0_14SourceLocationELm1ENSt3__19allocatorIS2_EEE6assignIPKS2_TnNS3_9enable_ifIXsr13base_internal24IsAtLeastForwardIteratorIT_EE5valueEiE4typeELi0EEEvSB_SB_:
  576|     11|  void assign(ForwardIterator first, ForwardIterator last) {
  577|     11|    storage_.Assign(IteratorValueAdapter<A, ForwardIterator>(first),
  578|     11|                    static_cast<size_t>(std::distance(first, last)));
  579|     11|  }

_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorINS0_14SourceLocationEEEmEEELb0EE3getEv:
   92|  25.3k|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  244|  25.3k|  constexpr ElemT<I>& get() & {
  245|  25.3k|    return StorageT<I>::get();
  246|  25.3k|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorINS0_14SourceLocationEEEmEEELb0EE3getEv:
   91|  54.9k|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  249|  54.9k|  constexpr const ElemT<I>& get() const& {
  250|  54.9k|    return StorageT<I>::get();
  251|  54.9k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS0_14SourceLocationEEELm0ENS2_10StorageTagIJS7_mEEELb1EE3getEv:
  105|  46.4k|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS7_XT_EE4typeEv:
  244|  46.4k|  constexpr ElemT<I>& get() & {
  245|  46.4k|    return StorageT<I>::get();
  246|  46.4k|  }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorIPNS0_7LogSinkEEEmEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS8_XT_EE4typeEv:
  249|  1.22M|  constexpr const ElemT<I>& get() const& {
  250|  1.22M|    return StorageT<I>::get();
  251|  1.22M|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEELb0EE3getEv:
   91|  1.22M|  constexpr const T& get() const& { return value; }
_ZN4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEC2IS7_JjETnNS3_9enable_ifIXsr3std11conjunctionINS3_8negationINS3_7is_sameIFvS8_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS8_JSE_DpT0_EEEEE5valueEbE4typeELb1EEEOSE_DpOSL_:
  239|   612k|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|   612k|                                             std::forward<First>(first),
  241|   612k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEENS5_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJS9_jEEENS5_10in_place_tEDpOT_:
  126|  1.22M|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|  1.22M|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIPNS0_7LogSinkEEELm0ENS2_10StorageTagIJS8_mEEELb1EEC2IS8_EENS4_10in_place_tEOT_:
  102|   612k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEELb0EEC2IjEENS5_10in_place_tEOT_:
   90|   612k|      : value(std::forward<V>(v)) {}
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorIPNS0_7LogSinkEEEmEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS8_XT_EE4typeEv:
  244|   612k|  constexpr ElemT<I>& get() & {
  245|   612k|    return StorageT<I>::get();
  246|   612k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIPNS0_7LogSinkEEEmEEELb0EE3getEv:
   92|   612k|  constexpr T& get() & { return value; }
_ZN4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEEC2IS6_JjETnNS3_9enable_ifIXsr3std11conjunctionINS3_8negationINS3_7is_sameIFvS7_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS7_JSD_DpT0_EEEEE5valueEbE4typeELb1EEEOSD_DpOSK_:
  239|  4.24k|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|  4.24k|                                             std::forward<First>(first),
  241|  4.24k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEmEEENS5_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJS8_jEEENS5_10in_place_tEDpOT_:
  126|  8.49k|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|  8.49k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS0_14SourceLocationEEELm0ENS2_10StorageTagIJS7_mEEELb1EEC2IS7_EENS4_10in_place_tEOT_:
  102|  4.24k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorINS0_14SourceLocationEEEmEEELb0EEC2IjEENS5_10in_place_tEOT_:
   90|  4.24k|      : value(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEPS5_EEC2IRS6_JDnETnNS3_9enable_ifIXsr3std11conjunctionINS3_8negationINS3_7is_sameIFvS8_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS8_JSF_DpT0_EEEEE5valueEbE4typeELb1EEEOSF_DpOSM_:
  239|  8.44k|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|  8.44k|                                             std::forward<First>(first),
  241|  8.44k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEPS7_EEENS5_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJRS8_DnEEENS5_10in_place_tEDpOT_:
  126|  16.8k|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|  16.8k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS0_14SourceLocationEEELm0ENS2_10StorageTagIJS7_PS6_EEELb1EEC2IRS7_EENS4_10in_place_tEOT_:
  102|  8.44k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageIPNS0_14SourceLocationELm1ENS2_10StorageTagIJNSt3__19allocatorIS4_EES5_EEELb0EEC2IDnEENS7_10in_place_tEOT_:
   90|  8.44k|      : value(std::forward<V>(v)) {}
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEPS5_EE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS8_XT_EE4typeEv:
  244|  8.43k|  constexpr ElemT<I>& get() & {
  245|  8.43k|    return StorageT<I>::get();
  246|  8.43k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorINS0_14SourceLocationEEELm0ENS2_10StorageTagIJS7_PS6_EEELb1EE3getEv:
  105|  8.43k|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorINS0_14SourceLocationEEEPS5_EE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS8_XT_EE4typeEv:
  244|  42.2k|  constexpr ElemT<I>& get() & {
  245|  42.2k|    return StorageT<I>::get();
  246|  42.2k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageIPNS0_14SourceLocationELm1ENS2_10StorageTagIJNSt3__19allocatorIS4_EES5_EEELb0EE3getEv:
   92|  42.2k|  constexpr T& get() & { return value; }

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

_ZNK4absl12lts_2026052618container_internal13GroupSse2Impl18MaskEmptyOrDeletedEv:
  316|   120k|  NonIterableBitMaskType MaskEmptyOrDeleted() const {
  317|   120k|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  318|   120k|    return NonIterableBitMaskType(
  319|   120k|        MoveMask(_mm_cmpgt_epi8_fixed(special, ctrl)));
  320|   120k|  }
_ZNK4absl12lts_2026052618container_internal13GroupSse2Impl37ConvertSpecialToEmptyAndFullToDeletedEPNS1_6ctrl_tE:
  331|     50|  void ConvertSpecialToEmptyAndFullToDeleted(ctrl_t* dst) const {
  332|       |    // Take advantage of the fact that kEmpty is already the smallest signed
  333|       |    // char value, and using a saturated subtraction will not affect it.
  334|       |    // All special values have the MSB set, so after an AND with MSBS, we
  335|       |    // are left with -128 for special values and 0 for full. After applying
  336|       |    // subs 2, we arrive at the result of -128(kEmpty) for special and
  337|       |    // -2(kDeleted) for full.
  338|     50|    auto msbs = _mm_set1_epi8(static_cast<char>(-128));
  339|     50|    auto twos = _mm_set1_epi8(static_cast<char>(2));
  340|     50|    auto res = _mm_subs_epi8(_mm_and_si128(msbs, ctrl), twos);
  341|     50|    _mm_storeu_si128(reinterpret_cast<__m128i*>(dst), res);
  342|     50|  }
_ZN4absl12lts_2026052618container_internal17GroupPortableImplC2EPKNS1_6ctrl_tE:
  447|  8.88k|      : ctrl(little_endian::Load64(pos)) {}
_ZNK4absl12lts_2026052618container_internal17GroupPortableImpl8MaskFullEv:
  475|  8.88k|  auto MaskFull() const {
  476|  8.88k|    return BitMaskType((ctrl ^ kMsbs8Bytes) & kMsbs8Bytes);
  477|  8.88k|  }
_ZN4absl12lts_2026052618container_internal7IsEmptyENS1_6ctrl_tE:
  220|  73.9k|inline bool IsEmpty(ctrl_t c) { return c == ctrl_t::kEmpty; }
_ZN4absl12lts_2026052618container_internal6IsFullENS1_6ctrl_tE:
  221|  4.08M|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|  4.08M|  return static_cast<std::underlying_type_t<ctrl_t>>(c) >= 0;
  226|  4.08M|}
_ZN4absl12lts_2026052618container_internal9IsDeletedENS1_6ctrl_tE:
  227|    613|inline bool IsDeleted(ctrl_t c) { return c == ctrl_t::kDeleted; }
_ZN4absl12lts_2026052618container_internal20_mm_cmpgt_epi8_fixedEDv2_xS2_:
  264|   120k|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|   120k|  return _mm_cmpgt_epi8(a, b);
  273|   120k|}
_ZNK4absl12lts_2026052618container_internal18NonIterableBitMaskIjLi16ELi0EE13TrailingZerosEv:
   95|  39.3k|  uint32_t TrailingZeros() const {
   96|  39.3k|    return container_internal::TrailingZeros(mask_) >> Shift;
   97|  39.3k|  }
_ZNK4absl12lts_2026052618container_internal18NonIterableBitMaskIjLi16ELi0EE12LeadingZerosEv:
  100|  39.3k|  uint32_t LeadingZeros() const {
  101|  39.3k|    constexpr int total_significant_bits = SignificantBits << Shift;
  102|  39.3k|    constexpr int extra_bits = sizeof(T) * 8 - total_significant_bits;
  103|  39.3k|    return static_cast<uint32_t>(
  104|  39.3k|               countl_zero(static_cast<T>(mask_ << extra_bits))) >>
  105|  39.3k|           Shift;
  106|  39.3k|  }
_ZN4absl12lts_2026052618container_internal7BitMaskImLi8ELi3ELb0EEC2Em:
  133|  17.7k|  explicit BitMask(T mask) : Base(mask) {
  134|  17.7k|    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|  17.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  136|  17.7k|    }
  137|  17.7k|  }
_ZN4absl12lts_2026052618container_internal18NonIterableBitMaskImLi8ELi3EEC2Em:
   85|  17.7k|  explicit NonIterableBitMask(T mask) : mask_(mask) {}
_ZNK4absl12lts_2026052618container_internal7BitMaskImLi8ELi3ELb0EE5beginEv:
  153|  8.88k|  BitMask begin() const { return *this; }
_ZNK4absl12lts_2026052618container_internal7BitMaskImLi8ELi3ELb0EE3endEv:
  154|  8.88k|  BitMask end() const { return BitMask(0); }
_ZN4absl12lts_2026052618container_internalneERKNS1_7BitMaskImLi8ELi3ELb0EEES5_:
  160|  43.9k|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  161|  43.9k|    return a.mask_ != b.mask_;
  162|  43.9k|  }
_ZNK4absl12lts_2026052618container_internal7BitMaskImLi8ELi3ELb0EEdeEv:
  151|  35.0k|  uint32_t operator*() const { return Base::LowestBitSet(); }
_ZNK4absl12lts_2026052618container_internal18NonIterableBitMaskImLi8ELi3EE12LowestBitSetEv:
   90|  35.0k|  uint32_t LowestBitSet() const {
   91|  35.0k|    return container_internal::TrailingZeros(mask_) >> Shift;
   92|  35.0k|  }
_ZN4absl12lts_2026052618container_internal7BitMaskImLi8ELi3ELb0EEppEv:
  143|  35.0k|  BitMask& operator++() {
  144|  35.0k|    if (Shift == 3 && NullifyBitsOnIteration) {
  ------------------
  |  Branch (144:9): [True: 0, Folded]
  |  Branch (144:23): [Folded, False: 0]
  ------------------
  145|      0|      this->mask_ &= kMsbs8Bytes;
  146|      0|    }
  147|  35.0k|    this->mask_ &= (this->mask_ - 1);
  148|  35.0k|    return *this;
  149|  35.0k|  }

_ZNK4absl12lts_2026052618container_internal20HashtablezInfoHandle9IsSampledEv:
  204|   251k|  inline bool IsSampled() const { return false; }
_ZN4absl12lts_2026052618container_internal20HashtablezInfoHandle20RecordStorageChangedEmm:
  205|  6.45k|  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
_ZN4absl12lts_2026052618container_internal20HashtablezInfoHandle12RecordRehashEm:
  206|     10|  inline void RecordRehash(size_t /*total_probe_length*/) {}
_ZN4absl12lts_2026052618container_internal20HashtablezInfoHandle24RecordClearedReservationEv:
  208|  2.46k|  inline void RecordClearedReservation() {}
_ZN4absl12lts_2026052618container_internal20HashtablezInfoHandle16RecordInsertMissEmm:
  210|  3.84M|                               size_t /*distance_from_desired*/) {}
_ZN4absl12lts_2026052618container_internal20HashtablezInfoHandle11RecordEraseEv:
  211|  47.5k|  inline void RecordErase() {}

_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE21GetSizeAndIsAllocatedEv:
  365|  25.3k|  SizeType<A>& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE21DeallocateIfAllocatedEv:
  521|  12.6k|  void DeallocateIfAllocated() {
  522|  12.6k|    if (GetIsAllocated()) {
  ------------------
  |  Branch (522:9): [True: 8.43k, False: 4.24k]
  ------------------
  523|  8.43k|      MallocAdapter<A>::Deallocate(GetAllocator(), GetAllocatedData(),
  524|  8.43k|                                   GetAllocatedCapacity());
  525|  8.43k|    }
  526|  12.6k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE14GetIsAllocatedEv:
  373|  33.8k|  bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE21GetSizeAndIsAllocatedEv:
  367|  54.9k|  const SizeType<A>& GetSizeAndIsAllocated() const {
  368|  54.9k|    return metadata_.template get<1>();
  369|  54.9k|  }
_ZN4absl12lts_2026052623inlined_vector_internal13MallocAdapterINSt3__19allocatorINS0_14SourceLocationEEELb0EE10DeallocateERS6_PS5_m:
  124|  8.43k|                         SizeType<A> capacity) {
  125|  8.43k|    AllocatorTraits<A>::deallocate(allocator, pointer, capacity);
  126|  8.43k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE12GetAllocatorEv:
  420|  46.4k|  A& GetAllocator() { return metadata_.template get<0>(); }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE16GetAllocatedDataEv:
  375|  16.8k|  Pointer<A> GetAllocatedData() {
  376|       |    // GCC 12 has a false-positive -Wmaybe-uninitialized warning here.
  377|       |#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
  378|       |#pragma GCC diagnostic push
  379|       |#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
  380|       |#endif
  381|  16.8k|    return data_.allocated.allocated_data;
  382|       |#if ABSL_INTERNAL_HAVE_MIN_GNUC_VERSION(12, 0)
  383|       |#pragma GCC diagnostic pop
  384|       |#endif
  385|  16.8k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE20GetAllocatedCapacityEv:
  405|  16.8k|  SizeType<A> GetAllocatedCapacity() const {
  406|  16.8k|    return data_.allocated.allocated_capacity;
  407|  16.8k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE14GetInlinedDataEv:
  397|  12.7k|  ABSL_ATTRIBUTE_NO_SANITIZE_CFI Pointer<A> GetInlinedData() {
  398|  12.7k|    return reinterpret_cast<Pointer<A>>(data_.inlined.inlined_data);
  399|  12.7k|  }
_ZN4absl12lts_2026052623inlined_vector_internal14DestroyAdapterINSt3__19allocatorINS0_14SourceLocationEEELb1EE15DestroyElementsERS6_PS5_m:
  101|  8.44k|                              SizeType<A> destroy_size) {
  102|  8.44k|    static_cast<void>(allocator);
  103|  8.44k|    static_cast<void>(destroy_first);
  104|  8.44k|    static_cast<void>(destroy_size);
  105|  8.44k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE7GetSizeEv:
  371|  21.1k|  SizeType<A> GetSize() const { return GetSizeAndIsAllocated() >> 1; }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE14GetIsAllocatedEv:
  373|   612k|  bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE21GetSizeAndIsAllocatedEv:
  367|  1.22M|  const SizeType<A>& GetSizeAndIsAllocated() const {
  368|  1.22M|    return metadata_.template get<1>();
  369|  1.22M|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE14GetInlinedDataEv:
  397|   612k|  ABSL_ATTRIBUTE_NO_SANITIZE_CFI Pointer<A> GetInlinedData() {
  398|   612k|    return reinterpret_cast<Pointer<A>>(data_.inlined.inlined_data);
  399|   612k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE7GetSizeEv:
  371|   612k|  SizeType<A> GetSize() const { return GetSizeAndIsAllocated() >> 1; }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEEC2Ev:
  338|   612k|  Storage() : metadata_(A(), /* size and is_allocated */ 0u) {}
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEED2Ev:
  343|   612k|  ~Storage() {
  344|       |    // Fast path: if we are empty and not allocated, there's nothing to do.
  345|   612k|    if (GetSizeAndIsAllocated() == 0) {
  ------------------
  |  Branch (345:9): [True: 612k, False: 0]
  ------------------
  346|   612k|      return;
  347|   612k|    }
  348|       |
  349|       |    // Fast path: if no destructors need to be run and we know the allocator
  350|       |    // doesn't do anything fancy, then all we need to do is deallocate (and
  351|       |    // maybe not even that).
  352|      0|    if (std::is_trivially_destructible<ValueType<A>>::value &&
  ------------------
  |  Branch (352:9): [True: 0, Folded]
  ------------------
  353|      0|        std::is_same<A, std::allocator<ValueType<A>>>::value) {
  ------------------
  |  Branch (353:9): [True: 0, Folded]
  ------------------
  354|      0|      DeallocateIfAllocated();
  355|      0|      return;
  356|      0|    }
  357|       |
  358|      0|    DestroyContents();
  359|      0|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIPNS0_7LogSinkELm16ENSt3__19allocatorIS4_EEE21GetSizeAndIsAllocatedEv:
  365|   612k|  SizeType<A>& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEED2Ev:
  343|  4.24k|  ~Storage() {
  344|       |    // Fast path: if we are empty and not allocated, there's nothing to do.
  345|  4.24k|    if (GetSizeAndIsAllocated() == 0) {
  ------------------
  |  Branch (345:9): [True: 0, False: 4.24k]
  ------------------
  346|      0|      return;
  347|      0|    }
  348|       |
  349|       |    // Fast path: if no destructors need to be run and we know the allocator
  350|       |    // doesn't do anything fancy, then all we need to do is deallocate (and
  351|       |    // maybe not even that).
  352|  4.24k|    if (std::is_trivially_destructible<ValueType<A>>::value &&
  ------------------
  |  Branch (352:9): [True: 0, Folded]
  ------------------
  353|  4.24k|        std::is_same<A, std::allocator<ValueType<A>>>::value) {
  ------------------
  |  Branch (353:9): [True: 0, Folded]
  ------------------
  354|  4.24k|      DeallocateIfAllocated();
  355|  4.24k|      return;
  356|  4.24k|    }
  357|       |
  358|      0|    DestroyContents();
  359|      0|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE14GetInlinedDataEv:
  401|     11|  ABSL_ATTRIBUTE_NO_SANITIZE_CFI ConstPointer<A> GetInlinedData() const {
  402|     11|    return reinterpret_cast<ConstPointer<A>>(data_.inlined.inlined_data);
  403|     11|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEEC2Ev:
  338|  4.24k|  Storage() : metadata_(A(), /* size and is_allocated */ 0u) {}
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE11EmplaceBackIJRKS3_EEERS3_DpOT_:
  817|  12.6k|auto Storage<T, N, A>::EmplaceBack(Args&&... args) -> Reference<A> {
  818|  12.6k|  StorageView<A> storage_view = MakeStorageView();
  819|  12.6k|  const SizeType<A> n = storage_view.size;
  820|  12.6k|  if (ABSL_PREDICT_TRUE(n != storage_view.capacity)) {
  ------------------
  |  |  191|  12.6k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 4.23k, False: 8.43k]
  |  |  |  Branch (191:48): [Folded, False: 12.6k]
  |  |  |  Branch (191:57): [True: 4.23k, False: 8.43k]
  |  |  ------------------
  ------------------
  821|       |    // Fast path; new element fits.
  822|  4.23k|    Pointer<A> last_ptr = storage_view.data + n;
  823|  4.23k|    AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
  824|  4.23k|                                  std::forward<Args>(args)...);
  825|  4.23k|    AddSize(1);
  826|  4.23k|    return *last_ptr;
  827|  4.23k|  }
  828|       |  // TODO(b/173712035): Annotate with musttail attribute to prevent regression.
  829|  8.43k|  return EmplaceBackSlow(std::forward<Args>(args)...);
  830|  12.6k|}
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE15MakeStorageViewEv:
  413|  21.1k|  StorageView<A> MakeStorageView() {
  414|  21.1k|    return GetIsAllocated() ? StorageView<A>{GetAllocatedData(), GetSize(),
  ------------------
  |  Branch (414:12): [True: 8.39k, False: 12.7k]
  ------------------
  415|  8.39k|                                             GetAllocatedCapacity()}
  416|  21.1k|                            : StorageView<A>{GetInlinedData(), GetSize(),
  417|  12.7k|                                             GetInlinedCapacity()};
  418|  21.1k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE18GetInlinedCapacityEv:
  409|  12.7k|  SizeType<A> GetInlinedCapacity() const {
  410|  12.7k|    return static_cast<SizeType<A>>(kOptimalInlinedSize);
  411|  12.7k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE7AddSizeEm:
  475|  12.6k|  void AddSize(SizeType<A> count) {
  476|  12.6k|    GetSizeAndIsAllocated() += count << static_cast<SizeType<A>>(1);
  477|  12.6k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE15EmplaceBackSlowIJRKS3_EEERS3_DpOT_:
  834|  8.43k|auto Storage<T, N, A>::EmplaceBackSlow(Args&&... args) -> Reference<A> {
  835|  8.43k|  StorageView<A> storage_view = MakeStorageView();
  836|  8.43k|  AllocationTransaction<A> allocation_tx(GetAllocator());
  837|  8.43k|  IteratorValueAdapter<A, MoveIterator<A>> move_values(
  838|  8.43k|      MoveIterator<A>(storage_view.data));
  839|  8.43k|  SizeType<A> requested_capacity = NextCapacity(storage_view.capacity);
  840|  8.43k|  Pointer<A> construct_data = allocation_tx.Allocate(requested_capacity);
  841|  8.43k|  Pointer<A> last_ptr = construct_data + storage_view.size;
  842|       |
  843|       |  // Construct new element.
  844|  8.43k|  AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
  845|  8.43k|                                std::forward<Args>(args)...);
  846|       |  // Move elements from old backing store to new backing store.
  847|  8.43k|  ABSL_INTERNAL_TRY {
  ------------------
  |  |  179|  8.43k|#define ABSL_INTERNAL_TRY try
  ------------------
  848|  8.43k|    ConstructElements<A>(GetAllocator(), allocation_tx.GetData(), move_values,
  849|  8.43k|                         storage_view.size);
  850|  8.43k|  }
  851|  8.43k|  ABSL_INTERNAL_CATCH_ANY {
  852|      0|    AllocatorTraits<A>::destroy(GetAllocator(), last_ptr);
  853|      0|    ABSL_INTERNAL_RETHROW;
  ------------------
  |  |  181|      0|#define ABSL_INTERNAL_RETHROW do { throw; } while (false)
  |  |  ------------------
  |  |  |  Branch (181:52): [Folded, False: 0]
  |  |  ------------------
  ------------------
  854|      0|  }
  855|       |  // Destroy elements in old backing store.
  856|  8.43k|  DestroyAdapter<A>::DestroyElements(GetAllocator(), storage_view.data,
  857|  8.43k|                                     storage_view.size);
  858|       |
  859|  8.43k|  DeallocateIfAllocated();
  860|  8.43k|  SetAllocation(std::move(allocation_tx).Release());
  861|  8.43k|  SetIsAllocated();
  862|  8.43k|  AddSize(1);
  863|  8.43k|  return *last_ptr;
  864|  8.43k|}
_ZN4absl12lts_2026052623inlined_vector_internal21AllocationTransactionINSt3__19allocatorINS0_14SourceLocationEEEEC2ERS6_:
  207|  8.44k|      : allocator_data_(allocator, nullptr), capacity_(0) {}
_ZN4absl12lts_2026052623inlined_vector_internal20IteratorValueAdapterINSt3__19allocatorINS0_14SourceLocationEEENS3_13move_iteratorIPS5_EEEC2ERKS9_:
  160|  8.43k|  explicit IteratorValueAdapter(const Iterator& it) : it_(it) {}
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE12NextCapacityEm:
  325|  8.43k|  static SizeType<A> NextCapacity(SizeType<A> current_capacity) {
  326|  8.43k|    return current_capacity * 2;
  327|  8.43k|  }
_ZN4absl12lts_2026052623inlined_vector_internal21AllocationTransactionINSt3__19allocatorINS0_14SourceLocationEEEE8AllocateEm:
  224|  8.43k|  Pointer<A> Allocate(SizeType<A> requested_capacity) {
  225|  8.43k|    Allocation<A> result =
  226|  8.43k|        MallocAdapter<A>::Allocate(GetAllocator(), requested_capacity);
  227|  8.43k|    GetData() = result.data;
  228|  8.43k|    GetCapacity() = result.capacity;
  229|  8.43k|    return result.data;
  230|  8.43k|  }
_ZN4absl12lts_2026052623inlined_vector_internal13MallocAdapterINSt3__19allocatorINS0_14SourceLocationEEELb0EE8AllocateERS6_m:
  118|  8.43k|  static Allocation<A> Allocate(A& allocator, SizeType<A> requested_capacity) {
  119|  8.43k|    return {AllocatorTraits<A>::allocate(allocator, requested_capacity),
  120|  8.43k|            requested_capacity};
  121|  8.43k|  }
_ZN4absl12lts_2026052623inlined_vector_internal21AllocationTransactionINSt3__19allocatorINS0_14SourceLocationEEEE12GetAllocatorEv:
  218|  8.43k|  A& GetAllocator() { return allocator_data_.template get<0>(); }
_ZN4absl12lts_2026052623inlined_vector_internal21AllocationTransactionINSt3__19allocatorINS0_14SourceLocationEEEE11GetCapacityEv:
  220|  25.3k|  SizeType<A>& GetCapacity() { return capacity_; }
_ZN4absl12lts_2026052623inlined_vector_internal17ConstructElementsINSt3__19allocatorINS0_14SourceLocationEEENS1_20IteratorValueAdapterIS6_NS3_13move_iteratorIPS5_EEEEEEvRNS0_13type_identityIT_E4typeENS3_16allocator_traitsISD_E7pointerERT0_NSI_9size_typeE:
  132|  8.43k|                       SizeType<A> construct_size) {
  133|  21.0k|  for (SizeType<A> i = 0; i < construct_size; ++i) {
  ------------------
  |  Branch (133:27): [True: 12.6k, False: 8.43k]
  ------------------
  134|  12.6k|    ABSL_INTERNAL_TRY { values.ConstructNext(allocator, construct_first + i); }
  ------------------
  |  |  179|  12.6k|#define ABSL_INTERNAL_TRY try
  ------------------
  135|  12.6k|    ABSL_INTERNAL_CATCH_ANY {
  136|      0|      DestroyAdapter<A>::DestroyElements(allocator, construct_first, i);
  137|      0|      ABSL_INTERNAL_RETHROW;
  ------------------
  |  |  181|      0|#define ABSL_INTERNAL_RETHROW do { throw; } while (false)
  |  |  ------------------
  |  |  |  Branch (181:52): [Folded, False: 0]
  |  |  ------------------
  ------------------
  138|      0|    }
  139|  12.6k|  }
  140|  8.43k|}
_ZN4absl12lts_2026052623inlined_vector_internal20IteratorValueAdapterINSt3__19allocatorINS0_14SourceLocationEEENS3_13move_iteratorIPS5_EEE13ConstructNextERS6_S8_:
  162|  12.6k|  void ConstructNext(A& allocator, Pointer<A> construct_at) {
  163|  12.6k|    AllocatorTraits<A>::construct(allocator, construct_at, *it_);
  164|  12.6k|    ++it_;
  165|  12.6k|  }
_ZN4absl12lts_2026052623inlined_vector_internal21AllocationTransactionINSt3__19allocatorINS0_14SourceLocationEEEE7GetDataEv:
  219|  42.2k|  Pointer<A>& GetData() { return allocator_data_.template get<1>(); }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE13SetAllocationENS1_10AllocationIS6_EE:
  485|  8.43k|  void SetAllocation(Allocation<A> allocation) {
  486|  8.43k|    data_.allocated.allocated_data = allocation.data;
  487|  8.43k|    data_.allocated.allocated_capacity = allocation.capacity;
  488|  8.43k|  }
_ZNO4absl12lts_2026052623inlined_vector_internal21AllocationTransactionINSt3__19allocatorINS0_14SourceLocationEEEE7ReleaseEv:
  232|  8.43k|  [[nodiscard]] Allocation<A> Release() && {
  233|  8.43k|    Allocation<A> result = {GetData(), GetCapacity()};
  234|  8.43k|    Reset();
  235|  8.43k|    return result;
  236|  8.43k|  }
_ZN4absl12lts_2026052623inlined_vector_internal21AllocationTransactionINSt3__19allocatorINS0_14SourceLocationEEEE5ResetEv:
  239|  8.43k|  void Reset() {
  240|  8.43k|    GetData() = nullptr;
  241|  8.43k|    GetCapacity() = 0;
  242|  8.43k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE14SetIsAllocatedEv:
  454|  8.43k|  void SetIsAllocated() {
  455|  8.43k|    GetSizeAndIsAllocated() |= static_cast<SizeType<A>>(1);
  456|  8.43k|  }
_ZN4absl12lts_2026052623inlined_vector_internal21AllocationTransactionINSt3__19allocatorINS0_14SourceLocationEEEED2Ev:
  209|  8.44k|  ~AllocationTransaction() {
  210|  8.44k|    if (DidAllocate()) {
  ------------------
  |  Branch (210:9): [True: 0, False: 8.44k]
  ------------------
  211|      0|      MallocAdapter<A>::Deallocate(GetAllocator(), GetData(), GetCapacity());
  212|      0|    }
  213|  8.44k|  }
_ZN4absl12lts_2026052623inlined_vector_internal21AllocationTransactionINSt3__19allocatorINS0_14SourceLocationEEEE11DidAllocateEv:
  222|  8.45k|  bool DidAllocate() { return GetData() != nullptr; }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE6AssignINS1_20IteratorValueAdapterIS6_PKS3_EEEEvT_m:
  646|     11|                              SizeType<A> new_size) -> void {
  647|     11|  StorageView<A> storage_view = MakeStorageView();
  648|       |
  649|     11|  AllocationTransaction<A> allocation_tx(GetAllocator());
  650|       |
  651|     11|  absl::Span<ValueType<A>> assign_loop;
  652|     11|  absl::Span<ValueType<A>> construct_loop;
  653|     11|  absl::Span<ValueType<A>> destroy_loop;
  654|       |
  655|     11|  if (new_size > storage_view.capacity) {
  ------------------
  |  Branch (655:7): [True: 0, False: 11]
  ------------------
  656|      0|    SizeType<A> requested_capacity =
  657|      0|        ComputeCapacity(storage_view.capacity, new_size);
  658|      0|    construct_loop = {allocation_tx.Allocate(requested_capacity), new_size};
  659|      0|    destroy_loop = {storage_view.data, storage_view.size};
  660|     11|  } else if (new_size > storage_view.size) {
  ------------------
  |  Branch (660:14): [True: 11, False: 0]
  ------------------
  661|     11|    assign_loop = {storage_view.data, storage_view.size};
  662|     11|    construct_loop = {storage_view.data + storage_view.size,
  663|     11|                      new_size - storage_view.size};
  664|     11|  } else {
  665|      0|    assign_loop = {storage_view.data, new_size};
  666|      0|    destroy_loop = {storage_view.data + new_size, storage_view.size - new_size};
  667|      0|  }
  668|       |
  669|     11|  AssignElements<A>(assign_loop.data(), values, assign_loop.size());
  670|       |
  671|     11|  ConstructElements<A>(GetAllocator(), construct_loop.data(), values,
  672|     11|                       construct_loop.size());
  673|       |
  674|     11|  DestroyAdapter<A>::DestroyElements(GetAllocator(), destroy_loop.data(),
  675|     11|                                     destroy_loop.size());
  676|       |
  677|     11|  if (allocation_tx.DidAllocate()) {
  ------------------
  |  Branch (677:7): [True: 0, False: 11]
  ------------------
  678|      0|    DeallocateIfAllocated();
  679|      0|    SetAllocation(std::move(allocation_tx).Release());
  680|      0|    SetIsAllocated();
  681|      0|  }
  682|       |
  683|     11|  SetSize(new_size);
  684|     11|}
_ZN4absl12lts_2026052623inlined_vector_internal14AssignElementsINSt3__19allocatorINS0_14SourceLocationEEENS1_20IteratorValueAdapterIS6_PKS5_EEEEvNS3_16allocator_traitsIT_E7pointerERT0_NSD_9size_typeE:
  144|     11|                    SizeType<A> assign_size) {
  145|     11|  for (SizeType<A> i = 0; i < assign_size; ++i) {
  ------------------
  |  Branch (145:27): [True: 0, False: 11]
  ------------------
  146|      0|    values.AssignNext(assign_first + i);
  147|      0|  }
  148|     11|}
_ZN4absl12lts_2026052623inlined_vector_internal17ConstructElementsINSt3__19allocatorINS0_14SourceLocationEEENS1_20IteratorValueAdapterIS6_PKS5_EEEEvRNS0_13type_identityIT_E4typeENS3_16allocator_traitsISC_E7pointerERT0_NSH_9size_typeE:
  132|     11|                       SizeType<A> construct_size) {
  133|     22|  for (SizeType<A> i = 0; i < construct_size; ++i) {
  ------------------
  |  Branch (133:27): [True: 11, False: 11]
  ------------------
  134|     11|    ABSL_INTERNAL_TRY { values.ConstructNext(allocator, construct_first + i); }
  ------------------
  |  |  179|     11|#define ABSL_INTERNAL_TRY try
  ------------------
  135|     11|    ABSL_INTERNAL_CATCH_ANY {
  136|      0|      DestroyAdapter<A>::DestroyElements(allocator, construct_first, i);
  137|      0|      ABSL_INTERNAL_RETHROW;
  ------------------
  |  |  181|      0|#define ABSL_INTERNAL_RETHROW do { throw; } while (false)
  |  |  ------------------
  |  |  |  Branch (181:52): [Folded, False: 0]
  |  |  ------------------
  ------------------
  138|      0|    }
  139|     11|  }
  140|     11|}
_ZN4absl12lts_2026052623inlined_vector_internal20IteratorValueAdapterINSt3__19allocatorINS0_14SourceLocationEEEPKS5_E13ConstructNextERS6_PS5_:
  162|     11|  void ConstructNext(A& allocator, Pointer<A> construct_at) {
  163|     11|    AllocatorTraits<A>::construct(allocator, construct_at, *it_);
  164|     11|    ++it_;
  165|     11|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageINS0_14SourceLocationELm1ENSt3__19allocatorIS3_EEE7SetSizeEm:
  462|     11|  void SetSize(SizeType<A> size) {
  463|     11|    GetSizeAndIsAllocated() =
  464|     11|        (size << 1) | static_cast<SizeType<A>>(GetIsAllocated());
  465|     11|  }
_ZN4absl12lts_2026052623inlined_vector_internal20IteratorValueAdapterINSt3__19allocatorINS0_14SourceLocationEEEPKS5_EC2ERKS8_:
  160|     11|  explicit IteratorValueAdapter(const Iterator& it) : it_(it) {}

_ZN4absl12lts_2026052618container_internal42GrowSooTableToNextCapacityAndPrepareInsertILm8ELb1EEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEEb:
 1780|      1|    absl::FunctionRef<size_t(size_t)> get_hash, bool force_sampling) {
 1781|      1|  AssertSoo(common, policy);
 1782|      1|  if (ABSL_PREDICT_FALSE(force_sampling)) {
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1]
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 1783|       |    // The table is empty, it is only used for forced sampling of SOO tables.
 1784|      0|    return GrowEmptySooTableToNextCapacityForceSamplingAndPrepareInsert(
 1785|      0|        common, policy, get_hash);
 1786|      0|  }
 1787|      1|  ABSL_SWISSTABLE_ASSERT(common.size() == policy.soo_capacity());
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1788|      1|  static constexpr size_t kNewCapacity = NextCapacity(SooCapacity());
 1789|      1|  const size_t slot_size = policy.slot_size;
 1790|      1|  void* alloc = policy.get_char_alloc(common);
 1791|      1|  common.set_capacity(kNewCapacity);
 1792|       |
 1793|       |  // Since the table is not empty, it will not be sampled.
 1794|       |  // The decision to sample was already made during the first insertion.
 1795|       |  //
 1796|       |  // We do not set control and slots in CommonFields yet to avoid overriding
 1797|       |  // SOO data.
 1798|      1|  const auto [new_ctrl, new_slots] = AllocBackingArray(
 1799|      1|      common, policy, kNewCapacity, /*has_infoz=*/false, alloc);
 1800|       |
 1801|      1|  PrepareInsertCommon(common);
 1802|      1|  ABSL_SWISSTABLE_ASSERT(common.size() == 2);
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1803|      1|  GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(kNewCapacity - 2);
 1804|      1|  common.generate_new_seed(/*has_infoz=*/false);
 1805|      1|  const h2_t soo_slot_h2 = H2(policy.hash_slot(
 1806|      1|      policy.hash_fn(common), common.soo_data(), common.seed().seed()));
 1807|      1|  const size_t new_hash = get_hash(common.seed().seed());
 1808|       |
 1809|      1|  const size_t offset = Resize1To3NewOffset(new_hash, common.seed());
 1810|      1|  InitializeThreeElementsControlBytes(soo_slot_h2, H2(new_hash), offset,
 1811|      1|                                      new_ctrl);
 1812|       |
 1813|      1|  SanitizerPoisonMemoryRegion(new_slots, slot_size * kNewCapacity);
 1814|      1|  void* target_slot = SlotAddress(new_slots, SooSlotIndex(), slot_size);
 1815|      1|  SanitizerUnpoisonMemoryRegion(target_slot, slot_size);
 1816|      1|  if constexpr (TransferUsesMemcpy) {
 1817|       |    // Target slot is placed at index 1, but capacity is at
 1818|       |    // minimum 3. So we are allowed to copy at least twice as much
 1819|       |    // memory.
 1820|      1|    static_assert(SooSlotIndex() == 1);
 1821|      1|    static_assert(SooSlotMemcpySize > 0);
 1822|      1|    static_assert(SooSlotMemcpySize <= MaxSooSlotSize());
 1823|      1|    ABSL_SWISSTABLE_ASSERT(SooSlotMemcpySize <= 2 * slot_size);
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1824|      1|    ABSL_SWISSTABLE_ASSERT(SooSlotMemcpySize >= slot_size);
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1825|      1|    void* next_slot = SlotAddress(target_slot, 1, slot_size);
 1826|      1|    SanitizerUnpoisonMemoryRegion(next_slot, SooSlotMemcpySize - slot_size);
 1827|      1|    std::memcpy(target_slot, common.soo_data(), SooSlotMemcpySize);
 1828|      1|    SanitizerPoisonMemoryRegion(next_slot, SooSlotMemcpySize - slot_size);
 1829|       |  } else {
 1830|       |    static_assert(SooSlotMemcpySize == 0);
 1831|       |    policy.transfer_n(&common, target_slot, common.soo_data(), 1);
 1832|       |  }
 1833|      1|  common.set_control(new_ctrl);
 1834|      1|  common.set_slots(new_slots);
 1835|       |
 1836|       |  // Full SOO table couldn't be sampled. If SOO table is sampled, it would
 1837|       |  // have been resized to the next capacity.
 1838|       |  ABSL_SWISSTABLE_ASSERT(!common.infoz().IsSampled());
  ------------------
  |  |   62|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1839|      1|  SanitizerUnpoisonMemoryRegion(SlotAddress(new_slots, offset, slot_size),
 1840|      1|                                slot_size);
 1841|      1|  return offset;
 1842|      1|}
_ZN4absl12lts_2026052618container_internal42GrowSooTableToNextCapacityAndPrepareInsertILm16ELb1EEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEEb:
 1780|  9.84k|    absl::FunctionRef<size_t(size_t)> get_hash, bool force_sampling) {
 1781|  9.84k|  AssertSoo(common, policy);
 1782|  9.84k|  if (ABSL_PREDICT_FALSE(force_sampling)) {
  ------------------
  |  |  190|  9.84k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 9.84k]
  |  |  |  Branch (190:49): [Folded, False: 9.84k]
  |  |  |  Branch (190:58): [True: 0, False: 9.84k]
  |  |  ------------------
  ------------------
 1783|       |    // The table is empty, it is only used for forced sampling of SOO tables.
 1784|      0|    return GrowEmptySooTableToNextCapacityForceSamplingAndPrepareInsert(
 1785|      0|        common, policy, get_hash);
 1786|      0|  }
 1787|  9.84k|  ABSL_SWISSTABLE_ASSERT(common.size() == policy.soo_capacity());
  ------------------
  |  |   62|  9.84k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1788|  9.84k|  static constexpr size_t kNewCapacity = NextCapacity(SooCapacity());
 1789|  9.84k|  const size_t slot_size = policy.slot_size;
 1790|  9.84k|  void* alloc = policy.get_char_alloc(common);
 1791|  9.84k|  common.set_capacity(kNewCapacity);
 1792|       |
 1793|       |  // Since the table is not empty, it will not be sampled.
 1794|       |  // The decision to sample was already made during the first insertion.
 1795|       |  //
 1796|       |  // We do not set control and slots in CommonFields yet to avoid overriding
 1797|       |  // SOO data.
 1798|  9.84k|  const auto [new_ctrl, new_slots] = AllocBackingArray(
 1799|  9.84k|      common, policy, kNewCapacity, /*has_infoz=*/false, alloc);
 1800|       |
 1801|  9.84k|  PrepareInsertCommon(common);
 1802|  9.84k|  ABSL_SWISSTABLE_ASSERT(common.size() == 2);
  ------------------
  |  |   62|  9.84k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1803|  9.84k|  GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(kNewCapacity - 2);
 1804|  9.84k|  common.generate_new_seed(/*has_infoz=*/false);
 1805|  9.84k|  const h2_t soo_slot_h2 = H2(policy.hash_slot(
 1806|  9.84k|      policy.hash_fn(common), common.soo_data(), common.seed().seed()));
 1807|  9.84k|  const size_t new_hash = get_hash(common.seed().seed());
 1808|       |
 1809|  9.84k|  const size_t offset = Resize1To3NewOffset(new_hash, common.seed());
 1810|  9.84k|  InitializeThreeElementsControlBytes(soo_slot_h2, H2(new_hash), offset,
 1811|  9.84k|                                      new_ctrl);
 1812|       |
 1813|  9.84k|  SanitizerPoisonMemoryRegion(new_slots, slot_size * kNewCapacity);
 1814|  9.84k|  void* target_slot = SlotAddress(new_slots, SooSlotIndex(), slot_size);
 1815|  9.84k|  SanitizerUnpoisonMemoryRegion(target_slot, slot_size);
 1816|  9.84k|  if constexpr (TransferUsesMemcpy) {
 1817|       |    // Target slot is placed at index 1, but capacity is at
 1818|       |    // minimum 3. So we are allowed to copy at least twice as much
 1819|       |    // memory.
 1820|  9.84k|    static_assert(SooSlotIndex() == 1);
 1821|  9.84k|    static_assert(SooSlotMemcpySize > 0);
 1822|  9.84k|    static_assert(SooSlotMemcpySize <= MaxSooSlotSize());
 1823|  9.84k|    ABSL_SWISSTABLE_ASSERT(SooSlotMemcpySize <= 2 * slot_size);
  ------------------
  |  |   62|  9.84k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1824|  9.84k|    ABSL_SWISSTABLE_ASSERT(SooSlotMemcpySize >= slot_size);
  ------------------
  |  |   62|  9.84k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1825|  9.84k|    void* next_slot = SlotAddress(target_slot, 1, slot_size);
 1826|  9.84k|    SanitizerUnpoisonMemoryRegion(next_slot, SooSlotMemcpySize - slot_size);
 1827|  9.84k|    std::memcpy(target_slot, common.soo_data(), SooSlotMemcpySize);
 1828|  9.84k|    SanitizerPoisonMemoryRegion(next_slot, SooSlotMemcpySize - slot_size);
 1829|       |  } else {
 1830|       |    static_assert(SooSlotMemcpySize == 0);
 1831|       |    policy.transfer_n(&common, target_slot, common.soo_data(), 1);
 1832|       |  }
 1833|  9.84k|  common.set_control(new_ctrl);
 1834|  9.84k|  common.set_slots(new_slots);
 1835|       |
 1836|       |  // Full SOO table couldn't be sampled. If SOO table is sampled, it would
 1837|       |  // have been resized to the next capacity.
 1838|       |  ABSL_SWISSTABLE_ASSERT(!common.infoz().IsSampled());
  ------------------
  |  |   62|  9.84k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1839|  9.84k|  SanitizerUnpoisonMemoryRegion(SlotAddress(new_slots, offset, slot_size),
 1840|  9.84k|                                slot_size);
 1841|  9.84k|  return offset;
 1842|  9.84k|}
_ZN4absl12lts_2026052618container_internal17NextHashTableSeedEv:
  138|  56.0k|uint16_t NextHashTableSeed() {
  139|  56.0k|  static_assert(PerTableSeed::kBitCount <= 16);
  140|  56.0k|  thread_local uint16_t seed =
  141|  56.0k|      static_cast<uint16_t>(reinterpret_cast<uintptr_t>(&seed));
  142|  56.0k|  seed += uint16_t{0xad53};
  143|  56.0k|  return seed;
  144|  56.0k|}
_ZN4absl12lts_2026052618container_internal37ConvertDeletedToEmptyAndFullToDeletedEPNS1_6ctrl_tEm:
  284|     10|void ConvertDeletedToEmptyAndFullToDeleted(ctrl_t* ctrl, size_t capacity) {
  285|     10|  ABSL_SWISSTABLE_ASSERT(ctrl[capacity] == ctrl_t::kSentinel);
  ------------------
  |  |   62|     10|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  286|     10|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |   62|     10|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  287|     60|  for (ctrl_t* pos = ctrl; pos < ctrl + capacity; pos += Group::kWidth) {
  ------------------
  |  Branch (287:28): [True: 50, False: 10]
  ------------------
  288|     50|    Group{pos}.ConvertSpecialToEmptyAndFullToDeleted(pos);
  289|     50|  }
  290|       |  // Copy the cloned ctrl bytes.
  291|     10|  std::memcpy(ctrl + capacity + 1, ctrl, NumClonedBytes());
  292|     10|  ctrl[capacity] = ctrl_t::kSentinel;
  293|     10|}
_ZN4absl12lts_2026052618container_internal20IterateOverFullSlotsERKNS1_12CommonFieldsEmNS0_11FunctionRefIFvPKNS1_6ctrl_tEPvEEE:
  296|  40.6k|                          absl::FunctionRef<void(const ctrl_t*, void*)> cb) {
  297|  40.6k|  IterateOverFullSlotsImpl(c, slot_size, cb);
  298|  40.6k|}
_ZN4absl12lts_2026052618container_internal18EraseMetaOnlyLargeERNS1_12CommonFieldsEPKNS1_6ctrl_tEm:
  650|  47.5k|void EraseMetaOnlyLarge(CommonFields& c, const ctrl_t* ctrl, size_t slot_size) {
  651|  47.5k|  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   62|  47.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  652|  47.5k|  ABSL_SWISSTABLE_ASSERT(IsFull(*ctrl) && "erasing a dangling iterator");
  ------------------
  |  |   62|  47.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  653|  47.5k|  c.decrement_size();
  654|  47.5k|  c.infoz().RecordErase();
  655|       |
  656|  47.5k|  size_t index = static_cast<size_t>(ctrl - c.control());
  657|       |
  658|  47.5k|  if (WasNeverFull(c, index)) {
  ------------------
  |  Branch (658:7): [True: 38.6k, False: 8.87k]
  ------------------
  659|  38.6k|    SetCtrl(c, index, ctrl_t::kEmpty, slot_size);
  660|  38.6k|    c.growth_info().OverwriteFullAsEmpty();
  661|  38.6k|    return;
  662|  38.6k|  }
  663|       |
  664|  8.87k|  c.growth_info().OverwriteFullAsDeleted();
  665|  8.87k|  SetCtrlInLargeTable(c, index, ctrl_t::kDeleted, slot_size);
  666|  8.87k|}
_ZN4absl12lts_2026052618container_internal17ClearBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPvb:
  670|  6.45k|                       bool reuse) {
  671|  6.45k|  ABSL_SWISSTABLE_ASSERT(c.capacity() > MaxSmallCapacity());
  ------------------
  |  |   62|  6.45k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  672|  6.45k|  if (reuse) {
  ------------------
  |  Branch (672:7): [True: 3.98k, False: 2.46k]
  ------------------
  673|  3.98k|    c.set_size_to_zero();
  674|  3.98k|    ResetCtrl(c, policy.slot_size);
  675|  3.98k|    ResetGrowthLeft(c);
  676|  3.98k|    c.infoz().RecordStorageChanged(0, c.capacity());
  677|  3.98k|  } else {
  678|  2.46k|    ClearBackingArrayNoReuse(c, policy, alloc);
  679|  2.46k|  }
  680|  6.45k|}
_ZN4absl12lts_2026052618container_internal24PrepareInsertSmallNonSooERNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEE:
 1541|  83.1k|    absl::FunctionRef<size_t(size_t)> get_hash) {
 1542|  83.1k|  ABSL_SWISSTABLE_ASSERT(common.is_small());
  ------------------
  |  |   62|  83.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1543|  83.1k|  ABSL_SWISSTABLE_ASSERT(!policy.soo_enabled);
  ------------------
  |  |   62|  83.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1544|  83.1k|  if (common.capacity() == 1) {
  ------------------
  |  Branch (1544:7): [True: 40.5k, False: 42.5k]
  ------------------
 1545|  40.5k|    if (common.empty()) {
  ------------------
  |  Branch (1545:9): [True: 125, False: 40.3k]
  ------------------
 1546|    125|      IncrementSmallSizeNonSoo(common, policy);
 1547|    125|      if (common.has_infoz()) {
  ------------------
  |  Branch (1547:11): [True: 0, False: 125]
  ------------------
 1548|      0|        common.infoz().RecordInsertMiss(get_hash(common.seed().seed()),
 1549|      0|                                        /*distance_from_desired=*/0);
 1550|      0|      }
 1551|    125|      return {SooControl(), common.slot_array()};
 1552|  40.3k|    } else {
 1553|  40.3k|      return Grow1To3AndPrepareInsert(common, policy, get_hash);
 1554|  40.3k|    }
 1555|  40.5k|  }
 1556|       |
 1557|       |  // Growing from 0 to 1 capacity.
 1558|  42.5k|  ABSL_SWISSTABLE_ASSERT(common.capacity() == 0);
  ------------------
  |  |   62|  42.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1559|  42.5k|  constexpr size_t kNewCapacity = 1;
 1560|       |
 1561|  42.5k|  common.set_capacity(kNewCapacity);
 1562|  42.5k|  HashtablezInfoHandle infoz;
 1563|  42.5k|  const bool should_sample =
 1564|  42.5k|      policy.is_hashtablez_eligible && ShouldSampleNextTable();
  ------------------
  |  Branch (1564:7): [True: 42.5k, False: 0]
  |  Branch (1564:40): [True: 0, False: 42.5k]
  ------------------
 1565|  42.5k|  if (ABSL_PREDICT_FALSE(should_sample)) {
  ------------------
  |  |  190|  42.5k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 42.5k]
  |  |  |  Branch (190:49): [Folded, False: 42.5k]
  |  |  |  Branch (190:58): [True: 0, False: 42.5k]
  |  |  ------------------
  ------------------
 1566|      0|    infoz = ForcedTrySample(policy.slot_size, policy.key_size,
 1567|      0|                            policy.value_size, policy.soo_capacity());
 1568|      0|  }
 1569|  42.5k|  const bool has_infoz = infoz.IsSampled();
 1570|  42.5k|  void* alloc = policy.get_char_alloc(common);
 1571|       |
 1572|  42.5k|  const auto [new_ctrl, new_slots] =
 1573|  42.5k|      AllocBackingArray(common, policy, kNewCapacity, has_infoz, alloc);
 1574|  42.5k|  common.set_control(new_ctrl);
 1575|  42.5k|  common.set_slots(new_slots);
 1576|       |
 1577|  42.5k|  static_assert(NextCapacity(0) == 1);
 1578|  42.5k|  PrepareInsertCommon(common);
 1579|       |
 1580|  42.5k|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|  42.5k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 42.5k]
  |  |  |  Branch (190:49): [Folded, False: 42.5k]
  |  |  |  Branch (190:58): [True: 0, False: 42.5k]
  |  |  ------------------
  ------------------
 1581|      0|    common.generate_new_seed(/*has_infoz=*/true);
 1582|      0|    ReportSingleGroupTableGrowthToInfoz(common, infoz,
 1583|      0|                                        get_hash(common.seed().seed()));
 1584|      0|  }
 1585|  42.5k|  return {SooControl(), new_slots};
 1586|  83.1k|}
_ZN4absl12lts_2026052618container_internal19GetRefForEmptyClassERNS1_12CommonFieldsE:
 1752|   312k|void* GetRefForEmptyClass(CommonFields& common) {
 1753|       |  // Empty base optimization typically make the empty base class address to be
 1754|       |  // the same as the first address of the derived class object.
 1755|       |  // But we generally assume that for empty classes we can return any valid
 1756|       |  // pointer.
 1757|   312k|  return &common;
 1758|   312k|}
_ZN4absl12lts_2026052618container_internal45ReserveEmptyNonAllocatedTableToFitBucketCountERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1769|  5.83k|    size_t bucket_count) {
 1770|  5.83k|  size_t new_capacity = NormalizeCapacity(bucket_count);
 1771|  5.83k|  ValidateMaxCapacity(new_capacity, policy.key_size, policy.slot_size);
 1772|  5.83k|  ResizeEmptyNonAllocatedTableImpl(common, policy, new_capacity,
 1773|  5.83k|                                   /*force_infoz=*/false);
 1774|  5.83k|}
_ZN4absl12lts_2026052618container_internal18PrepareInsertLargeERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_18NonIterableBitMaskIjLi16ELi0EEENS1_8FindInfoE:
 2012|  4.00M|                          FindInfo target_group) {
 2013|       |  // NOLINTNEXTLINE(misc-static-assert)
 2014|       |  ABSL_SWISSTABLE_ASSERT(!SwisstableGenerationsEnabled());
  ------------------
  |  |   62|  4.00M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2015|  4.00M|  return PrepareInsertLargeImpl(common, policy, hash, mask_empty, target_group);
 2016|  4.00M|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119Resize1To3NewOffsetEmNS1_16PerTableSeedImplIhEE:
  107|  50.2k|size_t Resize1To3NewOffset(size_t hash, PerTableSeed seed) {
  108|       |  // After resize from capacity 1 to 3, we always have exactly the slot with
  109|       |  // index 1 occupied, so we need to insert either at index 0 or index 2.
  110|  50.2k|  static_assert(SooSlotIndex() == 1);
  111|  50.2k|  return SingleGroupTableH1(hash, seed) & 2;
  112|  50.2k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_118SingleGroupTableH1EmNS1_16PerTableSeedImplIhEE:
  102|   134k|size_t SingleGroupTableH1(size_t hash, PerTableSeed seed) {
  103|   134k|  return hash ^ seed.seed();
  104|   134k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_111SlotAddressEPvmm:
  116|  3.24M|inline void* SlotAddress(void* slot_array, size_t slot, size_t slot_size) {
  117|  3.24M|  return static_cast<void*>(static_cast<char*>(slot_array) +
  118|  3.24M|                            (slot * slot_size));
  119|  3.24M|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119PrepareInsertCommonERNS1_12CommonFieldsE:
  335|  4.09M|void PrepareInsertCommon(CommonFields& common) {
  336|  4.09M|  common.increment_size();
  337|  4.09M|  common.maybe_increment_generation_on_insert();
  338|  4.09M|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_135InitializeThreeElementsControlBytesEhhmPNS1_6ctrl_tE:
  557|  50.2k|    h2_t orig_h2, h2_t new_h2, size_t new_offset, ctrl_t* new_ctrl) {
  558|  50.2k|  static constexpr size_t kNewCapacity = NextCapacity(SooCapacity());
  559|  50.2k|  static_assert(kNewCapacity == 3);
  560|  50.2k|  static_assert(is_single_group(kNewCapacity));
  561|  50.2k|  static_assert(SooSlotIndex() == 1);
  562|  50.2k|  ABSL_SWISSTABLE_ASSERT(new_offset == 0 || new_offset == 2);
  ------------------
  |  |   62|  50.2k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  563|       |
  564|  50.2k|  static constexpr uint64_t kEmptyXorSentinel =
  565|  50.2k|      static_cast<uint8_t>(ctrl_t::kEmpty) ^
  566|  50.2k|      static_cast<uint8_t>(ctrl_t::kSentinel);
  567|  50.2k|  static constexpr uint64_t kEmpty64 = static_cast<uint8_t>(ctrl_t::kEmpty);
  568|  50.2k|  static constexpr size_t kMirroredSooSlotIndex =
  569|  50.2k|      SooSlotIndex() + kNewCapacity + 1;
  570|       |  // The first 8 bytes, where SOO slot original and mirrored positions are
  571|       |  // replaced with 0.
  572|       |  // Result will look like: E0ESE0EE
  573|  50.2k|  static constexpr uint64_t kFirstCtrlBytesWithZeroes =
  574|  50.2k|      k8EmptyBytes ^ (kEmpty64 << (8 * SooSlotIndex())) ^
  575|  50.2k|      (kEmptyXorSentinel << (8 * kNewCapacity)) ^
  576|  50.2k|      (kEmpty64 << (8 * kMirroredSooSlotIndex));
  577|       |
  578|  50.2k|  const uint64_t soo_h2 = static_cast<uint64_t>(orig_h2);
  579|  50.2k|  const uint64_t new_h2_xor_empty =
  580|  50.2k|      static_cast<uint64_t>(new_h2 ^ static_cast<uint8_t>(ctrl_t::kEmpty));
  581|       |  // Fill the original and mirrored bytes for SOO slot.
  582|       |  // Result will look like:
  583|       |  // EHESEHEE
  584|       |  // Where H = soo_h2, E = kEmpty, S = kSentinel.
  585|  50.2k|  uint64_t first_ctrl_bytes =
  586|  50.2k|      ((soo_h2 << (8 * SooSlotIndex())) | kFirstCtrlBytesWithZeroes) |
  587|  50.2k|      (soo_h2 << (8 * kMirroredSooSlotIndex));
  588|       |  // Replace original and mirrored empty bytes for the new position.
  589|       |  // Result for new_offset 0 will look like:
  590|       |  // NHESNHEE
  591|       |  // Where H = soo_h2, N = H2(new_hash), E = kEmpty, S = kSentinel.
  592|       |  // Result for new_offset 2 will look like:
  593|       |  // EHNSEHNE
  594|  50.2k|  first_ctrl_bytes ^= (new_h2_xor_empty << (8 * new_offset));
  595|  50.2k|  size_t new_mirrored_offset = new_offset + kNewCapacity + 1;
  596|  50.2k|  first_ctrl_bytes ^= (new_h2_xor_empty << (8 * new_mirrored_offset));
  597|       |
  598|       |  // Fill last bytes with kEmpty.
  599|  50.2k|  std::memset(new_ctrl + kNewCapacity, static_cast<int8_t>(ctrl_t::kEmpty),
  600|  50.2k|              Group::kWidth);
  601|       |  // Overwrite the first 8 bytes with first_ctrl_bytes.
  602|  50.2k|  absl::little_endian::Store64(new_ctrl, first_ctrl_bytes);
  603|       |
  604|       |  // Example for group size 16:
  605|       |  // new_ctrl after 1st memset =      ???EEEEEEEEEEEEEEEE
  606|       |  // new_offset 0:
  607|       |  // new_ctrl after 2nd store  =      NHESNHEEEEEEEEEEEEE
  608|       |  // new_offset 2:
  609|       |  // new_ctrl after 2nd store  =      EHNSEHNEEEEEEEEEEEE
  610|       |
  611|       |  // Example for group size 8:
  612|       |  // new_ctrl after 1st memset =      ???EEEEEEEE
  613|       |  // new_offset 0:
  614|       |  // new_ctrl after 2nd store  =      NHESNHEEEEE
  615|       |  // new_offset 2:
  616|       |  // new_ctrl after 2nd store  =      EHNSEHNEEEE
  617|  50.2k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_112WasNeverFullERNS1_12CommonFieldsEm:
  513|  47.5k|bool WasNeverFull(CommonFields& c, size_t index) {
  514|  47.5k|  if (is_single_group(c.capacity())) {
  ------------------
  |  Branch (514:7): [True: 1.66k, False: 45.8k]
  ------------------
  515|  1.66k|    return true;
  516|  1.66k|  }
  517|  45.8k|  const size_t index_before = (index - Group::kWidth) & c.capacity();
  518|  45.8k|  const auto empty_after = Group(c.control() + index).MaskEmpty();
  519|  45.8k|  const auto empty_before = Group(c.control() + index_before).MaskEmpty();
  520|       |
  521|       |  // We count how many consecutive non empties we have to the right and to the
  522|       |  // left of `it`. If the sum is >= kWidth then there is at least one probe
  523|       |  // window that might have seen a full group.
  524|  45.8k|  return empty_before && empty_after &&
  ------------------
  |  Branch (524:10): [True: 42.1k, False: 3.70k]
  |  Branch (524:26): [True: 39.3k, False: 2.77k]
  ------------------
  525|  39.3k|         static_cast<size_t>(empty_after.TrailingZeros()) +
  ------------------
  |  Branch (525:10): [True: 36.9k, False: 2.39k]
  ------------------
  526|  39.3k|                 empty_before.LeadingZeros() <
  527|  39.3k|             Group::kWidth;
  528|  47.5k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_17SetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  357|  3.80M|                    size_t slot_size) {
  358|       |  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   62|  3.80M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  359|  3.80M|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  360|  3.80M|  ctrl_t* ctrl = c.control();
  361|  3.80M|  ctrl[i] = h;
  362|  3.80M|  ctrl[((i - NumClonedBytes()) & c.capacity()) +
  363|  3.80M|       (NumClonedBytes() & c.capacity())] = h;
  364|  3.80M|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119DoSanitizeOnSetCtrlERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  342|  4.08M|                                size_t slot_size) {
  343|  4.08M|  ABSL_SWISSTABLE_ASSERT(i < c.capacity());
  ------------------
  |  |   62|  4.08M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  344|  4.08M|  auto* slot_i = static_cast<const char*>(c.slot_array()) + i * slot_size;
  345|  4.08M|  if (IsFull(h)) {
  ------------------
  |  Branch (345:7): [True: 4.03M, False: 47.5k]
  ------------------
  346|  4.03M|    SanitizerUnpoisonMemoryRegion(slot_i, slot_size);
  347|  4.03M|  } else {
  348|  47.5k|    SanitizerPoisonMemoryRegion(slot_i, slot_size);
  349|  47.5k|  }
  350|  4.08M|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119SetCtrlInLargeTableERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  390|   193k|                                size_t slot_size) {
  391|       |  ABSL_SWISSTABLE_ASSERT(c.capacity() >= Group::kWidth - 1);
  ------------------
  |  |   62|   193k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  392|   193k|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  393|   193k|  ctrl_t* ctrl = c.control();
  394|   193k|  ctrl[i] = h;
  395|   193k|  ctrl[((i - NumClonedBytes()) & c.capacity()) + NumClonedBytes()] = h;
  396|   193k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_19ResetCtrlERNS1_12CommonFieldsEm:
  532|  9.81k|void ResetCtrl(CommonFields& common, size_t slot_size) {
  533|  9.81k|  const size_t capacity = common.capacity();
  534|  9.81k|  ctrl_t* ctrl = common.control();
  535|  9.81k|  static constexpr size_t kTwoGroupCapacity = 2 * Group::kWidth - 1;
  536|  9.81k|  if (ABSL_PREDICT_TRUE(capacity <= kTwoGroupCapacity)) {
  ------------------
  |  |  191|  9.81k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 5.40k, False: 4.41k]
  |  |  |  Branch (191:48): [Folded, False: 9.81k]
  |  |  |  Branch (191:57): [True: 5.40k, False: 4.41k]
  |  |  ------------------
  ------------------
  537|  5.40k|    if (IsSmallCapacity(capacity)) return;
  ------------------
  |  Branch (537:9): [True: 125, False: 5.28k]
  ------------------
  538|  5.28k|    std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
  539|  5.28k|    std::memset(ctrl + capacity, static_cast<int8_t>(ctrl_t::kEmpty),
  540|  5.28k|                Group::kWidth);
  541|  5.28k|    if (capacity == kTwoGroupCapacity) {
  ------------------
  |  Branch (541:9): [True: 2.24k, False: 3.03k]
  ------------------
  542|  2.24k|      std::memset(ctrl + Group::kWidth, static_cast<int8_t>(ctrl_t::kEmpty),
  543|  2.24k|                  Group::kWidth);
  544|  2.24k|    }
  545|  5.28k|  } else {
  546|  4.41k|    std::memset(ctrl, static_cast<int8_t>(ctrl_t::kEmpty),
  547|  4.41k|                capacity + 1 + NumClonedBytes());
  548|  4.41k|  }
  549|  9.69k|  ctrl[capacity] = ctrl_t::kSentinel;
  550|  9.69k|  SanitizerPoisonMemoryRegion(common.slot_array(), slot_size * capacity);
  551|  9.69k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_115ResetGrowthLeftERNS1_12CommonFieldsE:
  306|  3.99k|void ResetGrowthLeft(CommonFields& common) {
  307|  3.99k|  ResetGrowthLeft(common.growth_info(), common.capacity(), common.size());
  308|  3.99k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_115ResetGrowthLeftERNS1_10GrowthInfoEmm:
  302|   167k|void ResetGrowthLeft(GrowthInfo& growth_info, size_t capacity, size_t size) {
  303|   167k|  growth_info.InitGrowthLeftNoDeleted(CapacityToGrowth(capacity) - size);
  304|   167k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_124ClearBackingArrayNoReuseERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
  624|  2.46k|                              void* alloc) {
  625|  2.46k|  ABSL_SWISSTABLE_ASSERT(c.capacity() > policy.soo_capacity());
  ------------------
  |  |   62|  2.46k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  626|       |  // We need to record infoz before calling dealloc, which will unregister
  627|       |  // infoz.
  628|  2.46k|  c.infoz().RecordClearedReservation();
  629|  2.46k|  c.infoz().RecordStorageChanged(0, policy.soo_capacity());
  630|  2.46k|  c.infoz().Unregister();
  631|  2.46k|  (*policy.dealloc)(alloc, c.capacity(), c.control(), policy.slot_size,
  632|  2.46k|                    policy.slot_align, c.has_infoz());
  633|  2.46k|  c = policy.soo_enabled ? CommonFields{soo_tag_t{}}
  ------------------
  |  Branch (633:7): [True: 409, False: 2.05k]
  ------------------
  634|  2.46k|                         : CommonFields{non_soo_tag_t{}};
  635|  2.46k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_117AllocBackingArrayERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmbPv:
  776|   261k|                                   void* alloc) {
  777|   261k|  RawHashSetLayout layout(new_capacity, policy.slot_size, policy.slot_align,
  778|   261k|                          has_infoz);
  779|       |  // Perform a direct call in the common case to allow for profile-guided
  780|       |  // heap optimization (PGHO) to understand which allocation function is used.
  781|   261k|  constexpr size_t kDefaultAlignment = BackingArrayAlignment(alignof(size_t));
  782|   261k|  char* mem = static_cast<char*>(
  783|   261k|      ABSL_PREDICT_TRUE(
  ------------------
  |  |  191|   261k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 261k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 261k]
  |  |  |  Branch (191:57): [True: 261k, False: 0]
  |  |  ------------------
  ------------------
  784|   261k|          policy.alloc ==
  785|   261k|          (&AllocateBackingArray<kDefaultAlignment, std::allocator<char>>))
  786|   261k|          ? AllocateBackingArray<kDefaultAlignment, std::allocator<char>>(
  787|   261k|                alloc, layout.alloc_size())
  788|   261k|          : policy.alloc(alloc, layout.alloc_size()));
  789|   261k|  const GenerationType old_generation = common.generation();
  790|   261k|  common.set_generation_ptr(
  791|   261k|      reinterpret_cast<GenerationType*>(mem + layout.generation_offset()));
  792|   261k|  common.set_generation(NextGeneration(old_generation));
  793|       |
  794|   261k|  return {reinterpret_cast<ctrl_t*>(mem + layout.control_offset()),
  795|   261k|          mem + layout.slot_offset()};
  796|   261k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_19AssertSooERNS1_12CommonFieldsERKNS1_15PolicyFunctionsE:
  906|  9.84k|               [[maybe_unused]] const PolicyFunctions& policy) {
  907|  9.84k|  ABSL_SWISSTABLE_ASSERT(policy.soo_enabled);
  ------------------
  |  |   62|  9.84k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  908|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() == policy.soo_capacity());
  ------------------
  |  |   62|  9.84k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  909|  9.84k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_124IncrementSmallSizeNonSooERNS1_12CommonFieldsERKNS1_15PolicyFunctionsE:
 1397|    125|                              const PolicyFunctions& __restrict policy) {
 1398|       |  ABSL_SWISSTABLE_ASSERT(common.is_small());
  ------------------
  |  |   62|    125|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1399|    125|  common.increment_size();
 1400|    125|  SanitizerUnpoisonMemoryRegion(common.slot_array(), policy.slot_size);
 1401|    125|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_124Grow1To3AndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsENS0_11FunctionRefIFmmEEE:
 1415|  40.3k|    absl::FunctionRef<size_t(size_t)> get_hash) {
 1416|       |  // TODO(b/413062340): Refactor to reuse more code with
 1417|       |  // GrowSooTableToNextCapacityAndPrepareInsert.
 1418|  40.3k|  ABSL_SWISSTABLE_ASSERT(common.capacity() == 1);
  ------------------
  |  |   62|  40.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1419|  40.3k|  ABSL_SWISSTABLE_ASSERT(!common.empty());
  ------------------
  |  |   62|  40.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1420|  40.3k|  ABSL_SWISSTABLE_ASSERT(!policy.soo_enabled);
  ------------------
  |  |   62|  40.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1421|  40.3k|  constexpr size_t kOldCapacity = 1;
 1422|  40.3k|  constexpr size_t kNewCapacity = NextCapacity(kOldCapacity);
 1423|  40.3k|  ctrl_t* old_ctrl = common.control();
 1424|  40.3k|  void* old_slots = common.slot_array();
 1425|       |
 1426|  40.3k|  const size_t slot_size = policy.slot_size;
 1427|  40.3k|  const size_t slot_align = policy.slot_align;
 1428|  40.3k|  void* alloc = policy.get_char_alloc(common);
 1429|  40.3k|  HashtablezInfoHandle infoz = common.infoz();
 1430|  40.3k|  const bool has_infoz = infoz.IsSampled();
 1431|  40.3k|  common.set_capacity(kNewCapacity);
 1432|       |
 1433|  40.3k|  const auto [new_ctrl, new_slots] =
 1434|  40.3k|      AllocBackingArray(common, policy, kNewCapacity, has_infoz, alloc);
 1435|  40.3k|  common.set_control(new_ctrl);
 1436|  40.3k|  common.set_slots(new_slots);
 1437|  40.3k|  SanitizerPoisonMemoryRegion(new_slots, kNewCapacity * slot_size);
 1438|       |
 1439|  40.3k|  if (ABSL_PREDICT_TRUE(!has_infoz)) {
  ------------------
  |  |  191|  40.3k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 40.3k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 40.3k]
  |  |  |  Branch (191:57): [True: 40.3k, False: 0]
  |  |  ------------------
  ------------------
 1440|       |    // When we're sampled, we already have a seed.
 1441|  40.3k|    common.generate_new_seed(/*has_infoz=*/false);
 1442|  40.3k|  }
 1443|  40.3k|  const size_t new_hash = get_hash(common.seed().seed());
 1444|  40.3k|  h2_t new_h2 = H2(new_hash);
 1445|  40.3k|  size_t orig_hash =
 1446|  40.3k|      policy.hash_slot(policy.hash_fn(common), old_slots, common.seed().seed());
 1447|  40.3k|  size_t offset = Resize1To3NewOffset(new_hash, common.seed());
 1448|  40.3k|  InitializeThreeElementsControlBytes(H2(orig_hash), new_h2, offset, new_ctrl);
 1449|       |
 1450|  40.3k|  void* old_element_target = NextSlot(new_slots, slot_size);
 1451|  40.3k|  SanitizerUnpoisonMemoryRegion(old_element_target, slot_size);
 1452|  40.3k|  policy.transfer_n(&common, old_element_target, old_slots, 1);
 1453|       |
 1454|  40.3k|  void* new_element_target_slot = SlotAddress(new_slots, offset, slot_size);
 1455|  40.3k|  SanitizerUnpoisonMemoryRegion(new_element_target_slot, slot_size);
 1456|       |
 1457|  40.3k|  policy.dealloc(alloc, kOldCapacity, old_ctrl, slot_size, slot_align,
 1458|  40.3k|                 has_infoz);
 1459|  40.3k|  PrepareInsertCommon(common);
 1460|  40.3k|  ABSL_SWISSTABLE_ASSERT(common.size() == 2);
  ------------------
  |  |   62|  40.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1461|  40.3k|  GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(kNewCapacity - 2);
 1462|       |
 1463|  40.3k|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|  40.3k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 40.3k]
  |  |  |  Branch (190:49): [Folded, False: 40.3k]
  |  |  |  Branch (190:58): [True: 0, False: 40.3k]
  |  |  ------------------
  ------------------
 1464|      0|    ReportSingleGroupTableGrowthToInfoz(common, infoz, new_hash);
 1465|      0|  }
 1466|  40.3k|  return {new_ctrl + offset, new_element_target_slot};
 1467|  40.3k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_18NextSlotEPvmm:
  123|   439k|inline void* NextSlot(void* slot, size_t slot_size, size_t i = 1) {
  124|   439k|  return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(slot) +
  125|   439k|                                 slot_size * i);
  126|   439k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_125SetCtrlInSingleGroupTableERKNS1_12CommonFieldsEmhm:
  383|  84.6k|                                      size_t slot_size) {
  384|  84.6k|  SetCtrlInSingleGroupTable(c, i, static_cast<ctrl_t>(h), slot_size);
  385|  84.6k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_125SetCtrlInSingleGroupTableERKNS1_12CommonFieldsEmNS1_6ctrl_tEm:
  373|  84.6k|                                      size_t slot_size) {
  374|  84.6k|  ABSL_SWISSTABLE_ASSERT(!c.is_small());
  ------------------
  |  |   62|  84.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  375|       |  ABSL_SWISSTABLE_ASSERT(is_single_group(c.capacity()));
  ------------------
  |  |   62|  84.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  376|  84.6k|  DoSanitizeOnSetCtrl(c, i, h, slot_size);
  377|  84.6k|  ctrl_t* ctrl = c.control();
  378|  84.6k|  ctrl[i] = h;
  379|  84.6k|  ctrl[i + c.capacity() + 1] = h;
  380|  84.6k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119ValidateMaxCapacityEmmm:
   70|  5.83k|void ValidateMaxCapacity(size_t capacity, size_t key_size, size_t slot_size) {
   71|  5.83k|  if (capacity <= 1) return;
  ------------------
  |  Branch (71:7): [True: 125, False: 5.70k]
  ------------------
   72|  5.70k|  ValidateMaxSize(CapacityToGrowth(PreviousCapacity(capacity)), key_size,
   73|  5.70k|                  slot_size);
   74|  5.70k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_115ValidateMaxSizeEmmm:
   67|  5.70k|                     [[maybe_unused]] size_t slot_size) {
   68|       |  ABSL_SWISSTABLE_ASSERT(size <= MaxValidSize(key_size, slot_size));
  ------------------
  |  |   62|  5.70k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
   69|  5.70k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_132ResizeEmptyNonAllocatedTableImplERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmb:
  854|  5.83k|                                      size_t new_capacity, bool force_infoz) {
  855|  5.83k|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(new_capacity));
  ------------------
  |  |   62|  5.83k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  856|  5.83k|  ABSL_SWISSTABLE_ASSERT(new_capacity > policy.soo_capacity());
  ------------------
  |  |   62|  5.83k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  857|  5.83k|  ABSL_SWISSTABLE_ASSERT(!force_infoz || policy.soo_enabled);
  ------------------
  |  |   62|  5.83k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  858|  5.83k|  ABSL_SWISSTABLE_ASSERT(common.capacity() <= policy.soo_capacity());
  ------------------
  |  |   62|  5.83k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  859|  5.83k|  ABSL_SWISSTABLE_ASSERT(common.empty());
  ------------------
  |  |   62|  5.83k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  860|  5.83k|  const size_t slot_size = policy.slot_size;
  861|  5.83k|  HashtablezInfoHandle infoz;
  862|  5.83k|  const bool should_sample =
  863|  5.83k|      policy.is_hashtablez_eligible && (force_infoz || ShouldSampleNextTable());
  ------------------
  |  Branch (863:7): [True: 5.83k, False: 0]
  |  Branch (863:41): [True: 0, False: 5.83k]
  |  Branch (863:56): [True: 0, False: 5.83k]
  ------------------
  864|  5.83k|  if (ABSL_PREDICT_FALSE(should_sample)) {
  ------------------
  |  |  190|  5.83k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 5.83k]
  |  |  |  Branch (190:49): [Folded, False: 5.83k]
  |  |  |  Branch (190:58): [True: 0, False: 5.83k]
  |  |  ------------------
  ------------------
  865|      0|    infoz = ForcedTrySample(slot_size, policy.key_size, policy.value_size,
  866|      0|                            policy.soo_capacity());
  867|      0|  }
  868|  5.83k|  ResizeNonSooImpl<ResizeNonSooMode::kGuaranteedEmpty>(common, policy,
  869|  5.83k|                                                       new_capacity, infoz);
  870|  5.83k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_116ResizeNonSooImplILNS2_16ResizeNonSooModeE0EEEvRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_20HashtablezInfoHandleE:
  801|  5.83k|                      size_t new_capacity, HashtablezInfoHandle infoz) {
  802|  5.83k|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(new_capacity));
  ------------------
  |  |   62|  5.83k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  803|  5.83k|  ABSL_SWISSTABLE_ASSERT(new_capacity > policy.soo_capacity());
  ------------------
  |  |   62|  5.83k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  804|       |
  805|  5.83k|  [[maybe_unused]] const size_t old_capacity = common.capacity();
  806|  5.83k|  [[maybe_unused]] ctrl_t* old_ctrl;
  807|  5.83k|  [[maybe_unused]] void* old_slots;
  808|       |  if constexpr (kMode == ResizeNonSooMode::kGuaranteedAllocated) {
  809|       |    old_ctrl = common.control();
  810|       |    old_slots = common.slot_array();
  811|       |  }
  812|       |
  813|  5.83k|  const size_t slot_size = policy.slot_size;
  814|  5.83k|  [[maybe_unused]] const size_t slot_align = policy.slot_align;
  815|  5.83k|  const bool has_infoz = infoz.IsSampled();
  816|  5.83k|  void* alloc = policy.get_char_alloc(common);
  817|       |
  818|  5.83k|  common.set_capacity(new_capacity);
  819|  5.83k|  const auto [new_ctrl, new_slots] =
  820|  5.83k|      AllocBackingArray(common, policy, new_capacity, has_infoz, alloc);
  821|  5.83k|  common.set_control(new_ctrl);
  822|  5.83k|  common.set_slots(new_slots);
  823|  5.83k|  common.generate_new_seed(has_infoz);
  824|       |
  825|  5.83k|  size_t total_probe_length = 0;
  826|  5.83k|  ResetCtrl(common, slot_size);
  827|  5.83k|  ABSL_SWISSTABLE_ASSERT(kMode != ResizeNonSooMode::kGuaranteedEmpty ||
  ------------------
  |  |   62|  5.83k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  828|  5.83k|                         old_capacity == policy.soo_capacity());
  829|  5.83k|  ABSL_SWISSTABLE_ASSERT(kMode != ResizeNonSooMode::kGuaranteedAllocated ||
  ------------------
  |  |   62|  5.83k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  830|  5.83k|                         old_capacity > 0);
  831|       |  if constexpr (kMode == ResizeNonSooMode::kGuaranteedAllocated) {
  832|       |    total_probe_length = FindNewPositionsAndTransferSlots(
  833|       |        common, policy, old_ctrl, old_slots, old_capacity);
  834|       |    (*policy.dealloc)(alloc, old_capacity, old_ctrl, slot_size, slot_align,
  835|       |                      has_infoz);
  836|       |    if (HasGrowthInfoForCapacity(new_capacity)) {
  837|       |      ResetGrowthLeft(GetGrowthInfoFromControl(new_ctrl), new_capacity,
  838|       |                      common.size());
  839|       |    }
  840|  5.83k|  } else {
  841|  5.83k|    if (HasGrowthInfoForCapacity(new_capacity)) {
  ------------------
  |  Branch (841:9): [True: 5.70k, False: 125]
  ------------------
  842|  5.70k|      GetGrowthInfoFromControl(new_ctrl).InitGrowthLeftNoDeleted(
  843|  5.70k|          CapacityToGrowth(new_capacity));
  844|  5.70k|    }
  845|  5.83k|  }
  846|       |
  847|  5.83k|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|  5.83k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 5.83k]
  |  |  |  Branch (190:49): [Folded, False: 5.83k]
  |  |  |  Branch (190:58): [True: 0, False: 5.83k]
  |  |  ------------------
  ------------------
  848|      0|    ReportResizeToInfoz(common, infoz, total_probe_length);
  849|      0|  }
  850|  5.83k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_17SetCtrlERKNS1_12CommonFieldsEmhm:
  366|  3.76M|inline void SetCtrl(const CommonFields& c, size_t i, h2_t h, size_t slot_size) {
  367|  3.76M|  SetCtrl(c, i, static_cast<ctrl_t>(h), slot_size);
  368|  3.76M|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_122PrepareInsertLargeImplERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmNS1_18NonIterableBitMaskIjLi16ELi0EEENS1_8FindInfoE:
 1990|  4.00M|                              FindInfo target_group) {
 1991|  4.00M|  ABSL_SWISSTABLE_ASSERT(!common.is_small());
  ------------------
  |  |   62|  4.00M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1992|  4.00M|  const GrowthInfo growth_info = common.growth_info();
 1993|       |  // When there are no deleted slots in the table
 1994|       |  // and growth_left is positive, we can insert at the first
 1995|       |  // empty slot in the probe sequence (target).
 1996|  4.00M|  if (ABSL_PREDICT_FALSE(!growth_info.HasNoDeletedAndGrowthLeft())) {
  ------------------
  |  |  190|  4.00M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 236k, False: 3.76M]
  |  |  |  Branch (190:49): [Folded, False: 4.00M]
  |  |  |  Branch (190:58): [True: 236k, False: 3.76M]
  |  |  ------------------
  ------------------
 1997|   236k|    return PrepareInsertLargeSlow(common, policy, hash);
 1998|   236k|  }
 1999|  3.76M|  PrepareInsertCommon(common);
 2000|  3.76M|  common.growth_info().OverwriteEmptyAsFull();
 2001|  3.76M|  target_group.offset += mask_empty.LowestBitSet();
 2002|  3.76M|  target_group.offset &= common.capacity();
 2003|  3.76M|  SetCtrl(common, target_group.offset, H2(hash), policy.slot_size);
 2004|  3.76M|  common.infoz().RecordInsertMiss(hash, target_group.probe_length);
 2005|  3.76M|  return target_group.offset;
 2006|  4.00M|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_122PrepareInsertLargeSlowERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1653|   236k|                              size_t hash) {
 1654|   236k|  const GrowthInfo growth_info = common.growth_info();
 1655|   236k|  ABSL_SWISSTABLE_ASSERT(!growth_info.HasNoDeletedAndGrowthLeft());
  ------------------
  |  |   62|   236k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1656|   236k|  if (ABSL_PREDICT_TRUE(growth_info.HasNoGrowthLeftAndNoDeleted())) {
  ------------------
  |  |  191|   236k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 162k, False: 73.8k]
  |  |  |  Branch (191:48): [Folded, False: 236k]
  |  |  |  Branch (191:57): [True: 162k, False: 73.8k]
  |  |  ------------------
  ------------------
 1657|       |    // Table without deleted slots (>95% cases) that needs to be resized.
 1658|   162k|    ABSL_SWISSTABLE_ASSERT(growth_info.HasNoDeleted() &&
  ------------------
  |  |   62|   162k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1659|   162k|                           growth_info.GetGrowthLeft() == 0);
 1660|   162k|    return GrowToNextCapacityAndPrepareInsert(common, policy, hash);
 1661|   162k|  }
 1662|  73.8k|  if (ABSL_PREDICT_FALSE(growth_info.HasNoGrowthLeftAssumingMayHaveDeleted())) {
  ------------------
  |  |  190|  73.8k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 669, False: 73.1k]
  |  |  |  Branch (190:49): [Folded, False: 73.8k]
  |  |  |  Branch (190:58): [True: 669, False: 73.1k]
  |  |  ------------------
  ------------------
 1663|       |    // Table with deleted slots that needs to be rehashed or resized.
 1664|    669|    return RehashOrGrowToNextCapacityAndPrepareInsert(common, policy, hash);
 1665|    669|  }
 1666|       |  // Table with deleted slots that has space for the inserting element.
 1667|  73.1k|  FindInfo target = find_first_non_full(common, hash);
 1668|  73.1k|  PrepareInsertCommon(common);
 1669|  73.1k|  common.growth_info().OverwriteControlAsFull(common.control()[target.offset]);
 1670|  73.1k|  SetCtrlInLargeTable(common, target.offset, H2(hash), policy.slot_size);
 1671|  73.1k|  common.infoz().RecordInsertMiss(hash, target.probe_length);
 1672|  73.1k|  return target.offset;
 1673|  73.8k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_134GrowToNextCapacityAndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1473|   163k|    size_t new_hash) {
 1474|   163k|  ABSL_SWISSTABLE_ASSERT(common.growth_left() == 0);
  ------------------
  |  |   62|   163k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1475|   163k|  const size_t old_capacity = common.capacity();
 1476|   163k|  ABSL_SWISSTABLE_ASSERT(old_capacity > policy.soo_capacity());
  ------------------
  |  |   62|   163k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1477|   163k|  ABSL_SWISSTABLE_ASSERT(!IsSmallCapacity(old_capacity));
  ------------------
  |  |   62|   163k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1478|       |
 1479|   163k|  const size_t new_capacity = NextCapacity(old_capacity);
 1480|   163k|  ctrl_t* old_ctrl = common.control();
 1481|   163k|  void* old_slots = common.slot_array();
 1482|       |
 1483|   163k|  common.set_capacity(new_capacity);
 1484|   163k|  const size_t slot_size = policy.slot_size;
 1485|   163k|  const size_t slot_align = policy.slot_align;
 1486|   163k|  void* alloc = policy.get_char_alloc(common);
 1487|   163k|  HashtablezInfoHandle infoz = common.infoz();
 1488|   163k|  const bool has_infoz = infoz.IsSampled();
 1489|       |
 1490|   163k|  const auto [new_ctrl, new_slots] =
 1491|   163k|      AllocBackingArray(common, policy, new_capacity, has_infoz, alloc);
 1492|   163k|  common.set_control(new_ctrl);
 1493|   163k|  common.set_slots(new_slots);
 1494|   163k|  SanitizerPoisonMemoryRegion(new_slots, new_capacity * slot_size);
 1495|       |
 1496|   163k|  h2_t new_h2 = H2(new_hash);
 1497|   163k|  size_t total_probe_length = 0;
 1498|   163k|  FindInfo find_info;
 1499|   163k|  if (ABSL_PREDICT_TRUE(is_single_group(new_capacity))) {
  ------------------
  |  |  191|   163k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 84.6k, False: 78.4k]
  |  |  |  Branch (191:48): [Folded, False: 163k]
  |  |  |  Branch (191:57): [True: 84.6k, False: 78.4k]
  |  |  ------------------
  ------------------
 1500|  84.6k|    size_t offset;
 1501|  84.6k|    GrowIntoSingleGroupShuffleControlBytes(old_ctrl, old_capacity, new_ctrl,
 1502|  84.6k|                                           new_capacity);
 1503|       |    // We put the new element either at the beginning or at the end of the
 1504|       |    // table with approximately equal probability.
 1505|  84.6k|    offset =
 1506|  84.6k|        SingleGroupTableH1(new_hash, common.seed()) & 1 ? 0 : new_capacity - 1;
  ------------------
  |  Branch (1506:9): [True: 42.6k, False: 42.0k]
  ------------------
 1507|       |
 1508|  84.6k|    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[offset]));
  ------------------
  |  |   62|  84.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1509|  84.6k|    SetCtrlInSingleGroupTable(common, offset, new_h2, policy.slot_size);
 1510|  84.6k|    find_info = FindInfo{offset, 0};
 1511|       |    // Single group tables have all slots full on resize. So we can transfer
 1512|       |    // all slots without checking the control bytes.
 1513|  84.6k|    ABSL_SWISSTABLE_ASSERT(common.size() == old_capacity);
  ------------------
  |  |   62|  84.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1514|  84.6k|    void* target = NextSlot(new_slots, slot_size);
 1515|  84.6k|    SanitizerUnpoisonMemoryRegion(target, old_capacity * slot_size);
 1516|  84.6k|    policy.transfer_n(&common, target, old_slots, old_capacity);
 1517|  84.6k|  } else {
 1518|  78.4k|    total_probe_length =
 1519|  78.4k|        GrowToNextCapacityDispatch(common, policy, old_ctrl, old_slots);
 1520|  78.4k|    find_info = find_first_non_full(common, new_hash);
 1521|  78.4k|    SetCtrlInLargeTable(common, find_info.offset, new_h2, policy.slot_size);
 1522|  78.4k|  }
 1523|   163k|  ABSL_SWISSTABLE_ASSERT(old_capacity > policy.soo_capacity());
  ------------------
  |  |   62|   163k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1524|   163k|  (*policy.dealloc)(alloc, old_capacity, old_ctrl, slot_size, slot_align,
 1525|   163k|                    has_infoz);
 1526|   163k|  PrepareInsertCommon(common);
 1527|   163k|  ResetGrowthLeft(GetGrowthInfoFromControl(new_ctrl), new_capacity,
 1528|   163k|                  common.size());
 1529|       |
 1530|   163k|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|   163k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 163k]
  |  |  |  Branch (190:49): [Folded, False: 163k]
  |  |  |  Branch (190:58): [True: 0, False: 163k]
  |  |  ------------------
  ------------------
 1531|      0|    ReportGrowthToInfoz(common, infoz, new_hash, total_probe_length,
 1532|      0|                        find_info.probe_length);
 1533|      0|  }
 1534|   163k|  return find_info.offset;
 1535|   163k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_138GrowIntoSingleGroupShuffleControlBytesEPNS1_6ctrl_tEmS4_m:
  957|  84.6k|                                            size_t new_capacity) {
  958|  84.6k|  ABSL_SWISSTABLE_ASSERT(is_single_group(new_capacity));
  ------------------
  |  |   62|  84.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  959|  84.6k|  constexpr size_t kHalfWidth = Group::kWidth / 2;
  960|  84.6k|  ABSL_ASSUME(old_capacity < kHalfWidth);
  ------------------
  |  |  271|  84.6k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  961|  84.6k|  ABSL_ASSUME(old_capacity > 0);
  ------------------
  |  |  271|  84.6k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  962|  84.6k|  static_assert(Group::kWidth == 8 || Group::kWidth == 16,
  963|  84.6k|                "Group size is not supported.");
  964|       |
  965|       |  // NOTE: operations are done with compile time known size = 8.
  966|       |  // Compiler optimizes that into single ASM operation.
  967|       |
  968|       |  // Load the bytes from old_capacity. This contains
  969|       |  // - the sentinel byte
  970|       |  // - all the old control bytes
  971|       |  // - the rest is filled with kEmpty bytes
  972|       |  // Example:
  973|       |  // old_ctrl =     012S012EEEEEEEEE...
  974|       |  // copied_bytes = S012EEEE
  975|  84.6k|  uint64_t copied_bytes = absl::little_endian::Load64(old_ctrl + old_capacity);
  976|       |
  977|       |  // We change the sentinel byte to kEmpty before storing to both the start of
  978|       |  // the new_ctrl, and past the end of the new_ctrl later for the new cloned
  979|       |  // bytes. Note that this is faster than setting the sentinel byte to kEmpty
  980|       |  // after the copy directly in new_ctrl because we are limited on store
  981|       |  // bandwidth.
  982|  84.6k|  static constexpr uint64_t kEmptyXorSentinel =
  983|  84.6k|      static_cast<uint8_t>(ctrl_t::kEmpty) ^
  984|  84.6k|      static_cast<uint8_t>(ctrl_t::kSentinel);
  985|       |
  986|       |  // Replace the first byte kSentinel with kEmpty.
  987|       |  // Resulting bytes will be shifted by one byte old control blocks.
  988|       |  // Example:
  989|       |  // old_ctrl = 012S012EEEEEEEEE...
  990|       |  // before =   S012EEEE
  991|       |  // after  =   E012EEEE
  992|  84.6k|  copied_bytes ^= kEmptyXorSentinel;
  993|       |
  994|  84.6k|  if (Group::kWidth == 8) {
  ------------------
  |  Branch (994:7): [Folded, False: 84.6k]
  ------------------
  995|       |    // With group size 8, we can grow with two write operations.
  996|      0|    ABSL_SWISSTABLE_ASSERT(old_capacity < 8 &&
  ------------------
  |  |   62|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  997|      0|                           "old_capacity is too large for group size 8");
  998|      0|    absl::little_endian::Store64(new_ctrl, copied_bytes);
  999|       |
 1000|      0|    static constexpr uint64_t kSentinal64 =
 1001|      0|        static_cast<uint8_t>(ctrl_t::kSentinel);
 1002|       |
 1003|       |    // Prepend kSentinel byte to the beginning of copied_bytes.
 1004|       |    // We have maximum 3 non-empty bytes at the beginning of copied_bytes for
 1005|       |    // group size 8.
 1006|       |    // Example:
 1007|       |    // old_ctrl = 012S012EEEE
 1008|       |    // before =   E012EEEE
 1009|       |    // after  =   SE012EEE
 1010|      0|    copied_bytes = (copied_bytes << 8) ^ kSentinal64;
 1011|      0|    absl::little_endian::Store64(new_ctrl + new_capacity, copied_bytes);
 1012|       |    // Example for capacity 3:
 1013|       |    // old_ctrl = 012S012EEEE
 1014|       |    // After the first store:
 1015|       |    //           >!
 1016|       |    // new_ctrl = E012EEEE???????
 1017|       |    // After the second store:
 1018|       |    //                  >!
 1019|       |    // new_ctrl = E012EEESE012EEE
 1020|      0|    return;
 1021|      0|  }
 1022|       |
 1023|  84.6k|  ABSL_SWISSTABLE_ASSERT(Group::kWidth == 16);  // NOLINT(misc-static-assert)
  ------------------
  |  |   62|  84.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1024|       |
 1025|       |  // Fill the second half of the main control bytes with kEmpty.
 1026|       |  // For small capacity that may write into mirrored control bytes.
 1027|       |  // It is fine as we will overwrite all the bytes later.
 1028|  84.6k|  std::memset(new_ctrl + kHalfWidth, static_cast<int8_t>(ctrl_t::kEmpty),
 1029|  84.6k|              kHalfWidth);
 1030|       |  // Fill the second half of the mirrored control bytes with kEmpty.
 1031|  84.6k|  std::memset(new_ctrl + new_capacity + kHalfWidth,
 1032|  84.6k|              static_cast<int8_t>(ctrl_t::kEmpty), kHalfWidth);
 1033|       |  // Copy the first half of the non-mirrored control bytes.
 1034|  84.6k|  absl::little_endian::Store64(new_ctrl, copied_bytes);
 1035|  84.6k|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
 1036|       |  // Copy the first half of the mirrored control bytes.
 1037|  84.6k|  absl::little_endian::Store64(new_ctrl + new_capacity + 1, copied_bytes);
 1038|       |
 1039|       |  // Example for growth capacity 1->3:
 1040|       |  // old_ctrl =                  0S0EEEEEEEEEEEEEE
 1041|       |  // new_ctrl at the end =       E0ESE0EEEEEEEEEEEEE
 1042|       |  //                                    >!
 1043|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???
 1044|       |  //                                       >!
 1045|       |  // new_ctrl after 2nd memset = ????????EEEEEEEEEEE
 1046|       |  //                            >!
 1047|       |  // new_ctrl after 1st store =  E0EEEEEEEEEEEEEEEEE
 1048|       |  // new_ctrl after kSentinel =  E0ESEEEEEEEEEEEEEEE
 1049|       |  //                                >!
 1050|       |  // new_ctrl after 2nd store =  E0ESE0EEEEEEEEEEEEE
 1051|       |
 1052|       |  // Example for growth capacity 3->7:
 1053|       |  // old_ctrl =                  012S012EEEEEEEEEEEE
 1054|       |  // new_ctrl at the end =       E012EEESE012EEEEEEEEEEE
 1055|       |  //                                    >!
 1056|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???????
 1057|       |  //                                           >!
 1058|       |  // new_ctrl after 2nd memset = ????????EEEEEEEEEEEEEEE
 1059|       |  //                            >!
 1060|       |  // new_ctrl after 1st store =  E012EEEEEEEEEEEEEEEEEEE
 1061|       |  // new_ctrl after kSentinel =  E012EEESEEEEEEEEEEEEEEE
 1062|       |  //                                >!
 1063|       |  // new_ctrl after 2nd store =  E012EEESE012EEEEEEEEEEE
 1064|       |
 1065|       |  // Example for growth capacity 7->15:
 1066|       |  // old_ctrl =                  0123456S0123456EEEEEEEE
 1067|       |  // new_ctrl at the end =       E0123456EEEEEEESE0123456EEEEEEE
 1068|       |  //                                    >!
 1069|       |  // new_ctrl after 1st memset = ????????EEEEEEEE???????????????
 1070|       |  //                                                   >!
 1071|       |  // new_ctrl after 2nd memset = ????????EEEEEEEE???????EEEEEEEE
 1072|       |  //                            >!
 1073|       |  // new_ctrl after 1st store =  E0123456EEEEEEEE???????EEEEEEEE
 1074|       |  // new_ctrl after kSentinel =  E0123456EEEEEEES???????EEEEEEEE
 1075|       |  //                                            >!
 1076|       |  // new_ctrl after 2nd store =  E0123456EEEEEEESE0123456EEEEEEE
 1077|  84.6k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_126GrowToNextCapacityDispatchERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1385|  78.4k|                                  ctrl_t* old_ctrl, void* old_slots) {
 1386|  78.4k|  const size_t new_capacity = common.capacity();
 1387|  78.4k|  if (ABSL_PREDICT_TRUE(new_capacity <= kMaxLocalBufferNewCapacity)) {
  ------------------
  |  |  191|  78.4k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 73.7k, False: 4.75k]
  |  |  |  Branch (191:48): [Folded, False: 78.4k]
  |  |  |  Branch (191:57): [True: 73.7k, False: 4.75k]
  |  |  ------------------
  ------------------
 1388|  73.7k|    return GrowToNextCapacityThatFitsInLocalBuffer(common, policy, old_ctrl,
 1389|  73.7k|                                                   old_slots);
 1390|  73.7k|  } else {
 1391|  4.75k|    return GrowToNextCapacityOverflowLocalBuffer(common, policy, old_ctrl,
 1392|  4.75k|                                                 old_slots);
 1393|  4.75k|  }
 1394|  78.4k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_139GrowToNextCapacityThatFitsInLocalBufferERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1335|  73.7k|    ctrl_t* old_ctrl, void* old_slots) {
 1336|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= kMaxLocalBufferNewCapacity);
  ------------------
  |  |   62|  73.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1337|  73.7k|  return GrowToNextCapacity<
 1338|  73.7k|      ProbedItemEncoder<ProbedItem4Bytes, /*kGuaranteedFitToBuffer=*/true>>(
 1339|  73.7k|      common, policy, old_ctrl, old_slots);
 1340|  73.7k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1316|  73.7k|                          ctrl_t* old_ctrl, void* old_slots) {
 1317|  73.7k|  using ProbedItem = typename Encoder::ProbedItem;
 1318|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   62|  73.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1319|  73.7k|  Encoder encoder(old_ctrl);
 1320|  73.7k|  policy.transfer_unprobed_elements_to_next_capacity(
 1321|  73.7k|      common, old_ctrl, old_slots, &encoder,
 1322|  73.7k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1323|  73.7k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1324|  73.7k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1325|  73.7k|      });
 1326|  73.7k|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1327|  73.7k|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1328|  73.7k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEC2EPNS1_6ctrl_tE:
 1190|  73.7k|  explicit ProbedItemEncoder(ctrl_t* control) : control_(control) {}
raw_hash_set.cc:_ZZN4absl12lts_2026052618container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPvENKUlSF_hmmE_clESF_hmm:
 1322|  24.0k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1323|  24.0k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1324|  24.0k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1325|  24.0k|      });
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EE10EncodeItemES5_:
 1193|  24.0k|  void EncodeItem(ProbedItem item) {
 1194|  24.0k|    if (ABSL_PREDICT_FALSE(!kGuaranteedFitToBuffer && pos_ >= end_)) {
  ------------------
  |  |  190|  24.0k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [Folded, False: 24.0k]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:59): [Folded, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1195|      0|      return ProcessEncodeWithOverflow(item);
 1196|      0|    }
 1197|  24.0k|    ABSL_SWISSTABLE_ASSERT(pos_ < end_);
  ------------------
  |  |   62|  24.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1198|  24.0k|    *pos_ = item;
 1199|  24.0k|    ++pos_;
 1200|  24.0k|  }
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_130InitializeMirroredControlBytesEPNS1_6ctrl_tEm:
 1166|  78.4k|void InitializeMirroredControlBytes(ctrl_t* new_ctrl, size_t new_capacity) {
 1167|  78.4k|  std::memcpy(new_ctrl + new_capacity,
 1168|       |              // We own GrowthInfo just before control bytes. So it is ok
 1169|       |              // to read one byte from it.
 1170|  78.4k|              new_ctrl - 1, Group::kWidth);
 1171|  78.4k|  new_ctrl[new_capacity] = ctrl_t::kSentinel;
 1172|  78.4k|}
raw_hash_set.cc:_ZNK4absl12lts_2026052618container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb1EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1207|  73.7k|                                void* old_slots) const {
 1208|  73.7k|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1208:9): [True: 60.0k, False: 13.6k]
  ------------------
 1209|  60.0k|      return 0;
 1210|  60.0k|    }
 1211|  13.6k|    if constexpr (kGuaranteedFitToBuffer) {
 1212|  13.6k|      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1213|  13.6k|    }
 1214|      0|    size_t total_probe_length = DecodeAndInsertImpl(
 1215|  13.6k|        common, policy, buffer_,
 1216|  13.6k|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1216:9): [True: 0, False: 13.6k]
  ------------------
 1217|  13.6k|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1217:9): [True: 0, False: 13.6k]
  ------------------
 1218|      0|      return total_probe_length;
 1219|      0|    }
 1220|  13.6k|    total_probe_length +=
 1221|  13.6k|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1222|  13.6k|    return total_probe_length;
 1223|  13.6k|  }
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119DecodeAndInsertImplINS1_14ProbedItemImplIjLm32EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPKT_SD_Pv:
 1089|  16.2k|    const ProbedItem* start, const ProbedItem* end, void* old_slots) {
 1090|  16.2k|  const HashtableCapacity new_capacity = c.capacity_impl();
 1091|       |
 1092|  16.2k|  void* new_slots = c.slot_array();
 1093|  16.2k|  ctrl_t* new_ctrl = c.control();
 1094|  16.2k|  size_t total_probe_length = 0;
 1095|       |
 1096|  16.2k|  const size_t slot_size = policy.slot_size;
 1097|  16.2k|  auto transfer_n = policy.transfer_n;
 1098|       |
 1099|  48.5k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1099:10): [True: 32.3k, False: 16.2k]
  ------------------
 1100|  32.3k|    const FindInfo target = find_first_non_full_from_h1(
 1101|  32.3k|        new_ctrl, static_cast<size_t>(start->h1), new_capacity);
 1102|  32.3k|    total_probe_length += target.probe_length;
 1103|  32.3k|    const size_t old_index = static_cast<size_t>(start->source_offset);
 1104|  32.3k|    const size_t new_i = target.offset;
 1105|  32.3k|    ABSL_SWISSTABLE_ASSERT(old_index < new_capacity.capacity() / 2);
  ------------------
  |  |   62|  32.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1106|  32.3k|    ABSL_SWISSTABLE_ASSERT(new_i < new_capacity.capacity());
  ------------------
  |  |   62|  32.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1107|       |    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_i]));
  ------------------
  |  |   62|  32.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1108|  32.3k|    void* src_slot = SlotAddress(old_slots, old_index, slot_size);
 1109|  32.3k|    void* dst_slot = SlotAddress(new_slots, new_i, slot_size);
 1110|  32.3k|    SanitizerUnpoisonMemoryRegion(dst_slot, slot_size);
 1111|  32.3k|    transfer_n(&c, dst_slot, src_slot, 1);
 1112|  32.3k|    SetCtrlInLargeTable(c, new_i, static_cast<h2_t>(start->h2), slot_size);
 1113|  32.3k|  }
 1114|  16.2k|  return total_probe_length;
 1115|  16.2k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_127find_first_non_full_from_h1EPKNS1_6ctrl_tEmNS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEE:
  188|   184k|                                     HashtableCapacity capacity) {
  189|   184k|  auto seq = probe_h1(capacity, h1);
  190|   184k|  if (IsEmptyOrDeleted(ctrl[seq.offset()])) {
  ------------------
  |  Branch (190:7): [True: 78.1k, False: 106k]
  ------------------
  191|  78.1k|    return {seq.offset(), /*probe_length=*/0};
  192|  78.1k|  }
  193|   106k|  auto mask = probe_till_first_non_full_group(ctrl, seq, capacity.capacity());
  194|   106k|  return {seq.offset(mask.LowestBitSet()), seq.index()};
  195|   184k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_131probe_till_first_non_full_groupEPKNS1_6ctrl_tERNS1_9probe_seqILm16EEEm:
  175|   106k|    [[maybe_unused]] size_t capacity) {
  176|   120k|  while (true) {
  ------------------
  |  Branch (176:10): [True: 120k, Folded]
  ------------------
  177|   120k|    GroupFullEmptyOrDeleted g{ctrl + seq.offset()};
  178|   120k|    auto mask = g.MaskEmptyOrDeleted();
  179|   120k|    if (mask) {
  ------------------
  |  Branch (179:9): [True: 106k, False: 14.5k]
  ------------------
  180|   106k|      return mask;
  181|   106k|    }
  182|  14.5k|    seq.next();
  183|       |    ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity && "full table!");
  ------------------
  |  |   62|  14.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  184|  14.5k|  }
  185|   106k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_137GrowToNextCapacityOverflowLocalBufferERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1368|  4.75k|    ctrl_t* old_ctrl, void* old_slots) {
 1369|  4.75k|  const size_t new_capacity = common.capacity();
 1370|  4.75k|  if (ABSL_PREDICT_TRUE(new_capacity <= ProbedItem4Bytes::kMaxNewCapacity)) {
  ------------------
  |  |  191|  4.75k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 4.74k, False: 5]
  |  |  |  Branch (191:48): [Folded, False: 4.75k]
  |  |  |  Branch (191:57): [True: 4.74k, False: 5]
  |  |  ------------------
  ------------------
 1371|  4.74k|    return GrowToNextCapacity4BytesEncoder(common, policy, old_ctrl, old_slots);
 1372|  4.74k|  }
 1373|      5|  if (ABSL_PREDICT_TRUE(new_capacity <= ProbedItem8Bytes::kMaxNewCapacity)) {
  ------------------
  |  |  191|      5|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 5, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 5]
  |  |  |  Branch (191:57): [True: 5, False: 0]
  |  |  ------------------
  ------------------
 1374|      5|    return GrowToNextCapacity8BytesEncoder(common, policy, old_ctrl, old_slots);
 1375|      5|  }
 1376|       |  // 16 bytes encoding supports the maximum swisstable capacity.
 1377|      0|  return GrowToNextCapacity16BytesEncoder(common, policy, old_ctrl, old_slots);
 1378|      5|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_131GrowToNextCapacity4BytesEncoderERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1346|  4.74k|                                       ctrl_t* old_ctrl, void* old_slots) {
 1347|  4.74k|  return GrowToNextCapacity<ProbedItemEncoder<ProbedItem4Bytes>>(
 1348|  4.74k|      common, policy, old_ctrl, old_slots);
 1349|  4.74k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1316|  4.74k|                          ctrl_t* old_ctrl, void* old_slots) {
 1317|  4.74k|  using ProbedItem = typename Encoder::ProbedItem;
 1318|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   62|  4.74k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1319|  4.74k|  Encoder encoder(old_ctrl);
 1320|  4.74k|  policy.transfer_unprobed_elements_to_next_capacity(
 1321|  4.74k|      common, old_ctrl, old_slots, &encoder,
 1322|  4.74k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1323|  4.74k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1324|  4.74k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1325|  4.74k|      });
 1326|  4.74k|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1327|  4.74k|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1328|  4.74k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EEC2EPNS1_6ctrl_tE:
 1190|  4.74k|  explicit ProbedItemEncoder(ctrl_t* control) : control_(control) {}
raw_hash_set.cc:_ZZN4absl12lts_2026052618container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPvENKUlSF_hmmE_clESF_hmm:
 1322|  8.29k|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1323|  8.29k|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1324|  8.29k|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1325|  8.29k|      });
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EE10EncodeItemES5_:
 1193|  8.29k|  void EncodeItem(ProbedItem item) {
 1194|  8.29k|    if (ABSL_PREDICT_FALSE(!kGuaranteedFitToBuffer && pos_ >= end_)) {
  ------------------
  |  |  190|  16.5k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 8.29k]
  |  |  |  Branch (190:49): [Folded, False: 8.29k]
  |  |  |  Branch (190:59): [True: 8.29k, Folded]
  |  |  |  Branch (190:59): [True: 0, False: 8.29k]
  |  |  ------------------
  ------------------
 1195|      0|      return ProcessEncodeWithOverflow(item);
 1196|      0|    }
 1197|  8.29k|    ABSL_SWISSTABLE_ASSERT(pos_ < end_);
  ------------------
  |  |   62|  8.29k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1198|  8.29k|    *pos_ = item;
 1199|  8.29k|    ++pos_;
 1200|  8.29k|  }
raw_hash_set.cc:_ZNK4absl12lts_2026052618container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplIjLm32EEELb0EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1207|  4.74k|                                void* old_slots) const {
 1208|  4.74k|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1208:9): [True: 2.19k, False: 2.55k]
  ------------------
 1209|  2.19k|      return 0;
 1210|  2.19k|    }
 1211|       |    if constexpr (kGuaranteedFitToBuffer) {
 1212|       |      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1213|       |    }
 1214|  2.55k|    size_t total_probe_length = DecodeAndInsertImpl(
 1215|  2.55k|        common, policy, buffer_,
 1216|  2.55k|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1216:9): [True: 0, False: 2.55k]
  ------------------
 1217|  2.55k|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1217:9): [True: 2.55k, False: 0]
  ------------------
 1218|  2.55k|      return total_probe_length;
 1219|  2.55k|    }
 1220|      0|    total_probe_length +=
 1221|      0|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1222|      0|    return total_probe_length;
 1223|  2.55k|  }
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_131GrowToNextCapacity8BytesEncoderERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1352|      5|                                       ctrl_t* old_ctrl, void* old_slots) {
 1353|      5|  return GrowToNextCapacity<ProbedItemEncoder<ProbedItem8Bytes>>(
 1354|      5|      common, policy, old_ctrl, old_slots);
 1355|      5|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPv:
 1316|      5|                          ctrl_t* old_ctrl, void* old_slots) {
 1317|      5|  using ProbedItem = typename Encoder::ProbedItem;
 1318|       |  ABSL_SWISSTABLE_ASSERT(common.capacity() <= ProbedItem::kMaxNewCapacity);
  ------------------
  |  |   62|      5|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1319|      5|  Encoder encoder(old_ctrl);
 1320|      5|  policy.transfer_unprobed_elements_to_next_capacity(
 1321|      5|      common, old_ctrl, old_slots, &encoder,
 1322|      5|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1323|      5|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1324|      5|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1325|      5|      });
 1326|      5|  InitializeMirroredControlBytes(common.control(), common.capacity());
 1327|      5|  return encoder.DecodeAndInsertToTable(common, policy, old_slots);
 1328|      5|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EEC2EPNS1_6ctrl_tE:
 1190|      5|  explicit ProbedItemEncoder(ctrl_t* control) : control_(control) {}
raw_hash_set.cc:_ZZN4absl12lts_2026052618container_internal12_GLOBAL__N_118GrowToNextCapacityINS2_17ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPNS1_6ctrl_tEPvENKUlSF_hmmE_clESF_hmm:
 1322|      7|      [](void* probed_storage, h2_t h2, size_t source_offset, size_t h1) {
 1323|      7|        auto encoder_ptr = static_cast<Encoder*>(probed_storage);
 1324|      7|        encoder_ptr->EncodeItem(ProbedItem(h2, source_offset, h1));
 1325|      7|      });
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EE10EncodeItemES5_:
 1193|      7|  void EncodeItem(ProbedItem item) {
 1194|      7|    if (ABSL_PREDICT_FALSE(!kGuaranteedFitToBuffer && pos_ >= end_)) {
  ------------------
  |  |  190|     14|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 7]
  |  |  |  Branch (190:49): [Folded, False: 7]
  |  |  |  Branch (190:59): [True: 7, Folded]
  |  |  |  Branch (190:59): [True: 0, False: 7]
  |  |  ------------------
  ------------------
 1195|      0|      return ProcessEncodeWithOverflow(item);
 1196|      0|    }
 1197|      7|    ABSL_SWISSTABLE_ASSERT(pos_ < end_);
  ------------------
  |  |   62|      7|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1198|      7|    *pos_ = item;
 1199|      7|    ++pos_;
 1200|      7|  }
raw_hash_set.cc:_ZNK4absl12lts_2026052618container_internal12_GLOBAL__N_117ProbedItemEncoderINS1_14ProbedItemImplImLm64EEELb0EE22DecodeAndInsertToTableERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPv:
 1207|      5|                                void* old_slots) const {
 1208|      5|    if (pos_ == buffer_) {
  ------------------
  |  Branch (1208:9): [True: 1, False: 4]
  ------------------
 1209|      1|      return 0;
 1210|      1|    }
 1211|       |    if constexpr (kGuaranteedFitToBuffer) {
 1212|       |      return DecodeAndInsertImpl(common, policy, buffer_, pos_, old_slots);
 1213|       |    }
 1214|      4|    size_t total_probe_length = DecodeAndInsertImpl(
 1215|      4|        common, policy, buffer_,
 1216|      4|        local_buffer_full_ ? buffer_ + kBufferSize : pos_, old_slots);
  ------------------
  |  Branch (1216:9): [True: 0, False: 4]
  ------------------
 1217|      4|    if (!local_buffer_full_) {
  ------------------
  |  Branch (1217:9): [True: 4, False: 0]
  ------------------
 1218|      4|      return total_probe_length;
 1219|      4|    }
 1220|      0|    total_probe_length +=
 1221|      0|        DecodeAndInsertToTableOverflow(common, policy, old_slots);
 1222|      0|    return total_probe_length;
 1223|      4|  }
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119DecodeAndInsertImplINS1_14ProbedItemImplImLm64EEEEEmRNS1_12CommonFieldsERKNS1_15PolicyFunctionsEPKT_SD_Pv:
 1089|      4|    const ProbedItem* start, const ProbedItem* end, void* old_slots) {
 1090|      4|  const HashtableCapacity new_capacity = c.capacity_impl();
 1091|       |
 1092|      4|  void* new_slots = c.slot_array();
 1093|      4|  ctrl_t* new_ctrl = c.control();
 1094|      4|  size_t total_probe_length = 0;
 1095|       |
 1096|      4|  const size_t slot_size = policy.slot_size;
 1097|      4|  auto transfer_n = policy.transfer_n;
 1098|       |
 1099|     11|  for (; start < end; ++start) {
  ------------------
  |  Branch (1099:10): [True: 7, False: 4]
  ------------------
 1100|      7|    const FindInfo target = find_first_non_full_from_h1(
 1101|      7|        new_ctrl, static_cast<size_t>(start->h1), new_capacity);
 1102|      7|    total_probe_length += target.probe_length;
 1103|      7|    const size_t old_index = static_cast<size_t>(start->source_offset);
 1104|      7|    const size_t new_i = target.offset;
 1105|      7|    ABSL_SWISSTABLE_ASSERT(old_index < new_capacity.capacity() / 2);
  ------------------
  |  |   62|      7|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1106|      7|    ABSL_SWISSTABLE_ASSERT(new_i < new_capacity.capacity());
  ------------------
  |  |   62|      7|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1107|       |    ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_i]));
  ------------------
  |  |   62|      7|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1108|      7|    void* src_slot = SlotAddress(old_slots, old_index, slot_size);
 1109|      7|    void* dst_slot = SlotAddress(new_slots, new_i, slot_size);
 1110|      7|    SanitizerUnpoisonMemoryRegion(dst_slot, slot_size);
 1111|      7|    transfer_n(&c, dst_slot, src_slot, 1);
 1112|      7|    SetCtrlInLargeTable(c, new_i, static_cast<h2_t>(start->h2), slot_size);
 1113|      7|  }
 1114|      4|  return total_probe_length;
 1115|      4|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_142RehashOrGrowToNextCapacityAndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
 1595|    669|    size_t new_hash) {
 1596|    669|  const size_t cap = common.capacity();
 1597|    669|  ABSL_ASSUME(cap > 0);
  ------------------
  |  |  271|    669|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1598|    669|  if (cap > Group::kWidth &&
  ------------------
  |  Branch (1598:7): [True: 669, False: 0]
  ------------------
 1599|       |      // Do these calculations in 64-bit to avoid overflow.
 1600|    669|      common.size() * uint64_t{32} <= cap * uint64_t{25}) {
  ------------------
  |  Branch (1600:7): [True: 10, False: 659]
  ------------------
 1601|       |    // Squash DELETED without growing if there is enough capacity.
 1602|       |    //
 1603|       |    // Rehash in place if the current size is <= 25/32 of capacity.
 1604|       |    // Rationale for such a high factor: 1) DropDeletesWithoutResize() is
 1605|       |    // faster than resize, and 2) it takes quite a bit of work to add
 1606|       |    // tombstones.  In the worst case, seems to take approximately 4
 1607|       |    // insert/erase pairs to create a single tombstone and so if we are
 1608|       |    // rehashing because of tombstones, we can afford to rehash-in-place as
 1609|       |    // long as we are reclaiming at least 1/8 the capacity without doing more
 1610|       |    // than 2X the work.  (Where "work" is defined to be size() for rehashing
 1611|       |    // or rehashing in place, and 1 for an insert or erase.)  But rehashing in
 1612|       |    // place is faster per operation than inserting or even doubling the size
 1613|       |    // of the table, so we actually afford to reclaim even less space from a
 1614|       |    // resize-in-place.  The decision is to rehash in place if we can reclaim
 1615|       |    // at about 1/8th of the usable capacity (specifically 3/28 of the
 1616|       |    // capacity) which means that the total cost of rehashing will be a small
 1617|       |    // fraction of the total work.
 1618|       |    //
 1619|       |    // Here is output of an experiment using the BM_CacheInSteadyState
 1620|       |    // benchmark running the old case (where we rehash-in-place only if we can
 1621|       |    // reclaim at least 7/16*capacity) vs. this code (which rehashes in place
 1622|       |    // if we can recover 3/32*capacity).
 1623|       |    //
 1624|       |    // Note that although in the worst-case number of rehashes jumped up from
 1625|       |    // 15 to 190, but the number of operations per second is almost the same.
 1626|       |    //
 1627|       |    // Abridged output of running BM_CacheInSteadyState benchmark from
 1628|       |    // raw_hash_set_benchmark.   N is the number of insert/erase operations.
 1629|       |    //
 1630|       |    //      | OLD (recover >= 7/16        | NEW (recover >= 3/32)
 1631|       |    // size |    N/s LoadFactor NRehashes |    N/s LoadFactor NRehashes
 1632|       |    //  448 | 145284       0.44        18 | 140118       0.44        19
 1633|       |    //  493 | 152546       0.24        11 | 151417       0.48        28
 1634|       |    //  538 | 151439       0.26        11 | 151152       0.53        38
 1635|       |    //  583 | 151765       0.28        11 | 150572       0.57        50
 1636|       |    //  628 | 150241       0.31        11 | 150853       0.61        66
 1637|       |    //  672 | 149602       0.33        12 | 150110       0.66        90
 1638|       |    //  717 | 149998       0.35        12 | 149531       0.70       129
 1639|       |    //  762 | 149836       0.37        13 | 148559       0.74       190
 1640|       |    //  807 | 149736       0.39        14 | 151107       0.39        14
 1641|       |    //  852 | 150204       0.42        15 | 151019       0.42        15
 1642|     10|    return DropDeletesWithoutResizeAndPrepareInsert(common, policy, new_hash);
 1643|    659|  } else {
 1644|       |    // Otherwise grow the container.
 1645|    659|    return GrowToNextCapacityAndPrepareInsert(common, policy, new_hash);
 1646|    659|  }
 1647|    669|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_140DropDeletesWithoutResizeAndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEm:
  405|     10|    size_t new_hash) {
  406|     10|  void* set = &common;
  407|     10|  void* slot_array = common.slot_array();
  408|     10|  const size_t capacity = common.capacity();
  409|     10|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |   62|     10|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  410|     10|  ABSL_SWISSTABLE_ASSERT(!is_single_group(capacity));
  ------------------
  |  |   62|     10|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  411|       |  // Algorithm:
  412|       |  // - mark all DELETED slots as EMPTY
  413|       |  // - mark all FULL slots as DELETED
  414|       |  // - for each slot marked as DELETED
  415|       |  //     hash = Hash(element)
  416|       |  //     target = find_first_non_full(hash)
  417|       |  //     if target is in the same group
  418|       |  //       mark slot as FULL
  419|       |  //     else if target is EMPTY
  420|       |  //       transfer element to target
  421|       |  //       mark slot as EMPTY
  422|       |  //       mark target as FULL
  423|       |  //     else if target is DELETED
  424|       |  //       swap current element with target element
  425|       |  //       mark target as FULL
  426|       |  //       repeat procedure for current slot with moved from element (target)
  427|     10|  ctrl_t* ctrl = common.control();
  428|     10|  ConvertDeletedToEmptyAndFullToDeleted(ctrl, capacity);
  429|     10|  const void* hash_fn = policy.hash_fn(common);
  430|     10|  auto hasher = policy.hash_slot;
  431|     10|  auto transfer_n = policy.transfer_n;
  432|     10|  const size_t slot_size = policy.slot_size;
  433|       |
  434|     10|  size_t total_probe_length = 0;
  435|     10|  void* slot_ptr = SlotAddress(slot_array, 0, slot_size);
  436|       |
  437|       |  // The index of an empty slot that can be used as temporary memory for
  438|       |  // the swap operation.
  439|     10|  constexpr size_t kUnknownId = ~size_t{};
  440|     10|  size_t tmp_space_id = kUnknownId;
  441|       |
  442|    811|  for (size_t i = 0; i != capacity;
  ------------------
  |  Branch (442:22): [True: 801, False: 10]
  ------------------
  443|    801|       ++i, slot_ptr = NextSlot(slot_ptr, slot_size)) {
  444|    801|    ABSL_SWISSTABLE_ASSERT(slot_ptr == SlotAddress(slot_array, i, slot_size));
  ------------------
  |  |   62|    801|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  445|    801|    if (IsEmpty(ctrl[i])) {
  ------------------
  |  Branch (445:9): [True: 188, False: 613]
  ------------------
  446|    188|      tmp_space_id = i;
  447|    188|      continue;
  448|    188|    }
  449|    613|    if (!IsDeleted(ctrl[i])) continue;
  ------------------
  |  Branch (449:9): [True: 12, False: 601]
  ------------------
  450|    601|    const size_t hash = (*hasher)(hash_fn, slot_ptr, common.seed().seed());
  451|    601|    const FindInfo target = find_first_non_full(common, hash);
  452|    601|    const size_t new_i = target.offset;
  453|    601|    total_probe_length += target.probe_length;
  454|       |
  455|       |    // Verify if the old and new i fall within the same group wrt the hash.
  456|       |    // If they do, we don't need to move the object as it falls already in the
  457|       |    // best probe we can.
  458|    601|    const size_t probe_offset = probe(common, hash).offset();
  459|    601|    const h2_t h2 = H2(hash);
  460|    601|    const auto probe_index = [probe_offset, capacity](size_t pos) {
  461|    601|      return ((pos - probe_offset) & capacity) / Group::kWidth;
  462|    601|    };
  463|       |
  464|       |    // Element doesn't move.
  465|    601|    if (ABSL_PREDICT_TRUE(probe_index(new_i) == probe_index(i))) {
  ------------------
  |  |  191|    601|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 575, False: 26]
  |  |  |  Branch (191:48): [Folded, False: 601]
  |  |  |  Branch (191:57): [True: 575, False: 26]
  |  |  ------------------
  ------------------
  466|    575|      SetCtrlInLargeTable(common, i, h2, slot_size);
  467|    575|      continue;
  468|    575|    }
  469|       |
  470|     26|    void* new_slot_ptr = SlotAddress(slot_array, new_i, slot_size);
  471|     26|    if (IsEmpty(ctrl[new_i])) {
  ------------------
  |  Branch (471:9): [True: 15, False: 11]
  ------------------
  472|       |      // Transfer element to the empty spot.
  473|       |      // SetCtrl poisons/unpoisons the slots so we have to call it at the
  474|       |      // right time.
  475|     15|      SetCtrlInLargeTable(common, new_i, h2, slot_size);
  476|     15|      (*transfer_n)(set, new_slot_ptr, slot_ptr, 1);
  477|     15|      SetCtrlInLargeTable(common, i, ctrl_t::kEmpty, slot_size);
  478|       |      // Initialize or change empty space id.
  479|     15|      tmp_space_id = i;
  480|     15|    } else {
  481|     11|      ABSL_SWISSTABLE_ASSERT(IsDeleted(ctrl[new_i]));
  ------------------
  |  |   62|     11|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  482|     11|      SetCtrlInLargeTable(common, new_i, h2, slot_size);
  483|       |      // Until we are done rehashing, DELETED marks previously FULL slots.
  484|       |
  485|     11|      if (tmp_space_id == kUnknownId) {
  ------------------
  |  Branch (485:11): [True: 1, False: 10]
  ------------------
  486|      1|        tmp_space_id = FindEmptySlot(i + 1, capacity, ctrl);
  487|      1|      }
  488|     11|      void* tmp_space = SlotAddress(slot_array, tmp_space_id, slot_size);
  489|     11|      SanitizerUnpoisonMemoryRegion(tmp_space, slot_size);
  490|       |
  491|       |      // Swap i and new_i elements.
  492|     11|      (*transfer_n)(set, tmp_space, new_slot_ptr, 1);
  493|     11|      (*transfer_n)(set, new_slot_ptr, slot_ptr, 1);
  494|     11|      (*transfer_n)(set, slot_ptr, tmp_space, 1);
  495|       |
  496|     11|      SanitizerPoisonMemoryRegion(tmp_space, slot_size);
  497|       |
  498|       |      // repeat the processing of the ith slot
  499|     11|      --i;
  500|     11|      slot_ptr = PrevSlot(slot_ptr, slot_size);
  501|     11|    }
  502|     26|  }
  503|       |  // Prepare insert for the new element.
  504|     10|  PrepareInsertCommon(common);
  505|     10|  ResetGrowthLeft(common);
  506|     10|  FindInfo find_info = find_first_non_full(common, new_hash);
  507|     10|  SetCtrlInLargeTable(common, find_info.offset, H2(new_hash), slot_size);
  508|     10|  common.infoz().RecordInsertMiss(new_hash, find_info.probe_length);
  509|     10|  common.infoz().RecordRehash(total_probe_length);
  510|     10|  return find_info.offset;
  511|     10|}
raw_hash_set.cc:_ZZN4absl12lts_2026052618container_internal12_GLOBAL__N_140DropDeletesWithoutResizeAndPrepareInsertERNS1_12CommonFieldsERKNS1_15PolicyFunctionsEmENK3$_0clEm:
  460|  1.20k|    const auto probe_index = [probe_offset, capacity](size_t pos) {
  461|  1.20k|      return ((pos - probe_offset) & capacity) / Group::kWidth;
  462|  1.20k|    };
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_113FindEmptySlotEmmPKNS1_6ctrl_tE:
  314|      1|size_t FindEmptySlot(size_t start, size_t end, const ctrl_t* ctrl) {
  315|      1|  for (size_t i = start; i < end; ++i) {
  ------------------
  |  Branch (315:26): [True: 1, False: 0]
  ------------------
  316|      1|    if (IsEmpty(ctrl[i])) {
  ------------------
  |  Branch (316:9): [True: 1, False: 0]
  ------------------
  317|      1|      return i;
  318|      1|    }
  319|      1|  }
  320|      0|  ABSL_UNREACHABLE();
  ------------------
  |  |  237|      0|  do {                                           \
  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  ------------------
  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  ------------------
  |  |  241|      0|  } while (false)
  |  |  ------------------
  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  321|      0|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_18PrevSlotEPvm:
  130|  8.89k|inline void* PrevSlot(void* slot, size_t slot_size) {
  131|  8.89k|  return reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(slot) - slot_size);
  132|  8.89k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119find_first_non_fullERKNS1_12CommonFieldsEm:
  204|   152k|FindInfo find_first_non_full(const CommonFields& common, size_t hash) {
  205|   152k|  return find_first_non_full_from_h1(common.control(), H1(hash),
  206|   152k|                                     common.capacity_impl());
  207|   152k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_119SetCtrlInLargeTableERKNS1_12CommonFieldsEmhm:
  399|   184k|                                size_t slot_size) {
  400|   184k|  SetCtrlInLargeTable(c, i, static_cast<ctrl_t>(h), slot_size);
  401|   184k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_124IterateOverFullSlotsImplINS0_11FunctionRefIFvPKNS1_6ctrl_tEPvEEEEEvRKNS1_12CommonFieldsEmT_:
  234|  40.6k|void IterateOverFullSlotsImpl(const CommonFields& c, size_t slot_size, Fn cb) {
  235|  40.6k|  const size_t cap = c.capacity();
  236|  40.6k|  ABSL_SWISSTABLE_ASSERT(!IsSmallCapacity(cap));
  ------------------
  |  |   62|  40.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  237|  40.6k|  const ctrl_t* ctrl = c.control();
  238|  40.6k|  void* slot = c.slot_array();
  239|  40.6k|  if (is_half_group(cap)) {
  ------------------
  |  Branch (239:7): [True: 8.88k, False: 31.7k]
  ------------------
  240|       |    // Mirrored/cloned control bytes in half-group table are also located in the
  241|       |    // first group (starting from position 0). We are taking group from position
  242|       |    // `capacity` in order to avoid duplicates.
  243|       |
  244|       |    // Half-group tables capacity fits into portable group, where
  245|       |    // GroupPortableImpl::MaskFull is more efficient for the
  246|       |    // capacity <= GroupPortableImpl::kWidth.
  247|  8.88k|    ABSL_SWISSTABLE_ASSERT(cap <= GroupPortableImpl::kWidth &&
  ------------------
  |  |   62|  8.88k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  248|  8.88k|                           "unexpectedly large half-group capacity");
  249|  8.88k|    static_assert(Group::kWidth >= GroupPortableImpl::kWidth,
  250|  8.88k|                  "unexpected group width");
  251|       |    // Group starts from kSentinel slot, so indices in the mask will
  252|       |    // be increased by 1.
  253|  8.88k|    const auto mask = GroupPortableImpl(ctrl + cap).MaskFull();
  254|  8.88k|    --ctrl;
  255|  8.88k|    slot = PrevSlot(slot, slot_size);
  256|  35.0k|    for (uint32_t i : mask) {
  ------------------
  |  Branch (256:21): [True: 35.0k, False: 8.88k]
  ------------------
  257|  35.0k|      cb(ctrl + i, SlotAddress(slot, i, slot_size));
  258|  35.0k|    }
  259|  8.88k|    return;
  260|  8.88k|  }
  261|  31.7k|  size_t remaining = c.size();
  262|  31.7k|  ABSL_ATTRIBUTE_UNUSED const size_t original_size_for_assert = remaining;
  ------------------
  |  |  582|  31.7k|#define ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))
  ------------------
  263|   345k|  while (remaining != 0) {
  ------------------
  |  Branch (263:10): [True: 313k, False: 31.7k]
  ------------------
  264|  3.07M|    for (uint32_t i : GroupFullEmptyOrDeleted(ctrl).MaskFull()) {
  ------------------
  |  Branch (264:21): [True: 3.07M, False: 313k]
  ------------------
  265|  3.07M|      ABSL_SWISSTABLE_ASSERT(IsFull(ctrl[i]) &&
  ------------------
  |  |   62|  3.07M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  266|  3.07M|                             "hash table was modified unexpectedly");
  267|  3.07M|      cb(ctrl + i, SlotAddress(slot, i, slot_size));
  268|  3.07M|      --remaining;
  269|  3.07M|    }
  270|   313k|    ctrl += Group::kWidth;
  271|   313k|    slot = NextSlot(slot, slot_size, Group::kWidth);
  272|   313k|    ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |   62|   313k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  273|   313k|        (remaining == 0 || *(ctrl - 1) != ctrl_t::kSentinel) &&
  274|   313k|        "hash table was modified unexpectedly");
  275|   313k|  }
  276|       |  // NOTE: erasure of the current element is allowed in callback for
  277|       |  // absl::erase_if specialization. So we use `>=`.
  278|       |  ABSL_SWISSTABLE_ASSERT(original_size_for_assert >= c.size() &&
  ------------------
  |  |   62|  31.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  279|  31.7k|                         "hash table was modified unexpectedly");
  280|  31.7k|}
raw_hash_set.cc:_ZN4absl12lts_2026052618container_internal12_GLOBAL__N_113is_half_groupEm:
  229|  40.6k|constexpr bool is_half_group(size_t capacity) {
  230|  40.6k|  return capacity < Group::kWidth - 1;
  231|  40.6k|}

_ZN4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled36maybe_increment_generation_on_insertEv:
  838|  4.09M|  void maybe_increment_generation_on_insert() {}
_ZNK4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled10generationEv:
  845|   261k|  GenerationType generation() const { return 0; }
_ZN4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled14set_generationEh:
  846|   261k|  void set_generation(GenerationType) {}
_ZN4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled18set_generation_ptrEPh:
  848|   261k|  void set_generation_ptr(GenerationType*) {}
_ZN4absl12lts_2026052618container_internal10GrowthInfo23InitGrowthLeftNoDeletedEm:
  914|   223k|  void InitGrowthLeftNoDeleted(size_t growth_left) {
  915|   223k|    growth_left_info_ = growth_left;
  916|   223k|  }
_ZN4absl12lts_2026052618container_internal10GrowthInfo20OverwriteFullAsEmptyEv:
  919|  38.6k|  void OverwriteFullAsEmpty() { ++growth_left_info_; }
_ZN4absl12lts_2026052618container_internal10GrowthInfo20OverwriteEmptyAsFullEv:
  922|  3.76M|  void OverwriteEmptyAsFull() {
  923|       |    ABSL_SWISSTABLE_ASSERT(GetGrowthLeft() > 0);
  ------------------
  |  |  256|  3.76M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  924|  3.76M|    --growth_left_info_;
  925|  3.76M|  }
_ZN4absl12lts_2026052618container_internal10GrowthInfo22OverwriteControlAsFullENS1_6ctrl_tE:
  934|  73.1k|  void OverwriteControlAsFull(ctrl_t ctrl) {
  935|       |    ABSL_SWISSTABLE_ASSERT(GetGrowthLeft() >=
  ------------------
  |  |  256|  73.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  936|  73.1k|                           static_cast<size_t>(IsEmpty(ctrl)));
  937|  73.1k|    growth_left_info_ -= static_cast<size_t>(IsEmpty(ctrl));
  938|  73.1k|  }
_ZN4absl12lts_2026052618container_internal10GrowthInfo22OverwriteFullAsDeletedEv:
  941|  8.87k|  void OverwriteFullAsDeleted() { growth_left_info_ |= kDeletedBit; }
_ZNK4absl12lts_2026052618container_internal10GrowthInfo25HasNoDeletedAndGrowthLeftEv:
  946|  4.00M|  bool HasNoDeletedAndGrowthLeft() const {
  947|  4.00M|    return static_cast<std::make_signed_t<size_t>>(growth_left_info_) > 0;
  948|  4.00M|  }
_ZNK4absl12lts_2026052618container_internal10GrowthInfo27HasNoGrowthLeftAndNoDeletedEv:
  953|   236k|  bool HasNoGrowthLeftAndNoDeleted() const { return growth_left_info_ == 0; }
_ZNK4absl12lts_2026052618container_internal10GrowthInfo37HasNoGrowthLeftAssumingMayHaveDeletedEv:
  957|  73.8k|  bool HasNoGrowthLeftAssumingMayHaveDeleted() const {
  958|       |    ABSL_SWISSTABLE_ASSERT(!HasNoDeleted());
  ------------------
  |  |  256|  73.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  959|  73.8k|    return growth_left_info_ == kDeletedBit;
  960|  73.8k|  }
_ZN4absl12lts_2026052618container_internal16RawHashSetLayoutC2Emmmb:
 1020|   523k|            ControlOffset(has_infoz, HasGrowthInfoForCapacity(capacity))),
 1021|   523k|        generation_offset_(control_offset_ + NumControlBytes(capacity)),
 1022|       |        slot_offset_(
 1023|   523k|            AlignUpTo(generation_offset_ + NumGenerationBytes(), slot_align)),
 1024|   523k|        alloc_size_(slot_offset_ + capacity * slot_size) {
 1025|   523k|    ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |  256|   523k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1026|       |    ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |  256|   523k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1027|   523k|        slot_size <=
 1028|   523k|        ((std::numeric_limits<size_t>::max)() - slot_offset_) / capacity);
 1029|   523k|  }
_ZNK4absl12lts_2026052618container_internal16RawHashSetLayout14control_offsetEv:
 1033|   523k|  size_t control_offset() const { return control_offset_; }
_ZNK4absl12lts_2026052618container_internal16RawHashSetLayout17generation_offsetEv:
 1037|   261k|  size_t generation_offset() const { return generation_offset_; }
_ZNK4absl12lts_2026052618container_internal16RawHashSetLayout11slot_offsetEv:
 1041|   261k|  size_t slot_offset() const { return slot_offset_; }
_ZNK4absl12lts_2026052618container_internal16RawHashSetLayout10alloc_sizeEv:
 1045|   785k|  size_t alloc_size() const { return alloc_size_; }
_ZN4absl12lts_2026052618container_internal9HeapOrSoo7controlEv:
 1088|   261k|  MaybeInitializedPtr<ctrl_t>& control() {
 1089|   261k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.control);
  ------------------
  |  |  488|   261k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1090|   261k|  }
_ZN4absl12lts_2026052618container_internal9HeapOrSoo10slot_arrayEv:
 1094|   261k|  MaybeInitializedPtr<void>& slot_array() {
 1095|   261k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.slot_array);
  ------------------
  |  |  488|   261k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1096|   261k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields11set_controlEPNS1_6ctrl_tE:
 1170|   261k|  void set_control(ctrl_t* c) { heap_or_soo_.control().set(c); }
_ZN4absl12lts_2026052618container_internal12CommonFields9set_slotsEPv:
 1177|   261k|  void set_slots(void* s) { heap_or_soo_.slot_array().set(s); }
_ZN4absl12lts_2026052618container_internal12CommonFields16set_size_to_zeroEv:
 1182|  3.98k|  void set_size_to_zero() { inline_data_.set_size(0); }
_ZN4absl12lts_2026052618container_internal12CommonFields14increment_sizeEv:
 1191|  4.09M|  void increment_size() {
 1192|       |    ABSL_SWISSTABLE_ASSERT(size() < capacity());
  ------------------
  |  |  256|  4.09M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1193|  4.09M|    inline_data_.increment_size();
 1194|  4.09M|  }
_ZNK4absl12lts_2026052618container_internal12CommonFields5emptyEv:
 1203|  40.5k|  bool empty() const { return inline_data_.empty(); }
_ZN4absl12lts_2026052618container_internal12CommonFields17generate_new_seedEb:
 1216|  56.0k|  void generate_new_seed(bool has_infoz) {
 1217|       |    // Note: we can't use has_infoz() here because we set has_infoz later than
 1218|       |    // we generate the seed.
 1219|  56.0k|    if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|  56.0k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 56.0k]
  |  |  |  Branch (190:49): [Folded, False: 56.0k]
  |  |  |  Branch (190:58): [True: 0, False: 56.0k]
  |  |  ------------------
  ------------------
 1220|      0|      inline_data_.set_sampled_seed();
 1221|      0|      return;
 1222|      0|    }
 1223|  56.0k|    inline_data_.generate_new_seed();
 1224|  56.0k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields12set_capacityENS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEE:
 1238|   261k|  void set_capacity(HashtableCapacity c) { inline_data_.set_capacity(c); }
_ZN4absl12lts_2026052618container_internal12CommonFields12set_capacityEm:
 1239|   261k|  void set_capacity(size_t c) {
 1240|   261k|    set_capacity(HashtableCapacity(c));
 1241|   261k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields11growth_infoEv:
 1250|  8.13M|  GrowthInfo& growth_info() {
 1251|       |    ABSL_SWISSTABLE_ASSERT(HasGrowthInfoForCapacity(capacity()));
  ------------------
  |  |  256|  8.13M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1252|  8.13M|    return GetGrowthInfoFromControl(control());
 1253|  8.13M|  }
_ZNK4absl12lts_2026052618container_internal15PolicyFunctions12soo_capacityEv:
 1788|  2.46k|  uint8_t soo_capacity() const {
 1789|  2.46k|    return static_cast<uint8_t>(soo_enabled ? SooCapacity() : 0);
  ------------------
  |  Branch (1789:33): [True: 409, False: 2.05k]
  ------------------
 1790|  2.46k|  }
_ZN4absl12lts_2026052618container_internal23SentinelEmptyGenerationEv:
  264|   261k|constexpr GenerationType SentinelEmptyGeneration() { return 0; }
_ZN4absl12lts_2026052618container_internal14NextGenerationEh:
  266|   261k|constexpr GenerationType NextGeneration(GenerationType generation) {
  267|   261k|  return ++generation == SentinelEmptyGeneration() ? ++generation : generation;
  ------------------
  |  Branch (267:10): [True: 0, False: 261k]
  ------------------
  268|   261k|}
_ZN4absl12lts_2026052618container_internal18NumGenerationBytesEv:
  275|   523k|constexpr size_t NumGenerationBytes() { return 0; }
_ZN4absl12lts_2026052618container_internal17NormalizeCapacityEm:
  389|  5.83k|constexpr size_t NormalizeCapacity(size_t n) {
  390|  5.83k|  return n ? ~size_t{} >> countl_zero(n) : 1;
  ------------------
  |  Branch (390:10): [True: 5.83k, False: 0]
  ------------------
  391|  5.83k|}
_ZN4absl12lts_2026052618container_internal12NextCapacityEm:
  394|   163k|constexpr size_t NextCapacity(size_t n) {
  395|       |  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(n) || n == 0);
  ------------------
  |  |  256|   163k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  396|   163k|  return n * 2 + 1;
  397|   163k|}
_ZN4absl12lts_2026052618container_internal9AlignUpToEmm:
 1010|   523k|constexpr size_t AlignUpTo(size_t offset, size_t align) {
 1011|   523k|  return (offset + align - 1) & (~align + 1);
 1012|   523k|}
_ZN4absl12lts_2026052618container_internal24GetGrowthInfoFromControlEPNS1_6ctrl_tE:
 1113|  8.35M|inline GrowthInfo& GetGrowthInfoFromControl(ctrl_t* control) {
 1114|  8.35M|  auto* gl_ptr = reinterpret_cast<GrowthInfo*>(control) - 1;
 1115|       |  ABSL_SWISSTABLE_ASSERT(
  ------------------
  |  |  256|  8.35M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1116|  8.35M|      reinterpret_cast<uintptr_t>(gl_ptr) % alignof(GrowthInfo) == 0);
 1117|  8.35M|  return *gl_ptr;
 1118|  8.35M|}
_ZN4absl12lts_2026052618container_internal15is_single_groupEm:
 1571|   210k|constexpr bool is_single_group(size_t capacity) {
 1572|   210k|  return capacity <= Group::kWidth;
 1573|   210k|}
_ZN4absl12lts_2026052618container_internal12SooSlotIndexEv:
 1848|  60.0k|constexpr size_t SooSlotIndex() { return 1; }
_ZN4absl12lts_2026052618container_internal19MaybeInitializedPtrINS1_6ctrl_tEE3setEPS3_:
 1061|   261k|  void set(T* ptr) { p = ptr; }
_ZN4absl12lts_2026052618container_internal19MaybeInitializedPtrIvE3setEPv:
 1061|   261k|  void set(T* ptr) { p = ptr; }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE14increment_sizeEv:
  646|  4.09M|  void increment_size() { data_ += kSizeOneNoMetadata; }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE5emptyEv:
  652|  40.5k|  bool empty() const { return data_ < kSizeOneNoMetadata; }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8set_seedEh:
  712|  56.0k|  void set_seed(typename PerTableSeed::IntType seed) {
  713|  56.0k|    data_ = (data_ & ~kSeedMask) | seed;
  714|  56.0k|  }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE17generate_new_seedEv:
  670|  56.0k|  void generate_new_seed() {
  671|  56.0k|    set_seed(static_cast<typename PerTableSeed::IntType>(NextHashTableSeed()));
  672|  56.0k|  }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE12set_capacityENS1_21HashtableCapacityImplILS3_1EEE:
  641|   261k|  void set_capacity(HashtableCapacity c) { capacity_internal_ = c.ToRawData(); }
_ZN4absl12lts_2026052618container_internal20AllocateBackingArrayILm8ENSt3__19allocatorIcEEEEPvS6_m:
 1722|   261k|void* AllocateBackingArray(void* alloc, size_t n) {
 1723|   261k|  return Allocate<AlignOfBackingArray>(static_cast<Alloc*>(alloc), n);
 1724|   261k|}
_ZN4absl12lts_2026052618container_internal22DeallocateBackingArrayILm8ENSt3__19allocatorIcEEEEvPvmPNS1_6ctrl_tEmmb:
 1731|   261k|    size_t slot_align, bool had_infoz) {
 1732|   261k|  RawHashSetLayout layout(capacity, slot_size, slot_align, had_infoz);
 1733|   261k|  void* backing_array = ctrl - layout.control_offset();
 1734|       |  // Unpoison before returning the memory to the allocator.
 1735|   261k|  SanitizerUnpoisonMemoryRegion(backing_array, layout.alloc_size());
 1736|   261k|  Deallocate<AlignOfBackingArray>(static_cast<Alloc*>(alloc), backing_array,
 1737|   261k|                                  layout.alloc_size());
 1738|   261k|}

_ZN4absl12lts_2026052618container_internal14ProbedItemImplIjLm32EEC2Ehmm:
   59|  32.3k|      : h2(h2_arg),
   60|  32.3k|        source_offset(static_cast<IntType>(source_offset_arg)),
   61|  32.3k|        h1(static_cast<IntType>(h1_arg)) {}
_ZN4absl12lts_2026052618container_internal14ProbedItemImplImLm64EEC2Ehmm:
   59|      7|      : h2(h2_arg),
   60|      7|        source_offset(static_cast<IntType>(source_offset_arg)),
   61|      7|        h1(static_cast<IntType>(h1_arg)) {}

_ZNK4absl12lts_2026052611FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEclES5_S6_:
  164|  3.11M|  R operator()(Args... args) const {
  165|  3.11M|    return invoker_(ptr_, std::forward<Args>(args)...);
  166|  3.11M|  }
_ZNK4absl12lts_2026052611FunctionRefIFmmEEclEm:
  164|  50.2k|  R operator()(Args... args) const {
  165|  50.2k|    return invoker_(ptr_, std::forward<Args>(args)...);
  166|  50.2k|  }

_ZN4absl12lts_2026052613hash_internal43CombineLargeContiguousImplOn64BitLengthGt32EmPKhm:
  417|   394k|                                                     size_t len) {
  418|   394k|  assert(len > 32);
  419|   394k|  assert(sizeof(size_t) == 8);  // NOLINT(misc-static-assert)
  420|   394k|  if (ABSL_PREDICT_TRUE(len <= PiecewiseChunkSize())) {
  ------------------
  |  |  191|   394k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 394k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 394k]
  |  |  |  Branch (191:57): [True: 394k, False: 0]
  |  |  ------------------
  ------------------
  421|   394k|    return HashBlockOn64Bit(state, first, len);
  422|   394k|  }
  423|      0|  return SplitAndCombineOn64Bit(state, first, len);
  424|   394k|}
hash.cc:_ZN4absl12lts_2026052613hash_internal12_GLOBAL__N_116HashBlockOn64BitEmPKhm:
  376|   394k|    uint64_t state, const unsigned char* data, size_t len) {
  377|   394k|#ifdef ABSL_HAVE_INTRINSIC_INT128
  378|   394k|  return LowLevelHashLenGt32(state, data, len);
  379|       |#else
  380|       |  return hash_internal::CityHash64WithSeed(reinterpret_cast<const char*>(data),
  381|       |                                           len, state);
  382|       |#endif
  383|   394k|}
hash.cc:_ZN4absl12lts_2026052613hash_internal12_GLOBAL__N_119LowLevelHashLenGt32EmPKvm:
  341|   394k|                                              size_t len) {
  342|   394k|  assert(len > 32);
  343|   394k|  if (ABSL_PREDICT_FALSE(len > 64)) {
  ------------------
  |  |  190|   394k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 101k, False: 293k]
  |  |  |  Branch (190:49): [Folded, False: 394k]
  |  |  |  Branch (190:58): [True: 101k, False: 293k]
  |  |  ------------------
  ------------------
  344|   101k|    return LowLevelHashLenGt64(seed, data, len);
  345|   101k|  }
  346|   293k|  return LowLevelHash33To64(seed, static_cast<const uint8_t*>(data), len);
  347|   394k|}
hash.cc:_ZN4absl12lts_2026052613hash_internal12_GLOBAL__N_119LowLevelHashLenGt64EmPKvm:
  291|   101k|LowLevelHashLenGt64(uint64_t seed, const void* data, size_t len) {
  292|   101k|  assert(len > 64);
  293|   101k|  const uint8_t* ptr = static_cast<const uint8_t*>(data);
  294|   101k|  uint64_t current_state = seed ^ kStaticRandomData[0] ^ len;
  295|   101k|  const uint8_t* last_32_ptr = ptr + len - 32;
  296|       |  // If we have more than 64 bytes, we're going to handle chunks of 64
  297|       |  // bytes at a time. We're going to build up four separate hash states
  298|       |  // which we will then hash together. This avoids short dependency chains.
  299|   101k|  uint64_t duplicated_state0 = current_state;
  300|   101k|  uint64_t duplicated_state1 = current_state;
  301|   101k|  uint64_t duplicated_state2 = current_state;
  302|       |
  303|   213k|  do {
  304|   213k|    PrefetchFutureDataToLocalCache(ptr);
  305|       |
  306|   213k|    uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
  307|   213k|    uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
  308|   213k|    uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
  309|   213k|    uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
  310|   213k|    uint64_t e = absl::base_internal::UnalignedLoad64(ptr + 32);
  311|   213k|    uint64_t f = absl::base_internal::UnalignedLoad64(ptr + 40);
  312|   213k|    uint64_t g = absl::base_internal::UnalignedLoad64(ptr + 48);
  313|   213k|    uint64_t h = absl::base_internal::UnalignedLoad64(ptr + 56);
  314|       |
  315|   213k|    current_state = Mix(a ^ kStaticRandomData[1], b ^ current_state);
  316|   213k|    duplicated_state0 = Mix(c ^ kStaticRandomData[2], d ^ duplicated_state0);
  317|       |
  318|   213k|    duplicated_state1 = Mix(e ^ kStaticRandomData[3], f ^ duplicated_state1);
  319|   213k|    duplicated_state2 = Mix(g ^ kStaticRandomData[4], h ^ duplicated_state2);
  320|       |
  321|   213k|    ptr += 64;
  322|   213k|    len -= 64;
  323|   213k|  } while (len > 64);
  ------------------
  |  Branch (323:12): [True: 111k, False: 101k]
  ------------------
  324|       |
  325|   101k|  current_state = (current_state ^ duplicated_state0) ^
  326|   101k|                  (duplicated_state1 + duplicated_state2);
  327|       |  // We now have a data `ptr` with at most 64 bytes and the current state
  328|       |  // of the hashing state machine stored in current_state.
  329|   101k|  if (len > 32) {
  ------------------
  |  Branch (329:7): [True: 24.2k, False: 77.3k]
  ------------------
  330|  24.2k|    current_state = Mix32Bytes(ptr, current_state);
  331|  24.2k|  }
  332|       |
  333|       |  // We now have a data `ptr` with at most 32 bytes and the current state
  334|       |  // of the hashing state machine stored in current_state. But we can
  335|       |  // safely read from `ptr + len - 32`.
  336|   101k|  return Mix32Bytes(last_32_ptr, current_state);
  337|   101k|}
hash.cc:_ZN4absl12lts_2026052613hash_internal12_GLOBAL__N_130PrefetchFutureDataToLocalCacheEPKh:
   55|   213k|void PrefetchFutureDataToLocalCache(const uint8_t* ptr) {
   56|   213k|  PrefetchToLocalCache(ptr + 5 * ABSL_CACHELINE_SIZE);
  ------------------
  |  |   89|   213k|#define ABSL_CACHELINE_SIZE 64
  ------------------
   57|   213k|}
hash.cc:_ZN4absl12lts_2026052613hash_internal12_GLOBAL__N_110Mix32BytesEPKhm:
  271|   712k|uint64_t Mix32Bytes(const uint8_t* ptr, uint64_t current_state) {
  272|   712k|  uint64_t a = absl::base_internal::UnalignedLoad64(ptr);
  273|   712k|  uint64_t b = absl::base_internal::UnalignedLoad64(ptr + 8);
  274|   712k|  uint64_t c = absl::base_internal::UnalignedLoad64(ptr + 16);
  275|   712k|  uint64_t d = absl::base_internal::UnalignedLoad64(ptr + 24);
  276|       |
  277|   712k|  uint64_t cs0 = Mix(a ^ kStaticRandomData[1], b ^ current_state);
  278|   712k|  uint64_t cs1 = Mix(c ^ kStaticRandomData[2], d ^ current_state);
  279|   712k|  return cs0 ^ cs1;
  280|   712k|}
hash.cc:_ZN4absl12lts_2026052613hash_internal12_GLOBAL__N_118LowLevelHash33To64EmPKhm:
  282|   293k|uint64_t LowLevelHash33To64(uint64_t seed, const uint8_t* ptr, size_t len) {
  283|   293k|  assert(len > 32);
  284|       |  assert(len <= 64);
  285|   293k|  uint64_t current_state = seed ^ kStaticRandomData[0] ^ len;
  286|   293k|  const uint8_t* last_32_ptr = ptr + len - 32;
  287|   293k|  return Mix32Bytes(last_32_ptr, Mix32Bytes(ptr, current_state));
  288|   293k|}

_ZN4absl12lts_2026052613hash_internal18PiecewiseChunkSizeEv:
  157|   394k|constexpr size_t PiecewiseChunkSize() { return 1024; }

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

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

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

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

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

_ZN4absl12lts_2026052612log_internal10LogMessagelsIiEERS2_RKT_:
  351|  68.6k|LogMessage& LogMessage::operator<<(const T& v) {
  352|       |  if constexpr (absl::HasAbslStringify<T>::value) {
  353|       |    StringifySink sink(*this);
  354|       |    // Replace with public API.
  355|       |    AbslStringify(sink, v);
  356|  68.6k|  } else {
  357|  68.6k|    OstreamView view(*data_);
  358|  68.6k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  359|  68.6k|  }
  360|  68.6k|  return *this;
  361|  68.6k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsIlEERS2_RKT_:
  351|  39.9k|LogMessage& LogMessage::operator<<(const T& v) {
  352|       |  if constexpr (absl::HasAbslStringify<T>::value) {
  353|       |    StringifySink sink(*this);
  354|       |    // Replace with public API.
  355|       |    AbslStringify(sink, v);
  356|  39.9k|  } else {
  357|  39.9k|    OstreamView view(*data_);
  358|  39.9k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  359|  39.9k|  }
  360|  39.9k|  return *this;
  361|  39.9k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsImEERS2_RKT_:
  351|  57.5k|LogMessage& LogMessage::operator<<(const T& v) {
  352|       |  if constexpr (absl::HasAbslStringify<T>::value) {
  353|       |    StringifySink sink(*this);
  354|       |    // Replace with public API.
  355|       |    AbslStringify(sink, v);
  356|  57.5k|  } else {
  357|  57.5k|    OstreamView view(*data_);
  358|  57.5k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  359|  57.5k|  }
  360|  57.5k|  return *this;
  361|  57.5k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsIfEERS2_RKT_:
  351|  31.4k|LogMessage& LogMessage::operator<<(const T& v) {
  352|       |  if constexpr (absl::HasAbslStringify<T>::value) {
  353|       |    StringifySink sink(*this);
  354|       |    // Replace with public API.
  355|       |    AbslStringify(sink, v);
  356|  31.4k|  } else {
  357|  31.4k|    OstreamView view(*data_);
  358|  31.4k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  359|  31.4k|  }
  360|  31.4k|  return *this;
  361|  31.4k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsIdEERS2_RKT_:
  351|  42.1k|LogMessage& LogMessage::operator<<(const T& v) {
  352|       |  if constexpr (absl::HasAbslStringify<T>::value) {
  353|       |    StringifySink sink(*this);
  354|       |    // Replace with public API.
  355|       |    AbslStringify(sink, v);
  356|  42.1k|  } else {
  357|  42.1k|    OstreamView view(*data_);
  358|  42.1k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  359|  42.1k|  }
  360|  42.1k|  return *this;
  361|  42.1k|}

_ZN4absl12lts_2026052612log_internal24ThreadIsLoggingToLogSinkEv:
  277|  1.22M|bool ThreadIsLoggingToLogSink() { return ThreadIsLoggingStatus(); }
_ZN4absl12lts_2026052612log_internal10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEb:
  280|   612k|                absl::Span<absl::LogSink*> extra_sinks, bool extra_sinks_only) {
  281|   612k|  log_internal::GlobalSinks().LogToSinks(entry, extra_sinks, extra_sinks_only);
  282|   612k|}
log_sink_set.cc:_ZN4absl12lts_2026052612log_internal12_GLOBAL__N_121ThreadIsLoggingStatusEv:
   58|  2.45M|bool& ThreadIsLoggingStatus() {
   59|  2.45M|#ifdef ABSL_HAVE_THREAD_LOCAL
   60|  2.45M|  ABSL_CONST_INIT thread_local bool thread_is_logging = false;
  ------------------
  |  |  849|  2.45M|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
   61|  2.45M|  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.45M|}
log_sink_set.cc:_ZN4absl12lts_2026052612log_internal12_GLOBAL__N_111GlobalSinksEv:
  270|   612k|GlobalLogSinkSet& GlobalSinks() {
  271|   612k|  static absl::NoDestructor<GlobalLogSinkSet> global_sinks;
  272|   612k|  return *global_sinks;
  273|   612k|}
log_sink_set.cc:_ZN4absl12lts_2026052612log_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_2026052612log_internal12_GLOBAL__N_113StderrLogSink4SendERKNS0_8LogEntryE:
   92|   612k|  void Send(const absl::LogEntry& entry) override {
   93|   612k|    if (entry.log_severity() < absl::StderrThreshold() &&
  ------------------
  |  Branch (93:9): [True: 612k, False: 0]
  ------------------
   94|   612k|        absl::log_internal::IsInitialized()) {
  ------------------
  |  Branch (94:9): [True: 0, False: 612k]
  ------------------
   95|      0|      return;
   96|      0|    }
   97|       |
   98|   612k|    ABSL_CONST_INIT static absl::once_flag warn_if_not_initialized;
  ------------------
  |  |  849|   612k|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
   99|   612k|    absl::call_once(warn_if_not_initialized, []() {
  100|   612k|      if (absl::log_internal::IsInitialized()) return;
  101|   612k|      const char w[] =
  102|   612k|          "WARNING: All log messages before absl::InitializeLog() is called"
  103|   612k|          " are written to STDERR\n";
  104|   612k|      absl::log_internal::WriteToStderr(w, absl::LogSeverity::kWarning);
  105|   612k|    });
  106|       |
  107|   612k|    if (!entry.stacktrace().empty()) {
  ------------------
  |  Branch (107:9): [True: 0, False: 612k]
  ------------------
  108|      0|      absl::log_internal::WriteToStderr(entry.stacktrace(),
  109|      0|                                        entry.log_severity());
  110|   612k|    } else {
  111|       |      // TODO(b/226937039): do this outside else condition once we avoid
  112|       |      // ReprintFatalMessage
  113|   612k|      absl::log_internal::WriteToStderr(
  114|   612k|          entry.text_message_with_prefix_and_newline(), entry.log_severity());
  115|   612k|    }
  116|   612k|  }
log_sink_set.cc:_ZZN4absl12lts_2026052612log_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_2026052612log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEb:
  187|   612k|      ABSL_LOCKS_EXCLUDED(guard_) {
  188|   612k|    SendToSinks(entry, extra_sinks);
  189|       |
  190|   612k|    if (!extra_sinks_only) {
  ------------------
  |  Branch (190:9): [True: 612k, False: 0]
  ------------------
  191|   612k|      if (ThreadIsLoggingToLogSink()) {
  ------------------
  |  Branch (191:11): [True: 0, False: 612k]
  ------------------
  192|      0|        absl::log_internal::WriteToStderr(
  193|      0|            entry.text_message_with_prefix_and_newline(), entry.log_severity());
  194|   612k|      } else {
  195|   612k|        absl::ReaderMutexLock global_sinks_lock(guard_);
  196|   612k|        ThreadIsLoggingStatus() = true;
  197|       |        // Ensure the "thread is logging" status is reverted upon leaving the
  198|       |        // scope even in case of exceptions.
  199|   612k|        auto status_cleanup =
  200|   612k|            absl::MakeCleanup([] { ThreadIsLoggingStatus() = false; });
  201|   612k|        SendToSinks(entry, absl::MakeSpan(sinks_));
  202|   612k|      }
  203|   612k|    }
  204|   612k|  }
log_sink_set.cc:_ZN4absl12lts_2026052612log_internal12_GLOBAL__N_116GlobalLogSinkSet11SendToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEE:
  258|  1.22M|                          absl::Span<absl::LogSink*> sinks) {
  259|  1.22M|    for (absl::LogSink* sink : sinks) {
  ------------------
  |  Branch (259:30): [True: 612k, False: 1.22M]
  ------------------
  260|   612k|      sink->Send(entry);
  261|   612k|    }
  262|  1.22M|  }
log_sink_set.cc:_ZZN4absl12lts_2026052612log_internal12_GLOBAL__N_116GlobalLogSinkSet10LogToSinksERKNS0_8LogEntryENS0_4SpanIPNS0_7LogSinkEEEbENKUlvE_clEv:
  200|   612k|            absl::MakeCleanup([] { ThreadIsLoggingStatus() = false; });
log_sink_set.cc:_ZN4absl12lts_2026052612log_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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   82|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  216|      0|  }

_ZN4absl12lts_2026052612log_internal9NullGuardIfE5GuardERKf:
   45|  31.4k|  static const T& Guard(const T& v) { return v; }
_ZN4absl12lts_2026052612log_internal9NullGuardIdE5GuardERKd:
   45|  42.1k|  static const T& Guard(const T& v) { return v; }
_ZN4absl12lts_2026052612log_internal9NullGuardIiE5GuardERKi:
   45|  68.6k|  static const T& Guard(const T& v) { return v; }

_ZN4absl12lts_2026052612log_internal12EncodeVarintEmmPNS0_4SpanIcEE:
   53|  2.45M|bool EncodeVarint(uint64_t tag, uint64_t value, absl::Span<char> *buf) {
   54|  2.45M|  const uint64_t tag_type = MakeTagType(tag, WireType::kVarint);
   55|  2.45M|  const size_t tag_type_size = VarintSize(tag_type);
   56|  2.45M|  const size_t value_size = VarintSize(value);
   57|  2.45M|  if (tag_type_size + value_size > buf->size()) {
  ------------------
  |  Branch (57:7): [True: 0, False: 2.45M]
  ------------------
   58|      0|    buf->remove_suffix(buf->size());
   59|      0|    return false;
   60|      0|  }
   61|  2.45M|  EncodeRawVarint(tag_type, tag_type_size, buf);
   62|  2.45M|  EncodeRawVarint(value, value_size, buf);
   63|  2.45M|  return true;
   64|  2.45M|}
_ZN4absl12lts_2026052612log_internal19EncodeBytesTruncateEmNS0_4SpanIKcEEPNS2_IcEE:
  116|  1.44M|                         absl::Span<char> *buf) {
  117|  1.44M|  const uint64_t tag_type = MakeTagType(tag, WireType::kLengthDelimited);
  118|  1.44M|  const size_t tag_type_size = VarintSize(tag_type);
  119|  1.44M|  uint64_t length = value.size();
  120|  1.44M|  const size_t length_size =
  121|  1.44M|      VarintSize(std::min<uint64_t>(length, buf->size()));
  122|  1.44M|  if (tag_type_size + length_size <= buf->size() &&
  ------------------
  |  Branch (122:7): [True: 1.44M, False: 0]
  ------------------
  123|  1.44M|      tag_type_size + length_size + value.size() > buf->size()) {
  ------------------
  |  Branch (123:7): [True: 0, False: 1.44M]
  ------------------
  124|      0|    value.remove_suffix(tag_type_size + length_size + value.size() -
  125|      0|                        buf->size());
  126|      0|    length = value.size();
  127|      0|  }
  128|  1.44M|  if (tag_type_size + length_size + value.size() > buf->size()) {
  ------------------
  |  Branch (128:7): [True: 0, False: 1.44M]
  ------------------
  129|      0|    buf->remove_suffix(buf->size());
  130|      0|    return false;
  131|      0|  }
  132|  1.44M|  EncodeRawVarint(tag_type, tag_type_size, buf);
  133|  1.44M|  EncodeRawVarint(length, length_size, buf);
  134|  1.44M|  memcpy(buf->data(), value.data(), value.size());
  135|  1.44M|  buf->remove_prefix(value.size());
  136|  1.44M|  return true;
  137|  1.44M|}
_ZN4absl12lts_2026052612log_internal18EncodeMessageStartEmmPNS0_4SpanIcEE:
  141|  1.32M|                                                  absl::Span<char> *buf) {
  142|  1.32M|  const uint64_t tag_type = MakeTagType(tag, WireType::kLengthDelimited);
  143|  1.32M|  const size_t tag_type_size = VarintSize(tag_type);
  144|  1.32M|  max_size = std::min<uint64_t>(max_size, buf->size());
  145|  1.32M|  const size_t length_size = VarintSize(max_size);
  146|  1.32M|  if (tag_type_size + length_size > buf->size()) {
  ------------------
  |  Branch (146:7): [True: 0, False: 1.32M]
  ------------------
  147|      0|    buf->remove_suffix(buf->size());
  148|      0|    return absl::Span<char>();
  149|      0|  }
  150|  1.32M|  EncodeRawVarint(tag_type, tag_type_size, buf);
  151|  1.32M|  const absl::Span<char> ret = buf->subspan(0, length_size);
  152|  1.32M|  EncodeRawVarint(0, length_size, buf);
  153|  1.32M|  return ret;
  154|  1.32M|}
_ZN4absl12lts_2026052612log_internal19EncodeMessageLengthENS0_4SpanIcEEPKS3_:
  156|  1.32M|void EncodeMessageLength(absl::Span<char> msg, const absl::Span<char> *buf) {
  157|  1.32M|  if (!msg.data()) return;
  ------------------
  |  Branch (157:7): [True: 0, False: 1.32M]
  ------------------
  158|  1.32M|  assert(buf->data() >= msg.data());
  159|  1.32M|  if (buf->data() < msg.data()) return;
  ------------------
  |  Branch (159:7): [True: 0, False: 1.32M]
  ------------------
  160|  1.32M|  EncodeRawVarint(
  161|  1.32M|      static_cast<uint64_t>(buf->data() - (msg.data() + msg.size())),
  162|  1.32M|      msg.size(), &msg);
  163|  1.32M|}
_ZN4absl12lts_2026052612log_internal10ProtoField10DecodeFromEPNS0_4SpanIKcEE:
  203|  6.91M|bool ProtoField::DecodeFrom(absl::Span<const char> *data) {
  204|  6.91M|  if (data->empty()) return false;
  ------------------
  |  Branch (204:7): [True: 1.69M, False: 5.22M]
  ------------------
  205|  5.22M|  const uint64_t tag_type = DecodeVarint(data);
  206|  5.22M|  tag_ = tag_type >> 3;
  207|  5.22M|  type_ = static_cast<WireType>(tag_type & 0x07);
  208|  5.22M|  switch (type_) {
  ------------------
  |  Branch (208:11): [True: 5.22M, False: 0]
  ------------------
  209|  2.45M|    case WireType::kVarint:
  ------------------
  |  Branch (209:5): [True: 2.45M, False: 2.77M]
  ------------------
  210|  2.45M|      value_ = DecodeVarint(data);
  211|  2.45M|      break;
  212|      0|    case WireType::k64Bit:
  ------------------
  |  Branch (212:5): [True: 0, False: 5.22M]
  ------------------
  213|      0|      value_ = Decode64Bit(data);
  214|      0|      break;
  215|  2.77M|    case WireType::kLengthDelimited: {
  ------------------
  |  Branch (215:5): [True: 2.77M, False: 2.45M]
  ------------------
  216|  2.77M|      value_ = DecodeVarint(data);
  217|  2.77M|      data_ = data->subspan(
  218|  2.77M|          0, static_cast<size_t>(std::min<uint64_t>(value_, data->size())));
  219|  2.77M|      data->remove_prefix(data_.size());
  220|  2.77M|      break;
  221|      0|    }
  222|      0|    case WireType::k32Bit:
  ------------------
  |  Branch (222:5): [True: 0, False: 5.22M]
  ------------------
  223|      0|      value_ = Decode32Bit(data);
  224|      0|      break;
  225|  5.22M|  }
  226|  5.22M|  return true;
  227|  5.22M|}
proto.cc:_ZN4absl12lts_2026052612log_internal12_GLOBAL__N_115EncodeRawVarintEmmPNS0_4SpanIcEE:
   44|  11.7M|void EncodeRawVarint(uint64_t value, size_t size, absl::Span<char> *buf) {
   45|  30.6M|  for (size_t s = 0; s < size; s++) {
  ------------------
  |  Branch (45:22): [True: 18.9M, False: 11.7M]
  ------------------
   46|  18.9M|    (*buf)[s] = static_cast<char>((value & 0x7f) | (s + 1 == size ? 0 : 0x80));
  ------------------
  |  Branch (46:53): [True: 11.7M, False: 7.13M]
  ------------------
   47|  18.9M|    value >>= 7;
   48|  18.9M|  }
   49|  11.7M|  buf->remove_prefix(size);
   50|  11.7M|}
proto.cc:_ZN4absl12lts_2026052612log_internal12_GLOBAL__N_112DecodeVarintEPNS0_4SpanIKcEE:
  166|  10.4M|uint64_t DecodeVarint(absl::Span<const char> *buf) {
  167|  10.4M|  uint64_t value = 0;
  168|  10.4M|  size_t s = 0;
  169|  17.0M|  while (s < buf->size()) {
  ------------------
  |  Branch (169:10): [True: 17.0M, False: 0]
  ------------------
  170|  17.0M|    value |= static_cast<uint64_t>(static_cast<unsigned char>((*buf)[s]) & 0x7f)
  171|  17.0M|             << 7 * s;
  172|  17.0M|    if (!((*buf)[s++] & 0x80)) break;
  ------------------
  |  Branch (172:9): [True: 10.4M, False: 6.63M]
  ------------------
  173|  17.0M|  }
  174|  10.4M|  buf->remove_prefix(s);
  175|  10.4M|  return value;
  176|  10.4M|}

_ZNK4absl12lts_2026052612log_internal10ProtoField3tagEv:
  245|  5.22M|  uint64_t tag() const { return tag_; }
_ZNK4absl12lts_2026052612log_internal10ProtoField4typeEv:
  246|  2.15M|  WireType type() const { return type_; }
_ZNK4absl12lts_2026052612log_internal10ProtoField11bytes_valueEv:
  275|  3.23M|  absl::Span<const char> bytes_value() const { return data_; }
_ZNK4absl12lts_2026052612log_internal10ProtoField12string_valueEv:
  276|  2.15M|  absl::string_view string_value() const {
  277|  2.15M|    const auto data = bytes_value();
  278|  2.15M|    return absl::string_view(data.data(), data.size());
  279|  2.15M|  }
_ZN4absl12lts_2026052612log_internal12EncodeVarintEmlPNS0_4SpanIcEE:
   73|   612k|inline bool EncodeVarint(uint64_t tag, int64_t value, absl::Span<char> *buf) {
   74|   612k|  return EncodeVarint(tag, static_cast<uint64_t>(value), buf);
   75|   612k|}
_ZN4absl12lts_2026052612log_internal12EncodeVarintEmiPNS0_4SpanIcEE:
   79|  1.22M|inline bool EncodeVarint(uint64_t tag, int32_t value, absl::Span<char> *buf) {
   80|  1.22M|  return EncodeVarint(tag, static_cast<uint64_t>(value), buf);
   81|  1.22M|}
_ZN4absl12lts_2026052612log_internal20EncodeStringTruncateEmNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPNS0_4SpanIcEE:
  160|  1.44M|                                 absl::Span<char> *buf) {
  161|  1.44M|  return EncodeBytesTruncate(tag, value, buf);
  162|  1.44M|}
_ZN4absl12lts_2026052612log_internal10VarintSizeEm:
  188|  26.2M|constexpr size_t VarintSize(uint64_t value) {
  189|  26.2M|  return value < 128 ? 1 : 1 + VarintSize(value >> 7);
  ------------------
  |  Branch (189:10): [True: 12.1M, False: 14.1M]
  ------------------
  190|  26.2M|}
_ZN4absl12lts_2026052612log_internal13MaxVarintSizeEv:
  194|   830k|constexpr size_t MaxVarintSize() {
  195|   830k|  return VarintSize((std::numeric_limits<uint64_t>::max)());
  196|   830k|}
_ZN4absl12lts_2026052612log_internal11MakeTagTypeEmNS1_8WireTypeE:
  202|  6.05M|constexpr uint64_t MakeTagType(uint64_t tag, WireType type) {
  203|  6.05M|  return tag << 3 | static_cast<uint64_t>(type);
  204|  6.05M|}
_ZN4absl12lts_2026052612log_internal13BufferSizeForEmNS1_8WireTypeE:
  212|   830k|constexpr size_t BufferSizeFor(uint64_t tag, WireType type) {
  213|   830k|  size_t buffer_size = VarintSize(MakeTagType(tag, type));
  214|   830k|  switch (type) {
  ------------------
  |  Branch (214:11): [True: 830k, False: 0]
  ------------------
  215|      0|    case WireType::kVarint:
  ------------------
  |  Branch (215:5): [True: 0, False: 830k]
  ------------------
  216|      0|      buffer_size += MaxVarintSize();
  217|      0|      break;
  218|      0|    case WireType::k64Bit:
  ------------------
  |  Branch (218:5): [True: 0, False: 830k]
  ------------------
  219|      0|      buffer_size += size_t{8};
  220|      0|      break;
  221|   830k|    case WireType::kLengthDelimited:
  ------------------
  |  Branch (221:5): [True: 830k, False: 0]
  ------------------
  222|   830k|      buffer_size += MaxVarintSize();
  223|   830k|      break;
  224|      0|    case WireType::k32Bit:
  ------------------
  |  Branch (224:5): [True: 0, False: 830k]
  ------------------
  225|      0|      buffer_size += size_t{4};
  226|      0|      break;
  227|   830k|  }
  228|   830k|  return buffer_size;
  229|   830k|}

_ZNK4absl12lts_202605268LogEntry15source_filenameEv:
   76|   612k|  absl::string_view source_filename() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   77|   612k|    return full_filename_;
   78|   612k|  }
_ZNK4absl12lts_202605268LogEntry15source_basenameEv:
   79|   612k|  absl::string_view source_basename() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
   80|   612k|    return base_filename_;
   81|   612k|  }
_ZNK4absl12lts_202605268LogEntry11source_lineEv:
   82|  1.22M|  int source_line() const { return line_; }
_ZNK4absl12lts_202605268LogEntry6prefixEv:
   89|   612k|  bool prefix() const { return prefix_; }
_ZNK4absl12lts_202605268LogEntry12log_severityEv:
   95|  4.90M|  absl::LogSeverity log_severity() const { return severity_; }
_ZNK4absl12lts_202605268LogEntry9verbosityEv:
  102|   612k|  int verbosity() const { return verbose_level_; }
_ZNK4absl12lts_202605268LogEntry9timestampEv:
  113|  1.22M|  absl::Time timestamp() const { return timestamp_; }
_ZNK4absl12lts_202605268LogEntry3tidEv:
  122|  1.22M|  tid_t tid() const { return tid_; }
_ZNK4absl12lts_202605268LogEntry36text_message_with_prefix_and_newlineEv:
  147|   612k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  148|   612k|    return absl::string_view(
  149|   612k|        text_message_with_prefix_and_newline_and_nul_.data(),
  150|   612k|        text_message_with_prefix_and_newline_and_nul_.size() - 1);
  151|   612k|  }
_ZNK4absl12lts_202605268LogEntry10stacktraceEv:
  195|   612k|  absl::string_view stacktrace() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  196|   612k|    return stacktrace_;
  197|   612k|  }
_ZN4absl12lts_202605268LogEntryC2Ev:
  200|   612k|  LogEntry() = default;

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

_ZN4absl12lts_2026052611countl_zeroIjEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  108|  39.3k|    countl_zero(T x) noexcept {
  109|  39.3k|  return numeric_internal::CountLeadingZeroes(x);
  110|  39.3k|}

_ZN4absl12lts_202605267uint128rSEi:
  631|     62|inline uint128& uint128::operator>>=(int amount) {
  632|     62|  *this = *this >> amount;
  633|     62|  return *this;
  634|     62|}
_ZN4absl12lts_202605267uint128pLES1_:
  636|     39|inline uint128& uint128::operator+=(uint128 other) {
  637|     39|  *this = *this + other;
  638|     39|  return *this;
  639|     39|}
_ZN4absl12lts_20260526ltENS0_7uint128ES1_:
  832|     31|constexpr bool operator<(uint128 lhs, uint128 rhs) {
  833|     31|#ifdef ABSL_HAVE_INTRINSIC_INT128
  834|     31|  return static_cast<unsigned __int128>(lhs) <
  835|     31|         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|     31|}
_ZN4absl12lts_20260526gtENS0_7uint128ES1_:
  843|     31|constexpr bool operator>(uint128 lhs, uint128 rhs) { return rhs < lhs; }
_ZN4absl12lts_20260526anENS0_7uint128ES1_:
  923|     31|constexpr inline uint128 operator&(uint128 lhs, uint128 rhs) {
  924|     31|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  925|     31|  return static_cast<unsigned __int128>(lhs) &
  926|     31|         static_cast<unsigned __int128>(rhs);
  927|       |#else
  928|       |  return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
  929|       |                     Uint128Low64(lhs) & Uint128Low64(rhs));
  930|       |#endif
  931|     31|}
_ZN4absl12lts_20260526eoENS0_7uint128ES1_:
  933|  1.13k|constexpr inline uint128 operator^(uint128 lhs, uint128 rhs) {
  934|  1.13k|#if defined(ABSL_HAVE_INTRINSIC_INT128)
  935|  1.13k|  return static_cast<unsigned __int128>(lhs) ^
  936|  1.13k|         static_cast<unsigned __int128>(rhs);
  937|       |#else
  938|       |  return MakeUint128(Uint128High64(lhs) ^ Uint128High64(rhs),
  939|       |                     Uint128Low64(lhs) ^ Uint128Low64(rhs));
  940|       |#endif
  941|  1.13k|}
_ZN4absl12lts_202605267uint128eOES1_:
  953|  1.13k|inline uint128& uint128::operator^=(uint128 other) {
  954|  1.13k|  *this = *this ^ other;
  955|  1.13k|  return *this;
  956|  1.13k|}
_ZN4absl12lts_20260526lsENS0_7uint128Ei:
  960|     62|constexpr uint128 operator<<(uint128 lhs, int amount) {
  961|     62|#ifdef ABSL_HAVE_INTRINSIC_INT128
  962|     62|  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|     62|}
_ZN4absl12lts_20260526plENS0_7uint128ES1_:
  999|     70|constexpr uint128 operator+(uint128 lhs, uint128 rhs) {
 1000|     70|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1001|     70|  return static_cast<unsigned __int128>(lhs) +
 1002|     70|         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|     70|}
_ZN4absl12lts_20260526miENS0_7uint128ES1_:
 1022|     31|constexpr uint128 operator-(uint128 lhs, uint128 rhs) {
 1023|     31|#if defined(ABSL_HAVE_INTRINSIC_INT128)
 1024|     31|  return static_cast<unsigned __int128>(lhs) -
 1025|     31|         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|     31|}
_ZN4absl12lts_202605267uint128C2Ei:
  672|    124|    : lo_{static_cast<uint64_t>(v)},
  673|    124|      hi_{v < 0 ? (std::numeric_limits<uint64_t>::max)() : 0} {}
  ------------------
  |  Branch (673:11): [True: 0, False: 124]
  ------------------

_ZN4absl12lts_2026052616numeric_internal20CountLeadingZeroes32Ej:
  165|  39.3k|CountLeadingZeroes32(uint32_t x) {
  166|  39.3k|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_clz)
  167|       |  // Use __builtin_clz, which uses the following instructions:
  168|       |  //  x86: bsr, lzcnt
  169|       |  //  ARM64: clz
  170|       |  //  PPC: cntlzd
  171|       |
  172|  39.3k|  static_assert(sizeof(unsigned int) == sizeof(x),
  173|  39.3k|                "__builtin_clz does not take 32-bit arg");
  174|       |  // Handle 0 as a special case because __builtin_clz(0) is undefined.
  175|  39.3k|  return x == 0 ? 32 : __builtin_clz(x);
  ------------------
  |  Branch (175:10): [True: 0, False: 39.3k]
  ------------------
  176|       |#elif defined(_MSC_VER) && !defined(__clang__)
  177|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  178|       |  if (_BitScanReverse(&result, x)) {
  179|       |    return 31 - result;
  180|       |  }
  181|       |  return 32;
  182|       |#else
  183|       |  int zeroes = 28;
  184|       |  if (x >> 16) {
  185|       |    zeroes -= 16;
  186|       |    x >>= 16;
  187|       |  }
  188|       |  if (x >> 8) {
  189|       |    zeroes -= 8;
  190|       |    x >>= 8;
  191|       |  }
  192|       |  if (x >> 4) {
  193|       |    zeroes -= 4;
  194|       |    x >>= 4;
  195|       |  }
  196|       |  return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0"[x] + zeroes;
  197|       |#endif
  198|  39.3k|}
_ZN4absl12lts_2026052616numeric_internal18CountLeadingZeroesIjEEiT_:
  268|  39.3k|CountLeadingZeroes(T x) {
  269|  39.3k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  270|  39.3k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  271|  39.3k|                "T must have a power-of-2 size");
  272|  39.3k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  273|  39.3k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (273:10): [Folded, False: 39.3k]
  ------------------
  274|  39.3k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  275|      0|                   (std::numeric_limits<uint16_t>::digits -
  276|      0|                    std::numeric_limits<T>::digits)
  277|  39.3k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (277:17): [True: 39.3k, Folded]
  ------------------
  278|  39.3k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  279|  39.3k|                          (std::numeric_limits<uint32_t>::digits -
  280|  39.3k|                           std::numeric_limits<T>::digits)
  281|  39.3k|                    : CountLeadingZeroes64(x));
  282|  39.3k|}

_ZN4absl12lts_2026052615random_internal24GetEntropyFromRandenPoolEPvm:
  178|  8.53k|void GetEntropyFromRandenPool(void* dest, size_t bytes) {
  179|  8.53k|  auto* pool = GetPoolForCurrentThread();
  180|  8.53k|  pool->Fill(reinterpret_cast<uint8_t*>(dest), bytes);
  181|  8.53k|}
entropy_pool.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_123GetPoolForCurrentThreadEv:
  171|  8.53k|RandenPoolEntry* GetPoolForCurrentThread() {
  172|  8.53k|  absl::call_once(pool_once, InitPoolURBG);
  173|  8.53k|  return shared_pools[GetPoolID()];
  174|  8.53k|}
entropy_pool.cc:_ZN4absl12lts_2026052615random_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_2026052615random_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_2026052615random_internal12_GLOBAL__N_19GetPoolIDEv:
  116|  8.53k|size_t GetPoolID() {
  117|  8.53k|  static_assert(kPoolSize >= 1,
  118|  8.53k|                "At least one urbg instance is required for PoolURBG");
  119|       |
  120|  8.53k|  ABSL_CONST_INIT static std::atomic<uint64_t> sequence{0};
  ------------------
  |  |  849|  8.53k|#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
  ------------------
  121|       |
  122|  8.53k|#ifdef ABSL_HAVE_THREAD_LOCAL
  123|  8.53k|  static thread_local size_t my_pool_id = kPoolSize;
  124|  8.53k|  if (ABSL_PREDICT_FALSE(my_pool_id == kPoolSize)) {
  ------------------
  |  |  190|  8.53k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 8.53k]
  |  |  |  Branch (190:49): [Folded, False: 8.53k]
  |  |  |  Branch (190:58): [True: 1, False: 8.53k]
  |  |  ------------------
  ------------------
  125|      1|    my_pool_id = (sequence++ % kPoolSize);
  126|      1|  }
  127|  8.53k|  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|  8.53k|}
entropy_pool.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_115RandenPoolEntry4FillEPhm:
   86|  8.53k|void RandenPoolEntry::Fill(uint8_t* out, size_t bytes) {
   87|  8.53k|  SpinLockHolder l(mu_);
   88|  17.6k|  while (bytes > 0) {
  ------------------
  |  Branch (88:10): [True: 9.10k, False: 8.53k]
  ------------------
   89|  9.10k|    MaybeRefill();
   90|  9.10k|    size_t remaining = available() * sizeof(state_[0]);
   91|  9.10k|    size_t to_copy = std::min(bytes, remaining);
   92|  9.10k|    std::memcpy(out, &state_[next_], to_copy);
   93|  9.10k|    out += to_copy;
   94|  9.10k|    bytes -= to_copy;
   95|  9.10k|    next_ += (to_copy + sizeof(state_[0]) - 1) / sizeof(state_[0]);
   96|  9.10k|  }
   97|  8.53k|}
entropy_pool.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_115RandenPoolEntry11MaybeRefillEv:
   66|  9.10k|  inline void MaybeRefill() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
   67|  9.10k|    if (next_ >= kState) {
  ------------------
  |  Branch (67:9): [True: 1.13k, False: 7.96k]
  ------------------
   68|  1.13k|      next_ = kCapacity;
   69|  1.13k|      impl_.Generate(state_);
   70|  1.13k|    }
   71|  9.10k|  }
entropy_pool.cc:_ZNK4absl12lts_2026052615random_internal12_GLOBAL__N_115RandenPoolEntry9availableEv:
   73|  9.10k|  inline size_t available() const ABSL_SHARED_LOCKS_REQUIRED(mu_) {
   74|  9.10k|    return kState - next_;
   75|  9.10k|  }

_ZN4absl12lts_2026052615random_internal6RandenC2Ev:
   81|  9.80k|Randen::Randen() {
   82|  9.80k|  auto tmp = GetRandenState();
   83|  9.80k|  keys_ = tmp.keys;
   84|  9.80k|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   85|  9.80k|  has_crypto_ = tmp.has_crypto;
   86|  9.80k|#endif
   87|  9.80k|}
randen.cc:_ZN4absl12lts_2026052615random_internal12_GLOBAL__N_114GetRandenStateEv:
   53|  9.80k|RandenState GetRandenState() {
   54|  9.80k|  static const RandenState state = []() {
   55|  9.80k|    RandenState tmp;
   56|  9.80k|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   57|       |    // HW AES Dispatch.
   58|  9.80k|    if (HasRandenHwAesImplementation() && CPUSupportsRandenHwAes()) {
   59|  9.80k|      tmp.has_crypto = true;
   60|  9.80k|      tmp.keys = RandenHwAes::GetKeys();
   61|  9.80k|    } else {
   62|  9.80k|      tmp.has_crypto = false;
   63|  9.80k|      tmp.keys = RandenSlow::GetKeys();
   64|  9.80k|    }
   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|  9.80k|    return tmp;
   75|  9.80k|  }();
   76|  9.80k|  return state;
   77|  9.80k|}
randen.cc:_ZZN4absl12lts_2026052615random_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_2026052615random_internal28HasRandenHwAesImplementationEv:
   54|      1|bool HasRandenHwAesImplementation() { return false; }

_ZN4absl12lts_2026052615random_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_2026052615random_internal10RandenSlow6AbsorbEPKvPv:
  431|  9.79k|void RandenSlow::Absorb(const void* seed_void, void* state_void) {
  432|  9.79k|  auto* state =
  433|  9.79k|      reinterpret_cast<uint64_t * ABSL_RANDOM_INTERNAL_RESTRICT>(state_void);
  434|  9.79k|  const auto* seed =
  435|  9.79k|      reinterpret_cast<const uint64_t * ABSL_RANDOM_INTERNAL_RESTRICT>(
  436|  9.79k|          seed_void);
  437|       |
  438|  9.79k|  constexpr size_t kCapacityBlocks =
  439|  9.79k|      RandenTraits::kCapacityBytes / sizeof(uint64_t);
  440|  9.79k|  static_assert(
  441|  9.79k|      kCapacityBlocks * sizeof(uint64_t) == RandenTraits::kCapacityBytes,
  442|  9.79k|      "Not i*V");
  443|       |
  444|  9.79k|  for (size_t i = kCapacityBlocks;
  445|   303k|       i < RandenTraits::kStateBytes / sizeof(uint64_t); ++i) {
  ------------------
  |  Branch (445:8): [True: 293k, False: 9.79k]
  ------------------
  446|   293k|    state[i] ^= seed[i - kCapacityBlocks];
  447|   293k|  }
  448|  9.79k|}
_ZN4absl12lts_2026052615random_internal10RandenSlow8GenerateEPKvPv:
  450|  1.13k|void RandenSlow::Generate(const void* keys_void, void* state_void) {
  451|  1.13k|  static_assert(RandenTraits::kCapacityBytes == sizeof(absl::uint128),
  452|  1.13k|                "Capacity mismatch");
  453|       |
  454|  1.13k|  auto* state = reinterpret_cast<absl::uint128*>(state_void);
  455|  1.13k|  const auto* keys = reinterpret_cast<const absl::uint128*>(keys_void);
  456|       |
  457|  1.13k|  const absl::uint128 prev_inner = state[0];
  458|       |
  459|  1.13k|  SwapEndian(state);
  460|       |
  461|  1.13k|  Permute(state, keys);
  462|       |
  463|  1.13k|  SwapEndian(state);
  464|       |
  465|       |  // Ensure backtracking resistance.
  466|  1.13k|  *state ^= prev_inner;
  467|  1.13k|}
randen_slow.cc:_ZN12_GLOBAL__N_110SwapEndianEPN4absl12lts_202605267uint128E:
  400|  2.27k|    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.27k|  (void)state;
  412|  2.27k|#endif
  413|  2.27k|}
randen_slow.cc:_ZN12_GLOBAL__N_17PermuteEPN4absl12lts_202605267uint128EPKS2_:
  391|  1.13k|    const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) {
  392|  20.5k|  for (size_t round = 0; round < RandenTraits::kFeistelRounds; ++round) {
  ------------------
  |  Branch (392:26): [True: 19.3k, False: 1.13k]
  ------------------
  393|  19.3k|    keys = FeistelRound(state, keys);
  394|  19.3k|    BlockShuffle(state);
  395|  19.3k|  }
  396|  1.13k|}
randen_slow.cc:_ZN12_GLOBAL__N_112FeistelRoundEPN4absl12lts_202605267uint128EPKS2_:
  365|  19.3k|             const absl::uint128* ABSL_RANDOM_INTERNAL_RESTRICT keys) {
  366|  96.8k|  for (size_t branch = 0; branch < RandenTraits::kFeistelBlocks; branch += 4) {
  ------------------
  |  Branch (366:27): [True: 77.4k, False: 19.3k]
  ------------------
  367|  77.4k|    const Vector128 s0 = Vector128Load(state + branch);
  368|  77.4k|    const Vector128 s1 = Vector128Load(state + branch + 1);
  369|  77.4k|    const Vector128 f0 = AesRound(s0, Vector128Load(keys));
  370|  77.4k|    keys++;
  371|  77.4k|    const Vector128 o1 = AesRound(f0, s1);
  372|  77.4k|    Vector128Store(o1, state + branch + 1);
  373|       |
  374|       |    // Manually unroll this loop once. about 10% better than not unrolled.
  375|  77.4k|    const Vector128 s2 = Vector128Load(state + branch + 2);
  376|  77.4k|    const Vector128 s3 = Vector128Load(state + branch + 3);
  377|  77.4k|    const Vector128 f2 = AesRound(s2, Vector128Load(keys));
  378|  77.4k|    keys++;
  379|  77.4k|    const Vector128 o3 = AesRound(f2, s3);
  380|  77.4k|    Vector128Store(o3, state + branch + 3);
  381|  77.4k|  }
  382|  19.3k|  return keys;
  383|  19.3k|}
randen_slow.cc:_ZN12_GLOBAL__N_113Vector128LoadEPKv:
  239|   464k|Vector128Load(const void* from) {
  240|   464k|  Vector128 result;
  241|   464k|  std::memcpy(result.s, from, sizeof(Vector128));
  242|   464k|  return result;
  243|   464k|}
randen_slow.cc:_ZN12_GLOBAL__N_18AesRoundERKNS_9Vector128ES2_:
  253|   309k|AesRound(const Vector128& state, const Vector128& round_key) {
  254|   309k|  Vector128 result;
  255|   309k|#ifdef ABSL_IS_LITTLE_ENDIAN
  256|   309k|  result.s[0] = round_key.s[0] ^                  //
  257|   309k|                te0[uint8_t(state.s[0])] ^        //
  258|   309k|                te1[uint8_t(state.s[1] >> 8)] ^   //
  259|   309k|                te2[uint8_t(state.s[2] >> 16)] ^  //
  260|   309k|                te3[uint8_t(state.s[3] >> 24)];
  261|   309k|  result.s[1] = round_key.s[1] ^                  //
  262|   309k|                te0[uint8_t(state.s[1])] ^        //
  263|   309k|                te1[uint8_t(state.s[2] >> 8)] ^   //
  264|   309k|                te2[uint8_t(state.s[3] >> 16)] ^  //
  265|   309k|                te3[uint8_t(state.s[0] >> 24)];
  266|   309k|  result.s[2] = round_key.s[2] ^                  //
  267|   309k|                te0[uint8_t(state.s[2])] ^        //
  268|   309k|                te1[uint8_t(state.s[3] >> 8)] ^   //
  269|   309k|                te2[uint8_t(state.s[0] >> 16)] ^  //
  270|   309k|                te3[uint8_t(state.s[1] >> 24)];
  271|   309k|  result.s[3] = round_key.s[3] ^                  //
  272|   309k|                te0[uint8_t(state.s[3])] ^        //
  273|   309k|                te1[uint8_t(state.s[0] >> 8)] ^   //
  274|   309k|                te2[uint8_t(state.s[1] >> 16)] ^  //
  275|   309k|                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|   309k|  return result;
  299|   309k|}
randen_slow.cc:_ZN12_GLOBAL__N_114Vector128StoreERKNS_9Vector128EPv:
  246|   154k|    const Vector128& v, void* to) {
  247|   154k|  std::memcpy(to, v.s, sizeof(Vector128));
  248|   154k|}
randen_slow.cc:_ZN12_GLOBAL__N_112BlockShuffleEPN4absl12lts_202605267uint128E:
  305|  19.3k|    absl::uint128* state) {
  306|  19.3k|  static_assert(RandenTraits::kFeistelBlocks == 16,
  307|  19.3k|                "Feistel block shuffle only works for 16 blocks.");
  308|       |
  309|  19.3k|  constexpr size_t shuffle[RandenTraits::kFeistelBlocks] = {
  310|  19.3k|      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|  19.3k|  const absl::uint128 v0 = state[shuffle[0]];
  325|  19.3k|  const absl::uint128 v1 = state[shuffle[1]];
  326|  19.3k|  const absl::uint128 v2 = state[shuffle[2]];
  327|  19.3k|  const absl::uint128 v3 = state[shuffle[3]];
  328|  19.3k|  const absl::uint128 v4 = state[shuffle[4]];
  329|  19.3k|  const absl::uint128 v5 = state[shuffle[5]];
  330|  19.3k|  const absl::uint128 v6 = state[shuffle[6]];
  331|  19.3k|  const absl::uint128 v7 = state[shuffle[7]];
  332|  19.3k|  const absl::uint128 w0 = state[shuffle[8]];
  333|  19.3k|  const absl::uint128 w1 = state[shuffle[9]];
  334|  19.3k|  const absl::uint128 w2 = state[shuffle[10]];
  335|  19.3k|  const absl::uint128 w3 = state[shuffle[11]];
  336|  19.3k|  const absl::uint128 w4 = state[shuffle[12]];
  337|  19.3k|  const absl::uint128 w5 = state[shuffle[13]];
  338|  19.3k|  const absl::uint128 w6 = state[shuffle[14]];
  339|  19.3k|  const absl::uint128 w7 = state[shuffle[15]];
  340|  19.3k|  state[0] = v0;
  341|  19.3k|  state[1] = v1;
  342|  19.3k|  state[2] = v2;
  343|  19.3k|  state[3] = v3;
  344|  19.3k|  state[4] = v4;
  345|  19.3k|  state[5] = v5;
  346|  19.3k|  state[6] = v6;
  347|  19.3k|  state[7] = v7;
  348|  19.3k|  state[8] = w0;
  349|  19.3k|  state[9] = w1;
  350|  19.3k|  state[10] = w2;
  351|  19.3k|  state[11] = w3;
  352|  19.3k|  state[12] = w4;
  353|  19.3k|  state[13] = w5;
  354|  19.3k|  state[14] = w6;
  355|  19.3k|  state[15] = w7;
  356|  19.3k|}

_ZN4absl12lts_2026052615random_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_2026052615random_internal19MixIntoSeedMaterialENS0_4SpanIKjEENS2_IjEE:
  200|  1.25k|                         absl::Span<uint32_t> seed_material) {
  201|       |  // Algorithm is based on code available at
  202|       |  // https://gist.github.com/imneme/540829265469e673d045
  203|  1.25k|  constexpr uint32_t kInitVal = 0x43b0d7e5;
  204|  1.25k|  constexpr uint32_t kHashMul = 0x931e8875;
  205|  1.25k|  constexpr uint32_t kMixMulL = 0xca01f9dd;
  206|  1.25k|  constexpr uint32_t kMixMulR = 0x4973f715;
  207|  1.25k|  constexpr uint32_t kShiftSize = sizeof(uint32_t) * 8 / 2;
  208|       |
  209|  1.25k|  uint32_t hash_const = kInitVal;
  210|  1.25k|  auto hash = [&](uint32_t value) {
  211|  1.25k|    value ^= hash_const;
  212|  1.25k|    hash_const *= kHashMul;
  213|  1.25k|    value *= hash_const;
  214|  1.25k|    value ^= value >> kShiftSize;
  215|  1.25k|    return value;
  216|  1.25k|  };
  217|       |
  218|  1.25k|  auto mix = [&](uint32_t x, uint32_t y) {
  219|  1.25k|    uint32_t result = kMixMulL * x - kMixMulR * y;
  220|  1.25k|    result ^= result >> kShiftSize;
  221|  1.25k|    return result;
  222|  1.25k|  };
  223|       |
  224|  1.25k|  for (const auto& seq_val : sequence) {
  ------------------
  |  Branch (224:28): [True: 1.25k, False: 1.25k]
  ------------------
  225|  1.25k|    for (auto& elem : seed_material) {
  ------------------
  |  Branch (225:21): [True: 1.25k, False: 1.25k]
  ------------------
  226|  1.25k|      elem = mix(elem, hash(seq_val));
  227|  1.25k|    }
  228|  1.25k|  }
  229|  1.25k|}
_ZN4absl12lts_2026052615random_internal15GetSaltMaterialEv:
  231|  1.25k|std::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.25k|  static const auto salt_material = []() -> std::optional<uint32_t> {
  235|  1.25k|    uint32_t salt_value = 0;
  236|       |
  237|  1.25k|    if (ReadSeedMaterialFromOSEntropy(absl::MakeSpan(&salt_value, 1))) {
  238|  1.25k|      return salt_value;
  239|  1.25k|    }
  240|       |
  241|  1.25k|    return std::nullopt;
  242|  1.25k|  }();
  243|       |
  244|  1.25k|  return salt_material;
  245|  1.25k|}
seed_material.cc:_ZN4absl12lts_2026052615random_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_2026052615random_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_2026052615random_internal19MixIntoSeedMaterialENS0_4SpanIKjEENS2_IjEEENK3$_1clEjj:
  218|  1.25k|  auto mix = [&](uint32_t x, uint32_t y) {
  219|  1.25k|    uint32_t result = kMixMulL * x - kMixMulR * y;
  220|  1.25k|    result ^= result >> kShiftSize;
  221|  1.25k|    return result;
  222|  1.25k|  };
seed_material.cc:_ZZN4absl12lts_2026052615random_internal19MixIntoSeedMaterialENS0_4SpanIKjEENS2_IjEEENK3$_0clEj:
  210|  1.25k|  auto hash = [&](uint32_t value) {
  211|  1.25k|    value ^= hash_const;
  212|  1.25k|    hash_const *= kHashMul;
  213|  1.25k|    value *= hash_const;
  214|  1.25k|    value ^= value >> kShiftSize;
  215|  1.25k|    return value;
  216|  1.25k|  };
seed_material.cc:_ZZN4absl12lts_2026052615random_internal15GetSaltMaterialEvENK3$_0clEv:
  234|      1|  static const auto salt_material = []() -> std::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 std::nullopt;
  242|      1|  }();

_ZNK4absl12lts_2026052615status_internal9StatusRep5UnrefEv:
   53|  4.26k|void StatusRep::Unref() const {
   54|       |  // Fast path: if ref==1, there is no need for a RefCountDec (since
   55|       |  // this is the only reference and therefore no other thread is
   56|       |  // allowed to be mucking with r).
   57|  4.26k|  if (ref_.load(std::memory_order_acquire) == 1 ||
  ------------------
  |  Branch (57:7): [True: 4.24k, False: 11]
  ------------------
   58|  4.24k|      ref_.fetch_sub(1, std::memory_order_acq_rel) - 1 == 0) {
  ------------------
  |  Branch (58:7): [True: 0, False: 11]
  ------------------
   59|  4.24k|    delete this;
   60|  4.24k|  }
   61|  4.26k|}
_ZN4absl12lts_2026052615status_internal9StatusRep17AddSourceLocationENS0_14SourceLocationE:
  141|  12.6k|void StatusRep::AddSourceLocation(absl::SourceLocation loc) {
  142|  12.6k|  source_locations_.push_back(loc);
  143|  12.6k|}
_ZNK4absl12lts_2026052615status_internal9StatusRep5CloneENS0_12optional_refINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEbb:
  217|  12.6k|    bool include_source_locations) const {
  218|       |  // Optimization: no need to create a clone if we already have a refcount of 1.
  219|  12.6k|  if (ref_.load(std::memory_order_acquire) == 1 && !new_message.has_value() &&
  ------------------
  |  Branch (219:7): [True: 12.6k, False: 11]
  |  Branch (219:52): [True: 12.6k, False: 0]
  ------------------
  220|  12.6k|      include_payloads && include_source_locations) {
  ------------------
  |  Branch (220:7): [True: 12.6k, False: 0]
  |  Branch (220:27): [True: 12.6k, False: 0]
  ------------------
  221|       |    // All StatusRep instances are heap allocated and mutable, therefore this
  222|       |    // const_cast will never cast away const from a stack instance.
  223|       |    //
  224|       |    // CloneAndUnref is the only method that doesn't involve an external cast to
  225|       |    // get a mutable StatusRep* from the uintptr_t rep stored in Status.
  226|  12.6k|    return const_cast<StatusRep*>(this);
  227|  12.6k|  }
  228|     11|  std::unique_ptr<status_internal::Payloads> payloads;
  229|     11|  if (include_payloads && payloads_) {
  ------------------
  |  Branch (229:7): [True: 11, False: 0]
  |  Branch (229:27): [True: 0, False: 11]
  ------------------
  230|      0|    payloads = std::make_unique<status_internal::Payloads>(*payloads_);
  231|      0|  }
  232|     11|  auto* new_rep =
  233|     11|      new StatusRep(code_, new_message.value_or(message_), std::move(payloads));
  234|     11|  if (include_source_locations) {
  ------------------
  |  Branch (234:7): [True: 11, False: 0]
  ------------------
  235|     11|    new_rep->source_locations_ = source_locations_;
  236|     11|  }
  237|     11|  return new_rep;
  238|  12.6k|}
_ZNK4absl12lts_2026052615status_internal9StatusRep13CloneAndUnrefEv:
  240|  12.6k|StatusRep* absl_nonnull StatusRep::CloneAndUnref() const {
  241|  12.6k|  return CloneAndUnref(std::nullopt, true, true);
  242|  12.6k|}
_ZNK4absl12lts_2026052615status_internal9StatusRep13CloneAndUnrefENS0_12optional_refINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEEEbb:
  246|  12.6k|    bool include_source_locations) const {
  247|  12.6k|  StatusRep* new_rep =
  248|  12.6k|      Clone(new_message, /*include_payloads=*/include_payloads,
  249|  12.6k|            /*include_source_locations=*/include_source_locations);
  250|  12.6k|  if (new_rep != this) {
  ------------------
  |  Branch (250:7): [True: 11, False: 12.6k]
  ------------------
  251|     11|    Unref();
  252|     11|  }
  253|  12.6k|  return new_rep;
  254|  12.6k|}

_ZN4absl12lts_2026052615status_internal9StatusRepC2ENS0_10StatusCodeENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS4_10unique_ptrINS0_13InlinedVectorINS1_7PayloadELm1ENS4_9allocatorISB_EEEENS4_14default_deleteISE_EEEE:
   82|  4.24k|      : ref_(int32_t{1}),
   83|  4.24k|        code_(code_arg),
   84|  4.24k|        message_(message_arg),
   85|  4.24k|        payloads_(std::move(payloads_arg)) {}

_ZN4absl12lts_2026052615status_internal13MakeErrorImplILi13EEENS0_6StatusENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS0_14SourceLocationE:
  164|      5|Status MakeErrorImpl(string_view message, SourceLocation loc) {
  165|      5|  return Status(static_cast<StatusCode>(error_code), message, loc);
  166|      5|}
_ZN4absl12lts_202605266Status7MakeRepEmNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEENS0_14SourceLocationE:
  116|  4.23k|                          absl::SourceLocation loc) {
  117|  4.23k|  bool ok = inlined_rep == CodeToInlinedRep(absl::StatusCode::kOk);
  118|  4.23k|  if (ok) return inlined_rep;
  ------------------
  |  Branch (118:7): [True: 0, False: 4.23k]
  ------------------
  119|  4.23k|  if (msg.empty()
  ------------------
  |  Branch (119:7): [True: 4.23k, False: 5]
  ------------------
  120|  4.23k|  ) {
  121|  4.23k|    return inlined_rep;
  122|  4.23k|  }
  123|      5|  auto* rep = new status_internal::StatusRep(InlinedRepToCode(inlined_rep), msg,
  124|      5|                                             nullptr);
  125|      5|  if (loc.file_name()[0] != '\0') {
  ------------------
  |  Branch (125:7): [True: 5, False: 0]
  ------------------
  126|      5|    rep->AddSourceLocation(loc);
  127|      5|  }
  128|      5|  return PointerToRep(rep);
  129|  4.23k|}
_ZN4absl12lts_202605266Status21AddSourceLocationImplEmNS0_14SourceLocationE:
  132|  12.6k|                                        absl::SourceLocation loc) {
  133|  12.6k|  if (IsInlined(rep)) return rep;
  ------------------
  |  Branch (133:7): [True: 0, False: 12.6k]
  ------------------
  134|  12.6k|  if (loc.file_name()[0] == '\0') return rep;
  ------------------
  |  Branch (134:7): [True: 0, False: 12.6k]
  ------------------
  135|  12.6k|  status_internal::StatusRep* rep_ptr = PrepareToModify(rep);
  136|  12.6k|  rep_ptr->AddSourceLocation(loc);
  137|  12.6k|  return PointerToRep(rep_ptr);
  138|  12.6k|}
_ZN4absl12lts_202605266Status15PrepareToModifyEm:
  141|  12.6k|    uintptr_t rep) {
  142|  12.6k|  if (IsInlined(rep)) {
  ------------------
  |  Branch (142:7): [True: 0, False: 12.6k]
  ------------------
  143|      0|    return new status_internal::StatusRep(InlinedRepToCode(rep),
  144|      0|                                          absl::string_view(), nullptr);
  145|      0|  }
  146|  12.6k|  return RepToPointer(rep)->CloneAndUnref();
  147|  12.6k|}

_ZN4absl12lts_202605266StatusD2Ev:
  940|   534k|inline Status::~Status() { Unref(rep_); }
_ZN4absl12lts_202605266Status5UnrefEm:
 1046|   534k|inline void Status::Unref(uintptr_t rep) {
 1047|   534k|  if (!IsInlined(rep)) RepToPointer(rep)->Unref();
  ------------------
  |  Branch (1047:7): [True: 4.24k, False: 529k]
  ------------------
 1048|   534k|}
_ZN4absl12lts_202605266Status9IsInlinedEm:
 1014|   765k|constexpr bool Status::IsInlined(uintptr_t rep) { return (rep & 1) != 0; }
_ZN4absl12lts_202605266Status12RepToPointerEm:
 1032|  16.9k|    uintptr_t rep) {
 1033|  16.9k|  assert(!IsInlined(rep));
  ------------------
  |  Branch (1033:3): [True: 4.23k, False: 12.6k]
  ------------------
 1034|  4.23k|  return reinterpret_cast<const status_internal::StatusRep*>(rep);
 1035|  16.9k|}
_ZN4absl12lts_202605266Status17AddSourceLocationENS0_14SourceLocationE:
  644|  12.6k|      absl::SourceLocation loc = absl::SourceLocation::current()) {
  645|  12.6k|    if (ok()) return;
  ------------------
  |  Branch (645:9): [True: 0, False: 12.6k]
  ------------------
  646|  12.6k|    rep_ = AddSourceLocationImpl(rep_, loc);
  647|  12.6k|    ABSL_ATTRIBUTE_UNUSED bool okay = ok();
  ------------------
  |  |  582|  12.6k|#define ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))
  ------------------
  648|       |    // This hint tells the optimizer that the status is still not ok after the
  649|       |    // AddSourceLocation() call. This is useful when passing a known !ok status
  650|       |    // to StatusOr. StatusOr checks for ok() on its constructor and this assume
  651|       |    // helps the optimizer remove that check.
  652|  12.6k|    ABSL_ASSUME(!okay);
  ------------------
  |  |  271|  12.6k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  653|  12.6k|  }
_ZN4absl12lts_202605266Status16InlinedRepToCodeEm:
 1022|  4.23k|constexpr absl::StatusCode Status::InlinedRepToCode(uintptr_t rep) {
 1023|  4.23k|  ABSL_ASSERT(IsInlined(rep));
  ------------------
  |  |  127|  4.23k|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|  4.23k|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 4.23k]
  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1024|  4.23k|  return static_cast<absl::StatusCode>(rep >> 2);
 1025|  4.23k|}
_ZN4absl12lts_202605266Status12PointerToRepEPNS0_15status_internal9StatusRepE:
 1038|  16.9k|    status_internal::StatusRep* absl_nonnull rep) {
 1039|  16.9k|  return reinterpret_cast<uintptr_t>(rep);
 1040|  16.9k|}

_ZN4absl12lts_2026052613StatusBuilder7DestroyENSt3__110unique_ptrINS1_3RepENS2_14default_deleteIS4_EEEE:
   37|  8.44k|void StatusBuilder::Destroy(std::unique_ptr<Rep>) {
   38|       |  // nothing to do. The unique_ptr will do the cleanup.
   39|  8.44k|}
_ZN4absl12lts_2026052613StatusBuilder3RepC2EONS0_6StatusE:
   55|  12.6k|StatusBuilder::Rep::Rep(absl::Status&& s) : status(std::move(s)) {}
_ZN4absl12lts_2026052613StatusBuilder3RepD2Ev:
   56|  12.6k|StatusBuilder::Rep::~Rep() {}
_ZN4absl12lts_2026052613StatusBuilder11InitRepImplENS0_6StatusE:
   58|  12.6k|StatusBuilder::Rep* StatusBuilder::InitRepImpl(absl::Status s) {
   59|  12.6k|  if (s.ok()) {
  ------------------
  |  Branch (59:7): [True: 0, False: 12.6k]
  ------------------
   60|      0|    return nullptr;
   61|  12.6k|  } else {
   62|  12.6k|    return new Rep(std::move(s));
   63|  12.6k|  }
   64|  12.6k|}
_ZN4absl12lts_2026052613StatusBuilder3Rep10InitStreamEv:
   83|  4.23k|void StatusBuilder::Rep::InitStream() { stream.emplace(stream_message); }
_ZN4absl12lts_2026052613StatusBuilder31CreateStatusAndConditionallyLogENS0_14SourceLocationENSt3__110unique_ptrINS1_3RepENS3_14default_deleteIS5_EEEE:
  163|  12.6k|    absl::SourceLocation loc, std::unique_ptr<Rep> rep) {
  164|  12.6k|  if (rep == nullptr) return absl::OkStatus();
  ------------------
  |  Branch (164:7): [True: 0, False: 12.6k]
  ------------------
  165|  12.6k|  absl::Status result = status_internal::StatusPrivateAccessorForStatusBuilder::
  166|  12.6k|      JoinMessageToStatus(std::move(rep->status), rep->stream_message,
  167|  12.6k|                          rep->message_join_style);
  168|       |  // Passing in the `loc` last to ensure the sequence of the source locations.
  169|  12.6k|  result.AddSourceLocation(loc);
  170|  12.6k|  return result;
  171|  12.6k|}
_ZN4absl12lts_2026052615status_internal37StatusPrivateAccessorForStatusBuilder19JoinMessageToStatusENS0_6StatusENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS0_16MessageJoinStyleE:
  136|  12.6k|                                          MessageJoinStyle style) {
  137|  12.6k|    if (s.ok() || msg.empty()) return s;
  ------------------
  |  Branch (137:9): [True: 0, False: 12.6k]
  |  Branch (137:19): [True: 8.43k, False: 4.23k]
  ------------------
  138|  4.23k|    const absl::string_view original_message = s.message();
  139|  4.23k|    switch (style) {
  140|  4.23k|      case MessageJoinStyle::kAnnotate: {
  ------------------
  |  Branch (140:7): [True: 4.23k, False: 0]
  ------------------
  141|  4.23k|        std::string annotated;
  142|  4.23k|        if (!original_message.empty()) {
  ------------------
  |  Branch (142:13): [True: 0, False: 4.23k]
  ------------------
  143|      0|          absl::StrAppend(&annotated, original_message, "; ", msg);
  144|      0|          msg = annotated;
  145|      0|        }
  146|  4.23k|        return SetMessage(s, msg);
  147|      0|      }
  148|      0|      case MessageJoinStyle::kPrepend:
  ------------------
  |  Branch (148:7): [True: 0, False: 4.23k]
  ------------------
  149|      0|        return SetMessage(s, absl::StrCat(msg, original_message));
  150|      0|      case MessageJoinStyle::kAppend:
  ------------------
  |  Branch (150:7): [True: 0, False: 4.23k]
  ------------------
  151|      0|        return SetMessage(s, absl::StrCat(original_message, msg));
  152|      0|      default:
  ------------------
  |  Branch (152:7): [True: 0, False: 4.23k]
  ------------------
  153|      0|        return absl::InternalError("Unknown MessageJoinStyle");
  154|  4.23k|    }
  155|  4.23k|  }
_ZN4absl12lts_2026052615status_internal37StatusPrivateAccessorForStatusBuilder10SetMessageERKNS0_6StatusENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
  115|  4.23k|                                 absl::string_view message) {
  116|  4.23k|    ABSL_ASSERT(!status.ok());
  ------------------
  |  |  127|  4.23k|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|  4.23k|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 4.23k]
  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  117|       |
  118|  4.23k|    if (message.empty()) {
  ------------------
  |  Branch (118:9): [True: 0, False: 4.23k]
  ------------------
  119|      0|      return absl::Status(status.code(), message, absl::SourceLocation());
  120|      0|    }
  121|       |
  122|  4.23k|    using StatusRep =
  123|  4.23k|        std::remove_cv_t<std::remove_pointer_t<decltype(Status::RepToPointer(
  124|  4.23k|            std::declval<uintptr_t>()))>>;
  125|  4.23k|    StatusRep* rep;
  126|  4.23k|    if (Status::IsInlined(status.rep_)) {
  ------------------
  |  Branch (126:9): [True: 4.23k, False: 0]
  ------------------
  127|  4.23k|      rep = new StatusRep(Status::InlinedRepToCode(status.rep_), message,
  128|  4.23k|                          nullptr);
  129|  4.23k|    } else {
  130|      0|      rep = Status::RepToPointer(status.rep_)->Clone(message, true, true);
  131|      0|    }
  132|  4.23k|    return absl::Status(Status::PointerToRep(rep));
  133|  4.23k|  }

_ZN4absl12lts_2026052615status_internal6StreamC2ERNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   57|  4.23k|      : ostringstream_(&message), absl_stringify_stream_(ostringstream_) {}

_ZN4absl12lts_2026052614ascii_internal15AsciiStrToUpperEPcPKcm:
  226|  8.54k|                     size_t n) {
  227|  8.54k|  return AsciiStrCaseFold<true>(dst, src, n);
  228|  8.54k|}
_ZN4absl12lts_2026052614ascii_internal16AsciiStrCaseFoldILb1EEEvPcPKcm:
  215|  8.54k|                                const char* absl_nullable src, size_t size) {
  216|  8.54k|  size < 16 ? AsciiStrCaseFoldImpl<ToUpper, /*Naive=*/true>(dst, src, size)
  ------------------
  |  Branch (216:3): [True: 8.54k, False: 0]
  ------------------
  217|  8.54k|            : AsciiStrCaseFoldImpl<ToUpper, /*Naive=*/false>(dst, src, size);
  218|  8.54k|}
_ZN4absl12lts_2026052614ascii_internal20AsciiStrCaseFoldImplILb1ELb1EEEvPcPKcm:
  188|  8.54k|                                    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|  8.54k|  constexpr unsigned char kAsciiCaseBitFlip = 'a' ^ 'A';
  195|       |
  196|  59.0k|  for (size_t i = 0; i < size; ++i) {
  ------------------
  |  Branch (196:22): [True: 50.4k, False: 8.54k]
  ------------------
  197|  50.4k|    unsigned char v = static_cast<unsigned char>(src[i]);
  198|  50.4k|    if ABSL_INTERNAL_CONSTEXPR_SINCE_CXX17 (Naive) {
  199|  50.4k|      v ^= AsciiInAZRangeNaive<ToUpper>(v) ? kAsciiCaseBitFlip : 0;
  ------------------
  |  Branch (199:12): [True: 50.4k, False: 0]
  ------------------
  200|       |    } else {
  201|       |      v ^= AsciiInAZRange<ToUpper>(v) ? kAsciiCaseBitFlip : 0;
  202|       |    }
  203|  50.4k|    dst[i] = static_cast<char>(v);
  204|  50.4k|  }
  205|  8.54k|}
_ZN4absl12lts_2026052614ascii_internal19AsciiInAZRangeNaiveILb1EEEbh:
  179|  50.4k|constexpr bool AsciiInAZRangeNaive(unsigned char c) {
  180|  50.4k|  constexpr unsigned char a = (ToUpper ? 'a' : 'A');
  ------------------
  |  Branch (180:32): [True: 0, Folded]
  ------------------
  181|  50.4k|  constexpr unsigned char z = (ToUpper ? 'z' : 'Z');
  ------------------
  |  Branch (181:32): [True: 0, Folded]
  ------------------
  182|  50.4k|  return a <= c && c <= z;
  ------------------
  |  Branch (182:10): [True: 50.4k, False: 0]
  |  Branch (182:20): [True: 50.4k, False: 0]
  ------------------
  183|  50.4k|}

_ZN4absl12lts_2026052613ascii_isspaceEh:
  105|  42.0k|inline bool ascii_isspace(unsigned char c) {
  106|  42.0k|  return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
  107|  42.0k|}
_ZN4absl12lts_2026052627StripLeadingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  244|  2.17k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  245|  2.17k|  auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
  246|  2.17k|  return str.substr(static_cast<size_t>(it - str.begin()));
  247|  2.17k|}
_ZN4absl12lts_2026052628StripTrailingAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  258|  2.17k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  259|  2.17k|  auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
  260|  2.17k|  return str.substr(0, static_cast<size_t>(str.rend() - it));
  261|  2.17k|}
_ZN4absl12lts_2026052620StripAsciiWhitespaceENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  272|  2.17k|    absl::string_view str ABSL_ATTRIBUTE_LIFETIME_BOUND) {
  273|  2.17k|  return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
  274|  2.17k|}

_ZN4absl12lts_2026052610from_charsEPKcS2_RdNS0_12chars_formatE:
  949|  2.17k|                             chars_format fmt) {
  950|  2.17k|  return FromCharsImpl(first, last, value, fmt);
  951|  2.17k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113FromCharsImplIdEENS0_17from_chars_resultEPKcS5_RT_NS0_12chars_formatE:
  862|  2.17k|                                chars_format fmt_flags) {
  863|  2.17k|  from_chars_result result;
  864|  2.17k|  result.ptr = first;  // overwritten on successful parse
  865|  2.17k|  result.ec = std::errc();
  866|       |
  867|  2.17k|  bool negative = false;
  868|  2.17k|  if (first != last && *first == '-') {
  ------------------
  |  Branch (868:7): [True: 2.17k, False: 0]
  |  Branch (868:24): [True: 0, False: 2.17k]
  ------------------
  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.17k|  if ((fmt_flags & chars_format::hex) == chars_format{} && last - first >= 2 &&
  ------------------
  |  Branch (874:7): [True: 2.17k, False: 0]
  |  Branch (874:60): [True: 2.17k, False: 0]
  ------------------
  875|  2.17k|      *first == '0' && (first[1] == 'x' || first[1] == 'X')) {
  ------------------
  |  Branch (875:7): [True: 2.14k, False: 28]
  |  Branch (875:25): [True: 0, False: 2.14k]
  |  Branch (875:44): [True: 0, False: 2.14k]
  ------------------
  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.17k|  if ((fmt_flags & chars_format::hex) == chars_format::hex) {
  ------------------
  |  Branch (907:7): [True: 0, False: 2.17k]
  ------------------
  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.17k|  } else {
  923|  2.17k|    strings_internal::ParsedFloat decimal_parse =
  924|  2.17k|        strings_internal::ParseFloat<10>(first, last, fmt_flags);
  925|  2.17k|    if (decimal_parse.end == nullptr) {
  ------------------
  |  Branch (925:9): [True: 0, False: 2.17k]
  ------------------
  926|      0|      result.ec = std::errc::invalid_argument;
  927|      0|      return result;
  928|      0|    }
  929|  2.17k|    result.ptr = decimal_parse.end;
  930|  2.17k|    if (HandleEdgeCase(decimal_parse, negative, &value)) {
  ------------------
  |  Branch (930:9): [True: 0, False: 2.17k]
  ------------------
  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.17k|    if ((decimal_parse.subrange_begin == nullptr) &&
  ------------------
  |  Branch (935:9): [True: 2.17k, False: 0]
  ------------------
  936|  2.17k|        EiselLemire<FloatType>(decimal_parse, negative, &value, &result.ec)) {
  ------------------
  |  Branch (936:9): [True: 2.14k, False: 31]
  ------------------
  937|  2.14k|      return result;
  938|  2.14k|    }
  939|     31|    CalculatedFloat calculated =
  940|     31|        CalculateFromParsedDecimal<FloatType>(decimal_parse);
  941|     31|    EncodeResult(calculated, negative, &result, &value);
  942|     31|    return result;
  943|  2.17k|  }
  944|  2.17k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114HandleEdgeCaseIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_:
  360|  2.17k|                    FloatType* absl_nonnull value) {
  361|  2.17k|  if (input.type == strings_internal::FloatType::kNan) {
  ------------------
  |  Branch (361:7): [True: 0, False: 2.17k]
  ------------------
  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.17k|  if (input.type == strings_internal::FloatType::kInfinity) {
  ------------------
  |  Branch (386:7): [True: 0, False: 2.17k]
  ------------------
  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.17k|  if (input.mantissa == 0) {
  ------------------
  |  Branch (391:7): [True: 0, False: 2.17k]
  ------------------
  392|      0|    *value = negative ? -0.0f : 0.0f;
  ------------------
  |  Branch (392:14): [True: 0, False: 0]
  ------------------
  393|      0|    return true;
  394|      0|  }
  395|  2.17k|  return false;
  396|  2.17k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_119NormalizedShiftSizeIdEEiii:
  335|     31|int NormalizedShiftSize(int mantissa_width, int binary_exponent) {
  336|     31|  const int normal_shift =
  337|     31|      mantissa_width - FloatTraits<FloatType>::kTargetMantissaBits;
  338|     31|  const int minimum_shift =
  339|     31|      FloatTraits<FloatType>::kMinNormalExponent - binary_exponent;
  340|     31|  return std::max(normal_shift, minimum_shift);
  341|     31|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118ShiftRightAndRoundENS0_7uint128EibPb:
  453|     31|                            bool* absl_nonnull output_exact) {
  454|     31|  if (shift <= 0) {
  ------------------
  |  Branch (454:7): [True: 0, False: 31]
  ------------------
  455|      0|    *output_exact = input_exact;
  456|      0|    return static_cast<uint64_t>(value << -shift);
  457|      0|  }
  458|     31|  if (shift >= 128) {
  ------------------
  |  Branch (458:7): [True: 0, False: 31]
  ------------------
  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|     31|  *output_exact = true;
  467|     31|  const uint128 shift_mask = (uint128(1) << shift) - 1;
  468|     31|  const uint128 halfway_point = uint128(1) << (shift - 1);
  469|       |
  470|     31|  const uint128 shifted_bits = value & shift_mask;
  471|     31|  value >>= shift;
  472|     31|  if (shifted_bits > halfway_point) {
  ------------------
  |  Branch (472:7): [True: 31, False: 0]
  ------------------
  473|       |    // Shifted bits greater than 10000... require rounding up.
  474|     31|    return static_cast<uint64_t>(value + 1);
  475|     31|  }
  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_2026052612_GLOBAL__N_128CalculatedFloatFromRawValuesIdEENS1_15CalculatedFloatEmi:
  580|     31|CalculatedFloat CalculatedFloatFromRawValues(uint64_t mantissa, int exponent) {
  581|     31|  CalculatedFloat result;
  582|     31|  if (mantissa == uint64_t{1} << FloatTraits<FloatType>::kTargetMantissaBits) {
  ------------------
  |  Branch (582:7): [True: 28, False: 3]
  ------------------
  583|     28|    mantissa >>= 1;
  584|     28|    exponent += 1;
  585|     28|  }
  586|     31|  if (exponent > FloatTraits<FloatType>::kMaxExponent) {
  ------------------
  |  Branch (586:7): [True: 0, False: 31]
  ------------------
  587|      0|    result.exponent = kOverflow;
  588|     31|  } else if (mantissa == 0) {
  ------------------
  |  Branch (588:14): [True: 0, False: 31]
  ------------------
  589|      0|    result.exponent = kUnderflow;
  590|     31|  } else {
  591|     31|    result.exponent = exponent;
  592|     31|    result.mantissa = mantissa;
  593|     31|  }
  594|     31|  return result;
  595|     31|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_112EncodeResultIdEEvRKNS1_15CalculatedFloatEbPNS0_17from_chars_resultEPT_:
  407|     31|                  FloatType* absl_nonnull value) {
  408|     31|  if (calculated.exponent == kOverflow) {
  ------------------
  |  Branch (408:7): [True: 0, False: 31]
  ------------------
  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|     31|  } else if (calculated.mantissa == 0 || calculated.exponent == kUnderflow) {
  ------------------
  |  Branch (413:14): [True: 0, False: 31]
  |  Branch (413:42): [True: 0, False: 31]
  ------------------
  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|     31|  *value = FloatTraits<FloatType>::Make(
  419|     31|      static_cast<typename FloatTraits<FloatType>::mantissa_t>(
  420|     31|          calculated.mantissa),
  421|     31|      calculated.exponent, negative);
  422|     31|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_111FloatTraitsIdE4MakeEmib:
  150|     31|  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|     31|    constexpr uint64_t kMantissaMask =
  158|     31|        (uint64_t{1} << (kTargetMantissaBits - 1)) - 1;
  159|     31|    uint64_t dbl = static_cast<uint64_t>(sign) << 63;
  160|     31|    if (mantissa > kMantissaMask) {
  ------------------
  |  Branch (160:9): [True: 31, 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|     31|      dbl += static_cast<uint64_t>(exponent + 1023 + kTargetMantissaBits - 1)
  166|     31|             << 52;
  167|     31|      mantissa &= kMantissaMask;
  168|     31|    } else {
  169|       |      // subnormal value
  170|       |      assert(exponent == kMinNormalExponent);
  171|      0|    }
  172|     31|    dbl += mantissa;
  173|     31|    return absl::bit_cast<double>(dbl);
  174|     31|#endif  // ABSL_BIT_PACK_FLOATS
  175|     31|  }
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_111EiselLemireIdEEbRKNS0_16strings_internal11ParsedFloatEbPT_PNSt3__14errcE:
  687|  2.17k|                 FloatType* absl_nonnull value, std::errc* absl_nonnull ec) {
  688|  2.17k|  uint64_t man = input.mantissa;
  689|  2.17k|  int exp10 = input.exponent;
  690|  2.17k|  if (exp10 < FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10) {
  ------------------
  |  Branch (690:7): [True: 0, False: 2.17k]
  ------------------
  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.17k|  } else if (exp10 >= FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10) {
  ------------------
  |  Branch (694:14): [True: 0, False: 2.17k]
  ------------------
  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.17k|  static_assert(
  706|  2.17k|      FloatTraits<FloatType>::kEiselLemireMinInclusiveExp10 >=
  707|  2.17k|          kPower10TableMinInclusive,
  708|  2.17k|      "(exp10-kPower10TableMinInclusive) in kPower10MantissaHighTable bounds");
  709|  2.17k|  static_assert(
  710|  2.17k|      FloatTraits<FloatType>::kEiselLemireMaxExclusiveExp10 <=
  711|  2.17k|          kPower10TableMaxExclusive,
  712|  2.17k|      "(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.17k|  int clz = countl_zero(man);
  728|  2.17k|  man <<= static_cast<unsigned int>(clz);
  729|       |  // The 217706 etc magic numbers are from the Power10Exponent function.
  730|  2.17k|  uint64_t ret_exp2 =
  731|  2.17k|      static_cast<uint64_t>((217706 * exp10 >> 16) + 64 +
  732|  2.17k|                            FloatTraits<FloatType>::kExponentBias - clz);
  733|       |
  734|       |  // (+) Multiplication.
  735|  2.17k|  uint128 x = static_cast<uint128>(man) *
  736|  2.17k|              static_cast<uint128>(
  737|  2.17k|                  kPower10MantissaHighTable[exp10 - kPower10TableMinInclusive]);
  738|       |
  739|       |  // (+) Wider Approximation.
  740|  2.17k|  static constexpr uint64_t high64_mask =
  741|  2.17k|      FloatTraits<FloatType>::kEiselLemireMask;
  742|  2.17k|  if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (742:7): [True: 39, False: 2.13k]
  ------------------
  743|     39|      (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(x)))) {
  ------------------
  |  Branch (743:7): [True: 39, False: 0]
  ------------------
  744|     39|    uint128 y =
  745|     39|        static_cast<uint128>(man) *
  746|     39|        static_cast<uint128>(
  747|     39|            kPower10MantissaLowTable[exp10 - kPower10TableMinInclusive]);
  748|     39|    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|     39|    if (((Uint128High64(x) & high64_mask) == high64_mask) &&
  ------------------
  |  Branch (758:9): [True: 33, False: 6]
  ------------------
  759|     33|        ((Uint128Low64(x) + 1) == 0) &&
  ------------------
  |  Branch (759:9): [True: 31, False: 2]
  ------------------
  760|     31|        (man > (std::numeric_limits<uint64_t>::max() - Uint128Low64(y)))) {
  ------------------
  |  Branch (760:9): [True: 31, False: 0]
  ------------------
  761|     31|      return false;
  762|     31|    }
  763|     39|  }
  764|       |
  765|       |  // (+) Shifting to 54 Bits (or for single precision, to 25 bits).
  766|  2.14k|  uint64_t msb = Uint128High64(x) >> 63;
  767|  2.14k|  uint64_t ret_man =
  768|  2.14k|      Uint128High64(x) >> (msb + FloatTraits<FloatType>::kEiselLemireShift);
  769|  2.14k|  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.14k|  if ((Uint128Low64(x) == 0) && ((Uint128High64(x) & high64_mask) == 0) &&
  ------------------
  |  Branch (780:7): [True: 0, False: 2.14k]
  |  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.14k|  ret_man += ret_man & 1;  // Line From54a.
  787|  2.14k|  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.14k|  if ((ret_man >> FloatTraits<FloatType>::kTargetMantissaBits) > 0) {
  ------------------
  |  Branch (796:7): [True: 0, False: 2.14k]
  ------------------
  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.14k|  static constexpr uint64_t max_exp2 =
  821|  2.14k|      (1 << FloatTraits<FloatType>::kTargetExponentBits) - 1;
  822|  2.14k|  if ((ret_exp2 - 1) >= (max_exp2 - 1)) {
  ------------------
  |  Branch (822:7): [True: 0, False: 2.14k]
  ------------------
  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.14k|  if (FloatTraits<FloatType>::kTargetBits == 64) {
  ------------------
  |  Branch (839:7): [True: 2.14k, Folded]
  ------------------
  840|  2.14k|    uint64_t ret_bits = (ret_exp2 << 52) | (ret_man & 0x000FFFFFFFFFFFFFu);
  841|  2.14k|    if (negative) {
  ------------------
  |  Branch (841:9): [True: 0, False: 2.14k]
  ------------------
  842|      0|      ret_bits |= 0x8000000000000000u;
  843|      0|    }
  844|  2.14k|    *value = static_cast<FloatType>(absl::bit_cast<double>(ret_bits));
  845|  2.14k|    return true;
  846|  2.14k|  } 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.14k|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_126CalculateFromParsedDecimalIdEENS1_15CalculatedFloatERKNS0_16strings_internal11ParsedFloatE:
  617|     31|    const strings_internal::ParsedFloat& parsed_decimal) {
  618|     31|  CalculatedFloat result;
  619|       |
  620|       |  // Large or small enough decimal exponents will always result in overflow
  621|       |  // or underflow.
  622|     31|  if (Power10Underflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (622:7): [True: 0, False: 31]
  ------------------
  623|      0|    result.exponent = kUnderflow;
  624|      0|    return result;
  625|     31|  } else if (Power10Overflow(parsed_decimal.exponent)) {
  ------------------
  |  Branch (625:14): [True: 0, False: 31]
  ------------------
  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|     31|  uint128 wide_binary_mantissa = parsed_decimal.mantissa;
  633|     31|  wide_binary_mantissa *= Power10Mantissa(parsed_decimal.exponent);
  634|     31|  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|     31|  bool mantissa_exact;
  642|     31|  int mantissa_width;
  643|     31|  if (parsed_decimal.subrange_begin) {
  ------------------
  |  Branch (643:7): [True: 0, False: 31]
  ------------------
  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|     31|  } else if (!Power10Exact(parsed_decimal.exponent)) {
  ------------------
  |  Branch (649:14): [True: 31, False: 0]
  ------------------
  650|       |    // Exact mantissa, truncated power of ten
  651|     31|    mantissa_width = 63;
  652|     31|    mantissa_exact = false;
  653|     31|    binary_exponent +=
  654|     31|        TruncateToBitWidth(mantissa_width, &wide_binary_mantissa);
  655|     31|  } 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|     31|  const int shift =
  663|     31|      NormalizedShiftSize<FloatType>(mantissa_width, binary_exponent);
  664|     31|  bool result_exact;
  665|     31|  binary_exponent += shift;
  666|     31|  uint64_t binary_mantissa = ShiftRightAndRound(wide_binary_mantissa, shift,
  667|     31|                                                mantissa_exact, &result_exact);
  668|     31|  if (!result_exact) {
  ------------------
  |  Branch (668:7): [True: 0, False: 31]
  ------------------
  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|     31|  return CalculatedFloatFromRawValues<FloatType>(binary_mantissa,
  677|     31|                                                 binary_exponent);
  678|     31|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_116Power10UnderflowEi:
  288|     31|bool Power10Underflow(int n) { return n < kPower10TableMinInclusive; }
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115Power10OverflowEi:
  284|     31|bool Power10Overflow(int n) { return n >= kPower10TableMaxExclusive; }
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115Power10MantissaEi:
  270|     31|uint64_t Power10Mantissa(int n) {
  271|     31|  return kPower10MantissaHighTable[n - kPower10TableMinInclusive];
  272|     31|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115Power10ExponentEi:
  274|     31|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|     31|  return (217706 * n >> 16) - 63;
  280|     31|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118TruncateToBitWidthEiPNS0_7uint128E:
  348|     31|int TruncateToBitWidth(int bit_width, uint128* absl_nonnull value) {
  349|     31|  const int current_bit_width = BitWidth(*value);
  350|     31|  const int shift = current_bit_width - bit_width;
  351|     31|  *value >>= shift;
  352|     31|  return shift;
  353|     31|}
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_112Power10ExactEi:
  293|     31|bool Power10Exact(int n) { return n >= 0 && n <= 27; }
  ------------------
  |  Branch (293:35): [True: 0, False: 31]
  |  Branch (293:45): [True: 0, False: 0]
  ------------------
charconv.cc:_ZN4absl12lts_2026052612_GLOBAL__N_18BitWidthENS0_7uint128E:
  317|     31|int BitWidth(uint128 value) {
  318|     31|  if (Uint128High64(value) == 0) {
  ------------------
  |  Branch (318:7): [True: 0, False: 31]
  ------------------
  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|     31|  return 128 - countl_zero(Uint128High64(value));
  324|     31|}

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

_ZN4absl12lts_2026052616strings_internal10ParseFloatILi10EEENS1_11ParsedFloatEPKcS5_NS0_12chars_formatE:
  356|  2.17k|                                         chars_format format_flags) {
  357|  2.17k|  strings_internal::ParsedFloat result;
  358|       |
  359|       |  // Exit early if we're given an empty range.
  360|  2.17k|  if (begin == end) return result;
  ------------------
  |  Branch (360:7): [True: 0, False: 2.17k]
  ------------------
  361|       |
  362|       |  // Handle the infinity and NaN cases.
  363|  2.17k|  if (ParseInfinityOrNan(begin, end, &result)) {
  ------------------
  |  Branch (363:7): [True: 0, False: 2.17k]
  ------------------
  364|      0|    return result;
  365|      0|  }
  366|       |
  367|  2.17k|  const char* const mantissa_begin = begin;
  368|  4.31k|  while (begin < end && *begin == '0') {
  ------------------
  |  Branch (368:10): [True: 4.31k, False: 0]
  |  Branch (368:25): [True: 2.14k, False: 2.17k]
  ------------------
  369|  2.14k|    ++begin;  // skip leading zeros
  370|  2.14k|  }
  371|  2.17k|  uint64_t mantissa = 0;
  372|       |
  373|  2.17k|  int exponent_adjustment = 0;
  374|  2.17k|  bool mantissa_is_inexact = false;
  375|  2.17k|  int pre_decimal_digits = ConsumeDigits<base>(
  376|  2.17k|      begin, end, MantissaDigitsMax<base>(), &mantissa, &mantissa_is_inexact);
  377|  2.17k|  begin += pre_decimal_digits;
  378|  2.17k|  int digits_left;
  379|  2.17k|  if (pre_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (379:7): [True: 0, False: 2.17k]
  ------------------
  380|       |    // refuse to parse pathological inputs
  381|      0|    return result;
  382|  2.17k|  } else if (pre_decimal_digits > MantissaDigitsMax<base>()) {
  ------------------
  |  Branch (382:14): [True: 0, False: 2.17k]
  ------------------
  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.17k|  } else {
  389|  2.17k|    digits_left =
  390|  2.17k|        static_cast<int>(MantissaDigitsMax<base>() - pre_decimal_digits);
  391|  2.17k|  }
  392|  2.17k|  if (begin < end && *begin == '.') {
  ------------------
  |  Branch (392:7): [True: 2.17k, False: 0]
  |  Branch (392:22): [True: 2.17k, False: 0]
  ------------------
  393|  2.17k|    ++begin;
  394|  2.17k|    if (mantissa == 0) {
  ------------------
  |  Branch (394:9): [True: 2.14k, False: 28]
  ------------------
  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.14k|      const char* begin_zeros = begin;
  398|  2.14k|      while (begin < end && *begin == '0') {
  ------------------
  |  Branch (398:14): [True: 2.14k, False: 0]
  |  Branch (398:29): [True: 0, False: 2.14k]
  ------------------
  399|      0|        ++begin;
  400|      0|      }
  401|  2.14k|      int zeros_skipped = static_cast<int>(begin - begin_zeros);
  402|  2.14k|      if (zeros_skipped >= DigitLimit<base>()) {
  ------------------
  |  Branch (402:11): [True: 0, False: 2.14k]
  ------------------
  403|       |        // refuse to parse pathological inputs
  404|      0|        return result;
  405|      0|      }
  406|  2.14k|      exponent_adjustment -= static_cast<int>(zeros_skipped);
  407|  2.14k|    }
  408|  2.17k|    int post_decimal_digits = ConsumeDigits<base>(
  409|  2.17k|        begin, end, digits_left, &mantissa, &mantissa_is_inexact);
  410|  2.17k|    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.17k|    if (post_decimal_digits >= DigitLimit<base>()) {
  ------------------
  |  Branch (416:9): [True: 0, False: 2.17k]
  ------------------
  417|       |      // refuse to parse pathological inputs
  418|      0|      return result;
  419|  2.17k|    } else if (post_decimal_digits > digits_left) {
  ------------------
  |  Branch (419:16): [True: 0, False: 2.17k]
  ------------------
  420|      0|      exponent_adjustment -= digits_left;
  421|  2.17k|    } else {
  422|  2.17k|      exponent_adjustment -= post_decimal_digits;
  423|  2.17k|    }
  424|  2.17k|  }
  425|       |  // If we've found no mantissa whatsoever, this isn't a number.
  426|  2.17k|  if (mantissa_begin == begin) {
  ------------------
  |  Branch (426:7): [True: 0, False: 2.17k]
  ------------------
  427|      0|    return result;
  428|      0|  }
  429|       |  // A bare "." doesn't count as a mantissa either.
  430|  2.17k|  if (begin - mantissa_begin == 1 && *mantissa_begin == '.') {
  ------------------
  |  Branch (430:7): [True: 0, False: 2.17k]
  |  Branch (430:38): [True: 0, False: 0]
  ------------------
  431|      0|    return result;
  432|      0|  }
  433|       |
  434|  2.17k|  if (mantissa_is_inexact) {
  ------------------
  |  Branch (434:7): [True: 0, False: 2.17k]
  ------------------
  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.17k|  result.mantissa = mantissa;
  448|       |
  449|  2.17k|  const char* const exponent_begin = begin;
  450|  2.17k|  result.literal_exponent = 0;
  451|  2.17k|  bool found_exponent = false;
  452|  2.17k|  if (AllowExponent(format_flags) && begin < end &&
  ------------------
  |  Branch (452:7): [True: 2.17k, False: 0]
  |  Branch (452:38): [True: 0, False: 2.17k]
  ------------------
  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.17k|  if (!found_exponent && RequireExponent(format_flags)) {
  ------------------
  |  Branch (479:7): [True: 2.17k, False: 0]
  |  Branch (479:26): [True: 0, False: 2.17k]
  ------------------
  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.17k|  result.type = strings_internal::FloatType::kNumber;
  487|  2.17k|  if (result.mantissa > 0) {
  ------------------
  |  Branch (487:7): [True: 2.17k, False: 0]
  ------------------
  488|  2.17k|    result.exponent = result.literal_exponent +
  489|  2.17k|                      (DigitMagnitude<base>() * exponent_adjustment);
  490|  2.17k|  } else {
  491|      0|    result.exponent = 0;
  492|      0|  }
  493|  2.17k|  result.end = begin;
  494|  2.17k|  return result;
  495|  2.17k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113AllowExponentENS0_12chars_formatE:
  122|  2.17k|bool AllowExponent(chars_format flags) {
  123|  2.17k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  124|  2.17k|  bool scientific =
  125|  2.17k|      (flags & chars_format::scientific) == chars_format::scientific;
  126|  2.17k|  return scientific || !fixed;
  ------------------
  |  Branch (126:10): [True: 2.17k, False: 0]
  |  Branch (126:24): [True: 0, False: 0]
  ------------------
  127|  2.17k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115RequireExponentENS0_12chars_formatE:
  130|  2.17k|bool RequireExponent(chars_format flags) {
  131|  2.17k|  bool fixed = (flags & chars_format::fixed) == chars_format::fixed;
  132|  2.17k|  bool scientific =
  133|  2.17k|      (flags & chars_format::scientific) == chars_format::scientific;
  134|  2.17k|  return scientific && !fixed;
  ------------------
  |  Branch (134:10): [True: 2.17k, False: 0]
  |  Branch (134:24): [True: 0, False: 2.17k]
  ------------------
  135|  2.17k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_117MantissaDigitsMaxILi10EEEiv:
  211|  6.51k|constexpr int MantissaDigitsMax<10>() {
  212|  6.51k|  return kDecimalMantissaDigitsMax;
  213|  6.51k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_110DigitLimitILi10EEEiv:
  220|  6.48k|constexpr int DigitLimit<10>() {
  221|  6.48k|  return kDecimalDigitLimit;
  222|  6.48k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114DigitMagnitudeILi10EEEiv:
  229|  2.17k|constexpr int DigitMagnitude<10>() {
  230|  2.17k|  return 1;
  231|  2.17k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118ParseInfinityOrNanEPKcS3_PNS0_16strings_internal11ParsedFloatE:
  298|  2.17k|                        strings_internal::ParsedFloat* out) {
  299|  2.17k|  if (end - begin < 3) {
  ------------------
  |  Branch (299:7): [True: 0, False: 2.17k]
  ------------------
  300|      0|    return false;
  301|      0|  }
  302|  2.17k|  switch (*begin) {
  303|      0|    case 'i':
  ------------------
  |  Branch (303:5): [True: 0, False: 2.17k]
  ------------------
  304|      0|    case 'I': {
  ------------------
  |  Branch (304:5): [True: 0, False: 2.17k]
  ------------------
  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.17k]
  ------------------
  320|      0|    case 'N': {
  ------------------
  |  Branch (320:5): [True: 0, False: 2.17k]
  ------------------
  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.17k|    default:
  ------------------
  |  Branch (346:5): [True: 2.17k, False: 0]
  ------------------
  347|  2.17k|      return false;
  348|  2.17k|  }
  349|  2.17k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113ConsumeDigitsILi10EmEEiPKcS4_iPT0_Pb:
  250|  4.34k|                  bool* dropped_nonzero_digit) {
  251|  4.34k|  if (base == 10) {
  ------------------
  |  Branch (251:7): [True: 4.34k, Folded]
  ------------------
  252|  4.34k|    assert(max_digits <= std::numeric_limits<T>::digits10);
  253|  4.34k|  } else if (base == 16) {
  ------------------
  |  Branch (253:14): [Folded, False: 0]
  ------------------
  254|      0|    assert(max_digits * 4 <= std::numeric_limits<T>::digits);
  255|      0|  }
  256|  4.34k|  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|  4.34k|  while (!*out && end != begin && *begin == '0') ++begin;
  ------------------
  |  Branch (261:10): [True: 4.31k, False: 28]
  |  Branch (261:19): [True: 4.31k, False: 0]
  |  Branch (261:35): [True: 0, False: 4.31k]
  ------------------
  262|       |
  263|  4.34k|  T accumulator = *out;
  264|  4.34k|  const char* significant_digits_end =
  265|  4.34k|      (end - begin > max_digits) ? begin + max_digits : end;
  ------------------
  |  Branch (265:7): [True: 0, False: 4.34k]
  ------------------
  266|  17.4k|  while (begin < significant_digits_end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (266:10): [True: 15.2k, False: 2.17k]
  |  Branch (266:44): [True: 13.0k, False: 2.17k]
  ------------------
  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|  13.0k|    auto digit = static_cast<T>(ToDigit<base>(*begin));
  270|  13.0k|    assert(accumulator * base >= accumulator);
  271|  13.0k|    accumulator *= base;
  272|  13.0k|    assert(accumulator + digit >= accumulator);
  273|  13.0k|    accumulator += digit;
  274|  13.0k|    ++begin;
  275|  13.0k|  }
  276|  4.34k|  bool dropped_nonzero = false;
  277|  4.34k|  while (begin < end && IsDigit<base>(*begin)) {
  ------------------
  |  Branch (277:10): [True: 2.17k, False: 2.17k]
  |  Branch (277:25): [True: 0, False: 2.17k]
  ------------------
  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|  4.34k|  if (dropped_nonzero && dropped_nonzero_digit != nullptr) {
  ------------------
  |  Branch (281:7): [True: 0, False: 4.34k]
  |  Branch (281:26): [True: 0, False: 0]
  ------------------
  282|      0|    *dropped_nonzero_digit = true;
  283|      0|  }
  284|  4.34k|  *out = accumulator;
  285|  4.34k|  return static_cast<int>(begin - original_begin);
  286|  4.34k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_17IsDigitILi10EEEbc:
  183|  17.4k|bool IsDigit<10>(char ch) {
  184|  17.4k|  return ch >= '0' && ch <= '9';
  ------------------
  |  Branch (184:10): [True: 13.0k, False: 4.34k]
  |  Branch (184:23): [True: 13.0k, False: 0]
  ------------------
  185|  17.4k|}
charconv_parse.cc:_ZN4absl12lts_2026052612_GLOBAL__N_17ToDigitILi10EEEjc:
  192|  13.0k|unsigned ToDigit<10>(char ch) {
  193|  13.0k|  return static_cast<unsigned>(ch - '0');
  194|  13.0k|}

_ZN4absl12lts_2026052616strings_internal10memcasecmpEPKcS3_m:
   25|  11.2k|int memcasecmp(const char* s1, const char* s2, size_t len) {
   26|  11.2k|  const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1);
   27|  11.2k|  const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2);
   28|       |
   29|  63.9k|  for (size_t i = 0; i < len; i++) {
  ------------------
  |  Branch (29:22): [True: 52.6k, False: 11.2k]
  ------------------
   30|  52.6k|    unsigned char c1 = us1[i];
   31|  52.6k|    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|  52.6k|    if (c1 != c2) {
  ------------------
  |  Branch (36:9): [True: 0, False: 52.6k]
  ------------------
   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|  52.6k|  }
   43|  11.2k|  return 0;
   44|  11.2k|}

_ZN4absl12lts_2026052616strings_internal13OStringStream9Streambuf6xsputnEPKcl:
   35|  29.9k|                                                 std::streamsize n) {
   36|       |  assert(str_);
   37|  29.9k|  str_->append(s, static_cast<size_t>(n));
   38|  29.9k|  return n;
   39|  29.9k|}

_ZN4absl12lts_2026052616strings_internal13OStringStream9StreambufC2EPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
   93|  4.23k|    explicit Streambuf(std::string* str) : str_(str) {}
_ZN4absl12lts_2026052616strings_internal13OStringStreamC1EPNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   73|  4.23k|      : std::ostream(&buf_), buf_(str) {}

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

_ZN4absl12lts_2026052619str_format_internal13FormatArgImpl8DispatchIcEEbNS2_4DataENS1_24FormatConversionSpecImplEPv:
  588|   612k|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  589|       |    // A `none` conv indicates that we want the `int` conversion.
  590|   612k|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  190|   612k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 612k]
  |  |  |  Branch (190:49): [Folded, False: 612k]
  |  |  |  Branch (190:58): [True: 0, False: 612k]
  |  |  ------------------
  ------------------
  591|   612k|                           FormatConversionCharInternal::kNone)) {
  592|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  593|      0|                      std::is_enum<T>());
  594|      0|    }
  595|   612k|    if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|   612k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 612k]
  |  |  |  Branch (190:49): [Folded, False: 612k]
  |  |  |  Branch (190:58): [True: 0, False: 612k]
  |  |  ------------------
  ------------------
  596|   612k|            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
  597|      0|      return false;
  598|      0|    }
  599|   612k|    return str_format_internal::FormatConvertImpl(
  600|   612k|               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
  601|   612k|        .value;
  602|   612k|  }
_ZN4absl12lts_2026052619str_format_internal14ArgumentToConvIcEENS0_23FormatConversionCharSetEv:
  420|   612k|constexpr FormatConversionCharSet ArgumentToConv() {
  421|   612k|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  422|   612k|      std::declval<const Arg&>(),
  423|   612k|      std::declval<const FormatConversionSpecImpl&>(),
  424|   612k|      std::declval<FormatSinkImpl*>()));
  425|   612k|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  426|   612k|}
_ZN4absl12lts_2026052619str_format_internal14ExtractCharSetILNS0_23FormatConversionCharSetE131067EEES3_NS1_16ArgConvertResultIXT_EEE:
  206|   612k|constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
  207|   612k|  return C;
  208|   612k|}
_ZN4absl12lts_2026052619str_format_internal13FormatArgImpl7ManagerIcLNS2_13StoragePolicyE2EE5ValueENS2_4DataE:
  539|   612k|    static T Value(Data arg) {
  540|   612k|      T value;
  541|   612k|      memcpy(&value, arg.buf, sizeof(T));
  542|   612k|      return value;
  543|   612k|    }
_ZN4absl12lts_2026052619str_format_internal19FormatArgImplFriend7ConvertINS1_13FormatArgImplEEEbT_NS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  409|  2.45M|                      FormatSinkImpl* out) {
  410|  2.45M|    return arg.dispatcher_(arg.data_, conv, out);
  411|  2.45M|  }
_ZN4absl12lts_2026052619str_format_internal13FormatArgImplC2IcEERKT_:
  494|   612k|  explicit FormatArgImpl(const T& value) {
  495|   612k|    using D = typename DecayType<T>::type;
  496|   612k|    static_assert(
  497|   612k|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  498|   612k|        "Decayed types must be stored by value");
  499|   612k|    Init(static_cast<D>(value));
  500|   612k|  }
_ZN4absl12lts_2026052619str_format_internal13FormatArgImpl4InitIcEEvRKT_:
  547|   612k|  void Init(const T& value) {
  548|   612k|    data_ = Manager<T>::SetValue(value);
  549|   612k|    dispatcher_ = &Dispatch<T>;
  550|   612k|  }
_ZN4absl12lts_2026052619str_format_internal13FormatArgImpl7ManagerIcLNS2_13StoragePolicyE2EE8SetValueERKc:
  533|   612k|    static Data SetValue(const T& value) {
  534|   612k|      Data data;
  535|   612k|      memcpy(data.buf, &value, sizeof(value));
  536|   612k|      return data;
  537|   612k|    }

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

_ZNK4absl12lts_2026052619str_format_internal15BoundConversion3argEv:
   43|  2.45M|  const FormatArgImpl* arg() const { return arg_; }
_ZN4absl12lts_2026052619str_format_internal15BoundConversion7set_argEPKNS1_13FormatArgImplE:
   44|  2.45M|  void set_arg(const FormatArgImpl* a) { arg_ = a; }
_ZNK4absl12lts_2026052619str_format_internal21UntypedFormatSpecImpl21has_parsed_conversionEv:
   61|   617k|  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
_ZNK4absl12lts_2026052619str_format_internal21UntypedFormatSpecImpl3strEv:
   63|   617k|  string_view str() const {
   64|       |    assert(!has_parsed_conversion());
   65|   617k|    return string_view(static_cast<const char*>(data_), size_);
   66|   617k|  }
_ZN4absl12lts_2026052619str_format_internal21UntypedFormatSpecImpl7ExtractINS1_18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE131067ELS5_655355ELS5_655355ELS5_655355EEEEEERKS2_RKT_:
   73|   612k|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|   612k|    return s.spec_;
   75|   612k|  }
_ZN4absl12lts_2026052619str_format_internal18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE131067ELS3_655355ELS3_655355ELS3_655355EEEC2EUa9enable_ifIXclL_ZNS1_15ValidFormatImplIJLS3_131067ELS3_655355ELS3_655355ELS3_655355EEEEbNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEfL0p_EEEPKc:
  159|   612k|      : Base(s) {}

_ZN4absl12lts_2026052619str_format_internal17UnboundConversionC2Ev:
   36|  2.45M|  UnboundConversion() {}  // NOLINT
_ZN4absl12lts_2026052619str_format_internal17UnboundConversion10InputValue9set_valueEi:
   45|  1.83M|    constexpr void set_value(int value) {
   46|       |      assert(value >= 0);
   47|  1.83M|      value_ = value;
   48|  1.83M|    }
_ZNK4absl12lts_2026052619str_format_internal17UnboundConversion10InputValue5valueEv:
   49|  3.67M|    constexpr int value() const { return value_; }
_ZNK4absl12lts_2026052619str_format_internal17UnboundConversion10InputValue11is_from_argEv:
   60|  3.67M|    constexpr bool is_from_arg() const { return value_ < -1; }
_ZNK4absl12lts_2026052619str_format_internal7ConvTag7is_convEv:
   94|  4.29M|  constexpr bool is_conv() const { return (tag_ & 0x80) == 0; }
_ZNK4absl12lts_2026052619str_format_internal7ConvTag8is_flagsEv:
   96|  1.22M|  constexpr bool is_flags() const { return (tag_ & 0xE0) == 0xC0; }
_ZNK4absl12lts_2026052619str_format_internal7ConvTag7as_convEv:
   98|  2.45M|  constexpr FormatConversionChar as_conv() const {
   99|  2.45M|    assert(is_conv());
  100|  2.45M|    assert(!is_length());
  101|       |    assert(!is_flags());
  102|  2.45M|    return static_cast<FormatConversionChar>(tag_);
  103|  2.45M|  }
_ZNK4absl12lts_2026052619str_format_internal7ConvTag8as_flagsEv:
  110|  1.22M|  constexpr Flags as_flags() const {
  111|  1.22M|    assert(!is_conv());
  112|  1.22M|    assert(!is_length());
  113|       |    assert(is_flags());
  114|  1.22M|    return static_cast<Flags>(tag_ & 0x1F);
  115|  1.22M|  }
_ZN4absl12lts_2026052619str_format_internal17ConsumeConversionILb0EEEPKcS4_S4_PNS1_17UnboundConversionEPi:
  216|  1.83M|                                        int* next_arg) {
  217|  1.83M|  const char* const original_pos = pos;
  218|  1.83M|  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.83M|#define ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR()          \
  222|  1.83M|  do {                                                  \
  223|  1.83M|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  224|  1.83M|    c = *pos++;                                         \
  225|  1.83M|  } while (0)
  226|       |
  227|  1.83M|  if (is_positional) {
  ------------------
  |  Branch (227:7): [Folded, False: 1.83M]
  ------------------
  228|      0|    ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|      0|  do {                                                  \
  |  |  223|      0|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  |  Branch (190: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;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  233|      0|  }
  234|       |
  235|  1.83M|  ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|  1.83M|  do {                                                  \
  |  |  223|  1.83M|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|  1.83M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 1.83M]
  |  |  |  |  |  Branch (190:49): [Folded, False: 1.83M]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 1.83M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|  1.83M|    c = *pos++;                                         \
  |  |  225|  1.83M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 1.83M]
  |  |  ------------------
  ------------------
  236|       |
  237|       |  // We should start with the basic flag on.
  238|  1.83M|  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.83M|  if (c < 'A') {
  ------------------
  |  Branch (243:7): [True: 1.83M, False: 0]
  ------------------
  244|  3.06M|    while (c <= '0') {
  ------------------
  |  Branch (244:12): [True: 1.22M, False: 1.83M]
  ------------------
  245|  1.22M|      auto tag = GetTagForChar(c);
  246|  1.22M|      if (tag.is_flags()) {
  ------------------
  |  Branch (246:11): [True: 1.22M, False: 0]
  ------------------
  247|  1.22M|        conv->flags = conv->flags | tag.as_flags();
  248|  1.22M|        ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR();
  ------------------
  |  |  222|  1.22M|  do {                                                  \
  |  |  223|  1.22M|    if (ABSL_PREDICT_FALSE(pos == end)) return nullptr; \
  |  |  ------------------
  |  |  |  |  190|  1.22M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 1.22M]
  |  |  |  |  |  Branch (190:49): [Folded, False: 1.22M]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 1.22M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  224|  1.22M|    c = *pos++;                                         \
  |  |  225|  1.22M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (225:12): [Folded, False: 1.22M]
  |  |  ------------------
  ------------------
  249|  1.22M|      } else {
  250|      0|        break;
  251|      0|      }
  252|  1.22M|    }
  253|       |
  254|  1.83M|    if (c <= '9') {
  ------------------
  |  Branch (254:9): [True: 1.83M, False: 0]
  ------------------
  255|  1.83M|      if (c >= '0') {
  ------------------
  |  Branch (255:11): [True: 1.83M, False: 0]
  ------------------
  256|  1.83M|        int maybe_width = ParseDigits(c, pos, end);
  257|  1.83M|        if (!is_positional && c == '$') {
  ------------------
  |  Branch (257:13): [True: 1.83M, Folded]
  |  Branch (257:31): [True: 0, False: 1.83M]
  ------------------
  258|      0|          if (ABSL_PREDICT_FALSE(*next_arg != 0)) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190: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.83M|        conv->flags = conv->flags | Flags::kNonBasic;
  264|  1.83M|        conv->width.set_value(maybe_width);
  265|  1.83M|      } 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; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  |  Branch (190: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;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190: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; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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.83M|    }
  278|       |
  279|  1.83M|    if (c == '.') {
  ------------------
  |  Branch (279:9): [True: 0, False: 1.83M]
  ------------------
  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; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  |  Branch (190: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; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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.83M|  }
  299|       |
  300|  1.83M|  auto tag = GetTagForChar(c);
  301|       |
  302|  1.83M|  if (ABSL_PREDICT_FALSE(c == 'v' && conv->flags != Flags::kBasic)) {
  ------------------
  |  |  190|  1.83M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.83M]
  |  |  |  Branch (190:49): [Folded, False: 1.83M]
  |  |  |  Branch (190:59): [True: 0, False: 1.83M]
  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  303|      0|    return nullptr;
  304|      0|  }
  305|       |
  306|  1.83M|  if (ABSL_PREDICT_FALSE(!tag.is_conv())) {
  ------------------
  |  |  190|  1.83M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.83M]
  |  |  |  Branch (190:49): [Folded, False: 1.83M]
  |  |  |  Branch (190:58): [True: 0, False: 1.83M]
  |  |  ------------------
  ------------------
  307|      0|    if (ABSL_PREDICT_FALSE(!tag.is_length())) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190: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; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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; \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  324|      0|    if (ABSL_PREDICT_FALSE(!tag.is_conv())) return nullptr;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190: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.83M|#undef ABSL_FORMAT_PARSER_INTERNAL_GET_CHAR
  332|       |
  333|  1.83M|  assert(CheckFastPathSetting(*conv));
  334|  1.83M|  (void)(&CheckFastPathSetting);
  335|       |
  336|  1.83M|  conv->conv = tag.as_conv();
  337|  1.83M|  if (!is_positional) conv->arg_position = ++*next_arg;
  ------------------
  |  Branch (337:7): [True: 1.83M, Folded]
  ------------------
  338|  1.83M|  return pos;
  339|  1.83M|}
_ZN4absl12lts_2026052619str_format_internal13GetTagForCharEc:
  169|  5.52M|constexpr ConvTag GetTagForChar(char c) {
  170|  5.52M|  return ConvTagHolder::value[static_cast<unsigned char>(c)];
  171|  5.52M|}
_ZN4absl12lts_2026052619str_format_internal11ParseDigitsERcRPKcS4_:
  196|  1.83M|constexpr int ParseDigits(char& c, const char*& pos, const char* const end) {
  197|  1.83M|  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.83M|  int num_digits = std::numeric_limits<int>::digits10;
  202|  1.83M|  for (;;) {
  203|  1.83M|    if (ABSL_PREDICT_FALSE(pos == end)) break;
  ------------------
  |  |  190|  1.83M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.83M]
  |  |  |  Branch (190:49): [Folded, False: 1.83M]
  |  |  |  Branch (190:58): [True: 0, False: 1.83M]
  |  |  ------------------
  ------------------
  204|  1.83M|    c = *pos++;
  205|  1.83M|    if ('0' > c || c > '9') break;
  ------------------
  |  Branch (205:9): [True: 0, False: 1.83M]
  |  Branch (205:20): [True: 1.83M, False: 0]
  ------------------
  206|      0|    --num_digits;
  207|      0|    if (ABSL_PREDICT_FALSE(!num_digits)) break;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  208|      0|    digits = 10 * digits + c - '0';
  209|      0|  }
  210|  1.83M|  return digits;
  211|  1.83M|}
_ZN4absl12lts_2026052619str_format_internal24ConsumeUnboundConversionEPKcS3_PNS1_17UnboundConversionEPi:
  348|  1.83M|                                               int* next_arg) {
  349|  1.83M|  if (*next_arg < 0) return ConsumeConversion<true>(p, end, conv, next_arg);
  ------------------
  |  Branch (349:7): [True: 0, False: 1.83M]
  ------------------
  350|  1.83M|  return ConsumeConversion<false>(p, end, conv, next_arg);
  351|  1.83M|}

_ZN4absl12lts_2026052619str_format_internal17FormatRawSinkImpl5WriteENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   48|   617k|  void Write(string_view s) { write_(sink_, s); }
_ZN4absl12lts_2026052619str_format_internal14FormatSinkImplC2ENS1_17FormatRawSinkImplE:
   68|   617k|  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
_ZN4absl12lts_2026052619str_format_internal14FormatSinkImplD2Ev:
   70|   617k|  ~FormatSinkImpl() { Flush(); }
_ZN4absl12lts_2026052619str_format_internal14FormatSinkImpl5FlushEv:
   72|   617k|  void Flush() {
   73|   617k|    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
   74|   617k|    pos_ = buf_;
   75|   617k|  }
_ZN4absl12lts_2026052619str_format_internal14FormatSinkImpl6AppendEmc:
   77|  6.74M|  void Append(size_t n, char c) {
   78|  6.74M|    if (n == 0) return;
  ------------------
  |  Branch (78:9): [True: 5.45M, False: 1.28M]
  ------------------
   79|  1.28M|    size_ += n;
   80|  1.28M|    auto raw_append = [&](size_t count) {
   81|  1.28M|      memset(pos_, c, count);
   82|  1.28M|      pos_ += count;
   83|  1.28M|    };
   84|  1.28M|    while (n > Avail()) {
  ------------------
  |  Branch (84:12): [True: 0, False: 1.28M]
  ------------------
   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.28M|    raw_append(n);
   92|  1.28M|  }
_ZN4absl12lts_2026052619str_format_internal14FormatSinkImpl6AppendENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   94|  8.60M|  void Append(string_view v) {
   95|  8.60M|    size_t n = v.size();
   96|  8.60M|    if (n == 0) return;
  ------------------
  |  Branch (96:9): [True: 4.28M, False: 4.31M]
  ------------------
   97|  4.31M|    size_ += n;
   98|  4.31M|    if (n >= Avail()) {
  ------------------
  |  Branch (98:9): [True: 0, False: 4.31M]
  ------------------
   99|      0|      Flush();
  100|      0|      raw_.Write(v);
  101|      0|      return;
  102|      0|    }
  103|  4.31M|    memcpy(pos_, v.data(), n);
  104|  4.31M|    pos_ += n;
  105|  4.31M|  }
_ZNK4absl12lts_2026052619str_format_internal14FormatSinkImpl5AvailEv:
  123|  5.59M|  size_t Avail() const {
  124|  5.59M|    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
  125|  5.59M|  }
_ZNK4absl12lts_2026052619str_format_internal24FormatConversionSpecImpl8is_basicEv:
  277|  1.84M|  bool is_basic() const { return flags_ == Flags::kBasic; }
_ZNK4absl12lts_2026052619str_format_internal24FormatConversionSpecImpl13has_left_flagEv:
  278|  4.90M|  bool has_left_flag() const { return FlagsContains(flags_, Flags::kLeft); }
_ZNK4absl12lts_2026052619str_format_internal24FormatConversionSpecImpl17has_show_pos_flagEv:
  279|  1.83M|  bool has_show_pos_flag() const {
  280|  1.83M|    return FlagsContains(flags_, Flags::kShowPos);
  281|  1.83M|  }
_ZNK4absl12lts_2026052619str_format_internal24FormatConversionSpecImpl17has_sign_col_flagEv:
  282|  1.83M|  bool has_sign_col_flag() const {
  283|  1.83M|    return FlagsContains(flags_, Flags::kSignCol);
  284|  1.83M|  }
_ZNK4absl12lts_2026052619str_format_internal24FormatConversionSpecImpl12has_alt_flagEv:
  285|  3.67M|  bool has_alt_flag() const { return FlagsContains(flags_, Flags::kAlt); }
_ZNK4absl12lts_2026052619str_format_internal24FormatConversionSpecImpl13has_zero_flagEv:
  286|  1.83M|  bool has_zero_flag() const { return FlagsContains(flags_, Flags::kZero); }
_ZNK4absl12lts_2026052619str_format_internal24FormatConversionSpecImpl10length_modEv:
  288|   612k|  LengthMod length_mod() const { return length_mod_; }
_ZNK4absl12lts_2026052619str_format_internal24FormatConversionSpecImpl5widthEv:
  301|  4.28M|  int width() const { return width_; }
_ZNK4absl12lts_2026052619str_format_internal24FormatConversionSpecImpl9precisionEv:
  304|  1.83M|  int precision() const { return precision_; }
_ZN4absl12lts_2026052619str_format_internal30FormatConversionSpecImplFriend8SetFlagsENS1_5FlagsEPNS1_24FormatConversionSpecImplE:
  321|  2.45M|  static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
  322|  2.45M|    conv->flags_ = f;
  323|  2.45M|  }
_ZN4absl12lts_2026052619str_format_internal30FormatConversionSpecImplFriend12SetLengthModENS0_9LengthModEPNS1_24FormatConversionSpecImplE:
  324|  1.83M|  static void SetLengthMod(LengthMod l, FormatConversionSpecImpl* conv) {
  325|  1.83M|    conv->length_mod_ = l;
  326|  1.83M|  }
_ZN4absl12lts_2026052619str_format_internal30FormatConversionSpecImplFriend17SetConversionCharENS0_20FormatConversionCharEPNS1_24FormatConversionSpecImplE:
  328|  2.45M|                                FormatConversionSpecImpl* conv) {
  329|  2.45M|    conv->conv_ = c;
  330|  2.45M|  }
_ZN4absl12lts_2026052619str_format_internal30FormatConversionSpecImplFriend8SetWidthEiPNS1_24FormatConversionSpecImplE:
  331|  2.45M|  static void SetWidth(int w, FormatConversionSpecImpl* conv) {
  332|  2.45M|    conv->width_ = w;
  333|  2.45M|  }
_ZN4absl12lts_2026052619str_format_internal30FormatConversionSpecImplFriend12SetPrecisionEiPNS1_24FormatConversionSpecImplE:
  334|  2.45M|  static void SetPrecision(int p, FormatConversionSpecImpl* conv) {
  335|  2.45M|    conv->precision_ = p;
  336|  2.45M|  }
_ZN4absl12lts_2026052619str_format_internalorENS1_5FlagsES2_:
  146|  3.06M|constexpr Flags operator|(Flags a, Flags b) {
  147|  3.06M|  return static_cast<Flags>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
  148|  3.06M|}
_ZN4absl12lts_2026052619str_format_internal13FlagsContainsENS1_5FlagsES2_:
  150|  14.0M|constexpr bool FlagsContains(Flags haystack, Flags needle) {
  151|  14.0M|  return (static_cast<uint8_t>(haystack) & static_cast<uint8_t>(needle)) ==
  152|  14.0M|         static_cast<uint8_t>(needle);
  153|  14.0M|}
_ZN4absl12lts_2026052619str_format_internal6ExcessEmm:
  447|  9.80M|inline size_t Excess(size_t used, size_t capacity) {
  448|  9.80M|  return used < capacity ? capacity - used : 0;
  ------------------
  |  Branch (448:10): [True: 2.69M, False: 7.11M]
  ------------------
  449|  9.80M|}
_ZZN4absl12lts_2026052619str_format_internal14FormatSinkImpl6AppendEmcENKUlmE_clEm:
   80|  1.28M|    auto raw_append = [&](size_t count) {
   81|  1.28M|      memset(pos_, c, count);
   82|  1.28M|      pos_ += count;
   83|  1.28M|    };
_ZN4absl12lts_2026052619str_format_internal17FormatRawSinkImplC2INSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETnPDTclsr19str_format_internalE11InvokeFlushclsr3stdE7declvalIPT_EEcvNS4_17basic_string_viewIcS7_EE_EEELPv0EEESC_:
   46|  4.36k|      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
_ZN4absl12lts_2026052619str_format_internal17FormatRawSinkImpl5FlushINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvPvNS4_17basic_string_viewIcS7_EE:
   57|  4.36k|  static void Flush(void* r, string_view s) {
   58|  4.36k|    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
   59|  4.36k|  }
_ZN4absl12lts_2026052619str_format_internal17FormatRawSinkImplC2INS1_13BufferRawSinkETnPDTclsr19str_format_internalE11InvokeFlushclsr3stdE7declvalIPT_EEcvNSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE_EEELPv0EEES6_:
   46|   612k|      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
_ZN4absl12lts_2026052619str_format_internal17FormatRawSinkImpl5FlushINS1_13BufferRawSinkEEEvPvNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEE:
   57|   612k|  static void Flush(void* r, string_view s) {
   58|   612k|    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
   59|   612k|  }

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

_ZN4absl12lts_2026052619str_format_internal13BufferRawSinkC2EPcm:
   41|   612k|  BufferRawSink(char* buffer, size_t size) : buffer_(buffer), size_(size) {}
_ZNK4absl12lts_2026052619str_format_internal13BufferRawSink13total_writtenEv:
   43|   612k|  size_t total_written() const { return total_written_; }
_ZN4absl12lts_2026052619str_format_internal15AbslFormatFlushEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EE:
   71|  4.36k|inline void AbslFormatFlush(std::string* out, string_view s) {
   72|  4.36k|  out->append(s.data(), s.size());
   73|  4.36k|}
_ZN4absl12lts_2026052619str_format_internal15AbslFormatFlushEPNS1_13BufferRawSinkENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEE:
   82|   612k|inline void AbslFormatFlush(BufferRawSink* sink, string_view v) {
   83|   612k|  sink->Write(v);
   84|   612k|}
_ZN4absl12lts_2026052619str_format_internal11InvokeFlushINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEDTcl15AbslFormatFlushfp_fp0_EEPT_NS3_17basic_string_viewIcS6_EE:
   89|  4.36k|auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
   90|  4.36k|  AbslFormatFlush(out, s);
   91|  4.36k|}
_ZN4absl12lts_2026052619str_format_internal11InvokeFlushINS1_13BufferRawSinkEEEDTcl15AbslFormatFlushfp_fp0_EEPT_NSt3__117basic_string_viewIcNS7_11char_traitsIcEEEE:
   89|   612k|auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
   90|   612k|  AbslFormatFlush(out, s);
   91|   612k|}

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

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

_ZN4absl12lts_2026052616strings_internal15StringifyStreamC2ERNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEE:
   64|  4.23k|  explicit StringifyStream(std::ostream& os) : sink_{os} {}

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

_ZN4absl12lts_2026052610SimpleAtodENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPd:
   86|  2.17k|bool SimpleAtod(absl::string_view str, double* absl_nonnull out) {
   87|  2.17k|  *out = 0.0;
   88|  2.17k|  str = StripAsciiWhitespace(str);
   89|  2.17k|  if (str.empty()) {
  ------------------
  |  Branch (89:7): [True: 0, False: 2.17k]
  ------------------
   90|       |    // absl::from_chars doesn't accept empty strings.
   91|      0|    return false;
   92|      0|  }
   93|       |  // std::from_chars doesn't accept an initial +, but SimpleAtod does, so if one
   94|       |  // is present, skip it, while avoiding accepting "+-0" as valid.
   95|  2.17k|  if (str[0] == '+') {
  ------------------
  |  Branch (95:7): [True: 0, False: 2.17k]
  ------------------
   96|      0|    str.remove_prefix(1);
   97|      0|    if (str.empty() || str[0] == '-') {
  ------------------
  |  Branch (97:9): [True: 0, False: 0]
  |  Branch (97:24): [True: 0, False: 0]
  ------------------
   98|      0|      return false;
   99|      0|    }
  100|      0|  }
  101|  2.17k|  auto result = absl::from_chars(str.data(), str.data() + str.size(), *out);
  102|  2.17k|  if (result.ec == std::errc::invalid_argument) {
  ------------------
  |  Branch (102:7): [True: 0, False: 2.17k]
  ------------------
  103|      0|    return false;
  104|      0|  }
  105|  2.17k|  if (result.ptr != str.data() + str.size()) {
  ------------------
  |  Branch (105:7): [True: 0, False: 2.17k]
  ------------------
  106|       |    // not all non-whitespace characters consumed
  107|      0|    return false;
  108|      0|  }
  109|       |  // from_chars() with DR 3081's current wording will return max() on
  110|       |  // overflow.  SimpleAtod returns infinity instead.
  111|  2.17k|  if (result.ec == std::errc::result_out_of_range) {
  ------------------
  |  Branch (111:7): [True: 0, False: 2.17k]
  ------------------
  112|      0|    if (*out > 1.0) {
  ------------------
  |  Branch (112:9): [True: 0, False: 0]
  ------------------
  113|      0|      *out = std::numeric_limits<double>::infinity();
  114|      0|    } else if (*out < -1.0) {
  ------------------
  |  Branch (114:16): [True: 0, False: 0]
  ------------------
  115|      0|      *out = -std::numeric_limits<double>::infinity();
  116|      0|    }
  117|      0|  }
  118|  2.17k|  return true;
  119|  2.17k|}
_ZN4absl12lts_2026052610SimpleAtobENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEPb:
  121|  11.2k|bool SimpleAtob(absl::string_view str, bool* absl_nonnull out) {
  122|  11.2k|  ABSL_RAW_CHECK(out != nullptr, "Output pointer must not be nullptr.");
  ------------------
  |  |   60|  11.2k|  do {                                                                 \
  |  |   61|  11.2k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|  11.2k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 11.2k]
  |  |  |  |  |  Branch (190:49): [Folded, False: 11.2k]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 11.2k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|  11.2k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 11.2k]
  |  |  ------------------
  ------------------
  123|  11.2k|  if (EqualsIgnoreCase(str, "true") || EqualsIgnoreCase(str, "t") ||
  ------------------
  |  Branch (123:7): [True: 3.67k, False: 7.59k]
  |  Branch (123:40): [True: 0, False: 7.59k]
  ------------------
  124|  7.59k|      EqualsIgnoreCase(str, "yes") || EqualsIgnoreCase(str, "y") ||
  ------------------
  |  Branch (124:7): [True: 0, False: 7.59k]
  |  Branch (124:39): [True: 0, False: 7.59k]
  ------------------
  125|  7.59k|      EqualsIgnoreCase(str, "1")) {
  ------------------
  |  Branch (125:7): [True: 0, False: 7.59k]
  ------------------
  126|  3.67k|    *out = true;
  127|  3.67k|    return true;
  128|  3.67k|  }
  129|  7.59k|  if (EqualsIgnoreCase(str, "false") || EqualsIgnoreCase(str, "f") ||
  ------------------
  |  Branch (129:7): [True: 7.59k, False: 0]
  |  Branch (129:41): [True: 0, False: 0]
  ------------------
  130|      0|      EqualsIgnoreCase(str, "no") || EqualsIgnoreCase(str, "n") ||
  ------------------
  |  Branch (130:7): [True: 0, False: 0]
  |  Branch (130:38): [True: 0, False: 0]
  ------------------
  131|  7.59k|      EqualsIgnoreCase(str, "0")) {
  ------------------
  |  Branch (131:7): [True: 0, False: 0]
  ------------------
  132|  7.59k|    *out = false;
  133|  7.59k|    return true;
  134|  7.59k|  }
  135|      0|  return false;
  136|  7.59k|}
_ZN4absl12lts_2026052616numbers_internal15FastIntToBufferEiPc:
  349|  2.45M|    int32_t i, char* absl_nonnull buffer) {
  350|  2.45M|  uint32_t u = static_cast<uint32_t>(i);
  351|  2.45M|  if (i < 0) {
  ------------------
  |  Branch (351:7): [True: 0, False: 2.45M]
  ------------------
  352|      0|    *buffer++ = '-';
  353|       |    // We need to do the negation in modular (i.e., "unsigned")
  354|       |    // arithmetic; MSVC++ apparently warns for plain "-u", so
  355|       |    // we write the equivalent expression "0 - u" instead.
  356|      0|    u = 0 - u;
  357|      0|  }
  358|  2.45M|  buffer = EncodeFullU32(u, buffer);
  359|  2.45M|  *buffer = '\0';
  360|  2.45M|  return buffer;
  361|  2.45M|}
_ZN4absl12lts_2026052616numbers_internal17safe_strto32_baseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPii:
 1595|  17.0k|                       int base) {
 1596|  17.0k|  return safe_int_internal<int32_t>(text, value, base);
 1597|  17.0k|}
_ZN4absl12lts_2026052616numbers_internal18safe_strtou64_baseENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPmi:
 1625|  1.76k|                        int base) {
 1626|  1.76k|  return safe_uint_internal<uint64_t>(text, value, base);
 1627|  1.76k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113EncodeFullU32EjPc:
  259|  2.45M|    uint32_t n, char* absl_nonnull out_str) {
  260|  2.45M|  if (n < 10) {
  ------------------
  |  Branch (260:7): [True: 1.41k, False: 2.45M]
  ------------------
  261|  1.41k|    *out_str = static_cast<char>('0' + n);
  262|  1.41k|    return out_str + 1;
  263|  1.41k|  }
  264|  2.45M|  if (n < 100'000'000) {
  ------------------
  |  Branch (264:7): [True: 1.84M, False: 612k]
  ------------------
  265|  1.84M|    uint64_t bottom = PrepareEightDigits(n);
  266|  1.84M|    ABSL_ASSUME(bottom != 0);
  ------------------
  |  |  271|  1.84M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  267|       |    // 0 minus 8 to make MSVC happy.
  268|  1.84M|    uint32_t zeroes =
  269|  1.84M|        static_cast<uint32_t>(absl::countr_zero(bottom)) & (0 - 8u);
  270|  1.84M|    little_endian::Store64(out_str, (bottom + kEightZeroBytes) >> zeroes);
  271|  1.84M|    return out_str + sizeof(bottom) - zeroes / 8;
  272|  1.84M|  }
  273|   612k|  uint32_t div08 = n / 100'000'000;
  274|   612k|  uint32_t mod08 = n % 100'000'000;
  275|   612k|  uint64_t bottom = PrepareEightDigits(mod08) + kEightZeroBytes;
  276|   612k|  out_str = EncodeHundred(div08, out_str);
  277|   612k|  little_endian::Store64(out_str, bottom);
  278|   612k|  return out_str + sizeof(bottom);
  279|  2.45M|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118PrepareEightDigitsEj:
  230|  2.45M|inline uint64_t PrepareEightDigits(uint32_t i) {
  231|  2.45M|  ABSL_ASSUME(i < 10000'0000);
  ------------------
  |  |  271|  2.45M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  232|       |  // Prepare 2 blocks of 4 digits "in parallel".
  233|  2.45M|  uint32_t hi = i / 10000;
  234|  2.45M|  uint32_t lo = i % 10000;
  235|  2.45M|  uint64_t merged = hi | (uint64_t{lo} << 32);
  236|  2.45M|  uint64_t div100 = ((merged * kDivisionBy100Mul) / kDivisionBy100Div) &
  237|  2.45M|                    ((0x7Full << 32) | 0x7Full);
  238|  2.45M|  uint64_t mod100 = merged - 100ull * div100;
  239|  2.45M|  uint64_t hundreds = (mod100 << 16) + div100;
  240|  2.45M|  uint64_t tens = (hundreds * kDivisionBy10Mul) / kDivisionBy10Div;
  241|  2.45M|  tens &= (0xFull << 48) | (0xFull << 32) | (0xFull << 16) | 0xFull;
  242|  2.45M|  tens += (hundreds - 10ull * tens) << 8;
  243|  2.45M|  return tens;
  244|  2.45M|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_113EncodeHundredEjPc:
  180|   612k|inline char* EncodeHundred(uint32_t n, char* absl_nonnull out_str) {
  181|   612k|  int num_digits = static_cast<int>(n - 10) >> 8;
  182|   612k|  uint32_t div10 = (n * kDivisionBy10Mul) / kDivisionBy10Div;
  183|   612k|  uint32_t mod10 = n - 10u * div10;
  184|   612k|  uint32_t base = kTwoZeroBytes + div10 + (mod10 << 8);
  185|   612k|  base >>= num_digits & 8;
  186|   612k|  little_endian::Store16(out_str, static_cast<uint16_t>(base));
  187|   612k|  return out_str + 2 + num_digits;
  188|   612k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_124safe_parse_sign_and_baseEPNSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEPiPb:
 1168|  18.8k|    bool* absl_nonnull negative_ptr /*output*/) {
 1169|  18.8k|  if (text->data() == nullptr) {
  ------------------
  |  Branch (1169:7): [True: 0, False: 18.8k]
  ------------------
 1170|      0|    return false;
 1171|      0|  }
 1172|       |
 1173|  18.8k|  const char* start = text->data();
 1174|  18.8k|  const char* end = start + text->size();
 1175|  18.8k|  int base = *base_ptr;
 1176|       |
 1177|       |  // Consume whitespace.
 1178|  18.8k|  while (start < end &&
  ------------------
  |  Branch (1178:10): [True: 18.8k, False: 0]
  ------------------
 1179|  18.8k|         absl::ascii_isspace(static_cast<unsigned char>(start[0]))) {
  ------------------
  |  Branch (1179:10): [True: 0, False: 18.8k]
  ------------------
 1180|      0|    ++start;
 1181|      0|  }
 1182|  18.8k|  while (start < end &&
  ------------------
  |  Branch (1182:10): [True: 18.8k, False: 0]
  ------------------
 1183|  18.8k|         absl::ascii_isspace(static_cast<unsigned char>(end[-1]))) {
  ------------------
  |  Branch (1183:10): [True: 0, False: 18.8k]
  ------------------
 1184|      0|    --end;
 1185|      0|  }
 1186|  18.8k|  if (start >= end) {
  ------------------
  |  Branch (1186:7): [True: 0, False: 18.8k]
  ------------------
 1187|      0|    return false;
 1188|      0|  }
 1189|       |
 1190|       |  // Consume sign.
 1191|  18.8k|  *negative_ptr = (start[0] == '-');
 1192|  18.8k|  if (*negative_ptr || start[0] == '+') {
  ------------------
  |  Branch (1192:7): [True: 0, False: 18.8k]
  |  Branch (1192:24): [True: 0, False: 18.8k]
  ------------------
 1193|      0|    ++start;
 1194|      0|    if (start >= end) {
  ------------------
  |  Branch (1194:9): [True: 0, False: 0]
  ------------------
 1195|      0|      return false;
 1196|      0|    }
 1197|      0|  }
 1198|       |
 1199|       |  // Consume base-dependent prefix.
 1200|       |  //  base 0: "0x" -> base 16, "0" -> base 8, default -> base 10
 1201|       |  //  base 16: "0x" -> base 16
 1202|       |  // Also validate the base.
 1203|  18.8k|  if (base == 0) {
  ------------------
  |  Branch (1203:7): [True: 0, False: 18.8k]
  ------------------
 1204|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (1204:9): [True: 0, False: 0]
  |  Branch (1204:29): [True: 0, False: 0]
  ------------------
 1205|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (1205:10): [True: 0, False: 0]
  |  Branch (1205:29): [True: 0, False: 0]
  ------------------
 1206|      0|      base = 16;
 1207|      0|      start += 2;
 1208|      0|      if (start >= end) {
  ------------------
  |  Branch (1208:11): [True: 0, False: 0]
  ------------------
 1209|       |        // "0x" with no digits after is invalid.
 1210|      0|        return false;
 1211|      0|      }
 1212|      0|    } else if (end - start >= 1 && start[0] == '0') {
  ------------------
  |  Branch (1212:16): [True: 0, False: 0]
  |  Branch (1212:36): [True: 0, False: 0]
  ------------------
 1213|      0|      base = 8;
 1214|      0|      start += 1;
 1215|      0|    } else {
 1216|      0|      base = 10;
 1217|      0|    }
 1218|  18.8k|  } else if (base == 16) {
  ------------------
  |  Branch (1218:14): [True: 0, False: 18.8k]
  ------------------
 1219|      0|    if (end - start >= 2 && start[0] == '0' &&
  ------------------
  |  Branch (1219:9): [True: 0, False: 0]
  |  Branch (1219:29): [True: 0, False: 0]
  ------------------
 1220|      0|        (start[1] == 'x' || start[1] == 'X')) {
  ------------------
  |  Branch (1220:10): [True: 0, False: 0]
  |  Branch (1220:29): [True: 0, False: 0]
  ------------------
 1221|      0|      start += 2;
 1222|      0|      if (start >= end) {
  ------------------
  |  Branch (1222:11): [True: 0, False: 0]
  ------------------
 1223|       |        // "0x" with no digits after is invalid.
 1224|      0|        return false;
 1225|      0|      }
 1226|      0|    }
 1227|  18.8k|  } else if (base >= 2 && base <= 36) {
  ------------------
  |  Branch (1227:14): [True: 18.8k, False: 0]
  |  Branch (1227:27): [True: 18.8k, False: 0]
  ------------------
 1228|       |    // okay
 1229|  18.8k|  } else {
 1230|      0|    return false;
 1231|      0|  }
 1232|  18.8k|  *text = absl::string_view(start, static_cast<size_t>(end - start));
 1233|  18.8k|  *base_ptr = base;
 1234|  18.8k|  return true;
 1235|  18.8k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_117safe_int_internalIiEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
 1535|  17.0k|                              IntType* absl_nonnull value_p, int base) {
 1536|  17.0k|  *value_p = 0;
 1537|  17.0k|  bool negative;
 1538|  17.0k|  if (!safe_parse_sign_and_base(&text, &base, &negative)) {
  ------------------
  |  Branch (1538:7): [True: 0, False: 17.0k]
  ------------------
 1539|      0|    return false;
 1540|      0|  }
 1541|  17.0k|  if (!negative) {
  ------------------
  |  Branch (1541:7): [True: 17.0k, False: 0]
  ------------------
 1542|  17.0k|    return safe_parse_positive_int(text, base, value_p);
 1543|  17.0k|  } else {
 1544|      0|    return safe_parse_negative_int(text, base, value_p);
 1545|      0|  }
 1546|  17.0k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_123safe_parse_positive_intIiEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiPT_:
 1453|  17.0k|                                    IntType* absl_nonnull value_p) {
 1454|  17.0k|  IntType value = 0;
 1455|  17.0k|  const IntType vmax = std::numeric_limits<IntType>::max();
 1456|  17.0k|  assert(vmax > 0);
 1457|  17.0k|  assert(base >= 0);
 1458|  17.0k|  const IntType base_inttype = static_cast<IntType>(base);
 1459|  17.0k|  assert(vmax >= base_inttype);
 1460|  17.0k|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1461|  17.0k|  assert(base < 2 ||
 1462|  17.0k|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1463|  17.0k|  const char* start = text.data();
 1464|  17.0k|  const char* end = start + text.size();
 1465|       |  // loop over digits
 1466|  42.7k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1466:10): [True: 25.6k, False: 17.0k]
  ------------------
 1467|  25.6k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1468|  25.6k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1469|  25.6k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1469:9): [True: 0, False: 25.6k]
  ------------------
 1470|      0|      *value_p = value;
 1471|      0|      return false;
 1472|      0|    }
 1473|  25.6k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1473:9): [True: 0, False: 25.6k]
  ------------------
 1474|      0|      *value_p = vmax;
 1475|      0|      return false;
 1476|      0|    }
 1477|  25.6k|    value *= base_inttype;
 1478|  25.6k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1478:9): [True: 0, False: 25.6k]
  ------------------
 1479|      0|      *value_p = vmax;
 1480|      0|      return false;
 1481|      0|    }
 1482|  25.6k|    value += digit;
 1483|  25.6k|  }
 1484|  17.0k|  *value_p = value;
 1485|  17.0k|  return true;
 1486|  17.0k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_118safe_uint_internalImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPT_i:
 1550|  1.76k|                               IntType* absl_nonnull value_p, int base) {
 1551|  1.76k|  *value_p = 0;
 1552|  1.76k|  bool negative;
 1553|  1.76k|  if (!safe_parse_sign_and_base(&text, &base, &negative) || negative) {
  ------------------
  |  Branch (1553:7): [True: 0, False: 1.76k]
  |  Branch (1553:61): [True: 0, False: 1.76k]
  ------------------
 1554|      0|    return false;
 1555|      0|  }
 1556|  1.76k|  return safe_parse_positive_int(text, base, value_p);
 1557|  1.76k|}
numbers.cc:_ZN4absl12lts_2026052612_GLOBAL__N_123safe_parse_positive_intImEEbNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiPT_:
 1453|  1.76k|                                    IntType* absl_nonnull value_p) {
 1454|  1.76k|  IntType value = 0;
 1455|  1.76k|  const IntType vmax = std::numeric_limits<IntType>::max();
 1456|  1.76k|  assert(vmax > 0);
 1457|  1.76k|  assert(base >= 0);
 1458|  1.76k|  const IntType base_inttype = static_cast<IntType>(base);
 1459|  1.76k|  assert(vmax >= base_inttype);
 1460|  1.76k|  const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
 1461|  1.76k|  assert(base < 2 ||
 1462|  1.76k|         std::numeric_limits<IntType>::max() / base_inttype == vmax_over_base);
 1463|  1.76k|  const char* start = text.data();
 1464|  1.76k|  const char* end = start + text.size();
 1465|       |  // loop over digits
 1466|  7.04k|  for (; start < end; ++start) {
  ------------------
  |  Branch (1466:10): [True: 5.28k, False: 1.76k]
  ------------------
 1467|  5.28k|    unsigned char c = static_cast<unsigned char>(start[0]);
 1468|  5.28k|    IntType digit = static_cast<IntType>(kAsciiToInt[c]);
 1469|  5.28k|    if (digit >= base_inttype) {
  ------------------
  |  Branch (1469:9): [True: 0, False: 5.28k]
  ------------------
 1470|      0|      *value_p = value;
 1471|      0|      return false;
 1472|      0|    }
 1473|  5.28k|    if (value > vmax_over_base) {
  ------------------
  |  Branch (1473:9): [True: 0, False: 5.28k]
  ------------------
 1474|      0|      *value_p = vmax;
 1475|      0|      return false;
 1476|      0|    }
 1477|  5.28k|    value *= base_inttype;
 1478|  5.28k|    if (value > vmax - digit) {
  ------------------
  |  Branch (1478:9): [True: 0, False: 5.28k]
  ------------------
 1479|      0|      *value_p = vmax;
 1480|      0|      return false;
 1481|      0|    }
 1482|  5.28k|    value += digit;
 1483|  5.28k|  }
 1484|  1.76k|  *value_p = value;
 1485|  1.76k|  return true;
 1486|  1.76k|}

str_cat.cc:_ZN4absl12lts_2026052624StringResizeAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_6StrCatERKNS0_8AlphaNumESB_E3$_0EEvRT_NSD_9size_typeET0_:
  186|  8.54k|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  187|  8.54k|  strings_internal::StringResizeAndOverwriteImpl(str, n, std::move(op));
  188|       |#if defined(ABSL_HAVE_MEMORY_SANITIZER)
  189|       |  __msan_check_mem_is_initialized(str.data(), str.size());
  190|       |#endif
  191|  8.54k|}
str_cat.cc:_ZN4absl12lts_2026052616strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS0_6StrCatERKNS0_8AlphaNumESC_E3$_0EEvRT_NSE_9size_typeET0_:
  149|  8.54k|void StringResizeAndOverwriteImpl(T& str, typename T::size_type n, Op op) {
  150|       |#ifdef ABSL_INTERNAL_HAS_RESIZE_AND_OVERWRITE
  151|       |  str.resize_and_overwrite(n, std::move(op));
  152|       |#else
  153|       |  if constexpr (strings_internal::
  154|       |                    has__google_nonstandard_backport_resize_and_overwrite<
  155|       |                        T>::value) {
  156|       |    str.__google_nonstandard_backport_resize_and_overwrite(n, std::move(op));
  157|       |  } else if constexpr (strings_internal::has__resize_and_overwrite<T>::value) {
  158|       |    str.__resize_and_overwrite(n, std::move(op));
  159|  8.54k|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  160|  8.54k|    str.__resize_default_init(n);
  161|  8.54k|    str.__resize_default_init(
  162|  8.54k|        static_cast<typename T::size_type>(std::move(op)(str.data(), n)));
  163|       |  } else if constexpr (strings_internal::has_Resize_and_overwrite<T>::value) {
  164|       |    str._Resize_and_overwrite(n, std::move(op));
  165|       |  } else {
  166|       |    strings_internal::StringResizeAndOverwriteFallback(str, n, std::move(op));
  167|       |  }
  168|  8.54k|#endif
  169|  8.54k|}

_ZN4absl12lts_202605266StrCatERKNS0_8AlphaNumES3_:
   58|  8.54k|std::string StrCat(const AlphaNum& a, const AlphaNum& b) {
   59|  8.54k|  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|  8.54k|  constexpr uint64_t kMaxSize = uint64_t{std::numeric_limits<size_t>::max()};
   63|  8.54k|  const uint64_t result_size =
   64|  8.54k|      static_cast<uint64_t>(a.size()) + static_cast<uint64_t>(b.size());
   65|  8.54k|  ABSL_INTERNAL_CHECK(result_size <= kMaxSize, "size_t overflow");
  ------------------
  |  |   85|  8.54k|  do {                                                             \
  |  |   86|  8.54k|    if (ABSL_PREDICT_FALSE(!(condition))) {                        \
  |  |  ------------------
  |  |  |  |  190|  8.54k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 8.54k]
  |  |  |  |  |  Branch (190:49): [Folded, False: 8.54k]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 8.54k]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   82|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (82:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   90|      0|    }                                                              \
  |  |   91|  8.54k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (91:12): [Folded, False: 8.54k]
  |  |  ------------------
  ------------------
   66|  8.54k|  absl::StringResizeAndOverwrite(result, static_cast<size_t>(result_size),
   67|  8.54k|                                 [&a, &b](char* const begin, size_t buf_size) {
   68|  8.54k|                                   char* out = begin;
   69|  8.54k|                                   out = Append(out, a);
   70|  8.54k|                                   out = Append(out, b);
   71|  8.54k|                                   assert(out == begin + buf_size);
   72|  8.54k|                                   return buf_size;
   73|  8.54k|                                 });
   74|  8.54k|  return result;
   75|  8.54k|}
str_cat.cc:_ZZN4absl12lts_202605266StrCatERKNS0_8AlphaNumES3_ENK3$_0clEPcm:
   67|  8.54k|                                 [&a, &b](char* const begin, size_t buf_size) {
   68|  8.54k|                                   char* out = begin;
   69|  8.54k|                                   out = Append(out, a);
   70|  8.54k|                                   out = Append(out, b);
   71|       |                                   assert(out == begin + buf_size);
   72|  8.54k|                                   return buf_size;
   73|  8.54k|                                 });
str_cat.cc:_ZN4absl12lts_2026052612_GLOBAL__N_16AppendEPcRKNS0_8AlphaNumE:
   46|  17.0k|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|  17.0k|  char* after = out + x.size();
   50|  17.0k|  if (x.size() != 0) {
  ------------------
  |  Branch (50:7): [True: 17.0k, False: 0]
  ------------------
   51|  17.0k|    memcpy(out, x.data(), x.size());
   52|  17.0k|  }
   53|  17.0k|  return after;
   54|  17.0k|}

_ZNK4absl12lts_202605268AlphaNum4sizeEv:
  430|  68.3k|  absl::string_view::size_type size() const { return piece_.size(); }
_ZNK4absl12lts_202605268AlphaNum4dataEv:
  431|  17.0k|  const char* absl_nullable data() const { return piece_.data(); }

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

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

_ZN4absl12lts_2026052624synchronization_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|       |  // To avoid a circular dependency we declare only the storage in the header
   81|       |  // and use placement new to construct the SpinLock.
   82|      2|  static_assert(
   83|      2|      sizeof(base_internal::ThreadIdentity::SchedulerState::
   84|      2|                 association_lock_word) == sizeof(base_internal::SpinLock),
   85|      2|      "Wrong size for SpinLock");
   86|       |  // Protects the association between this identity and its schedulable.  Should
   87|       |  // never be cooperative.
   88|      2|  new (&identity->scheduler_state.association_lock_word)
   89|      2|      base_internal::SpinLock(base_internal::SCHEDULE_KERNEL_ONLY);
   90|      2|}
_ZN4absl12lts_2026052624synchronization_internal20CreateThreadIdentityEv:
  162|     14|base_internal::ThreadIdentity* CreateThreadIdentity() {
  163|     14|  base_internal::ThreadIdentity* identity = NewThreadIdentity();
  164|       |  // Associate the value with the current thread, and attach our destructor.
  165|     14|  base_internal::SetCurrentThreadIdentity(identity, ReclaimThreadIdentity);
  166|     14|  return identity;
  167|     14|}
create_thread_identity.cc:_ZN4absl12lts_2026052624synchronization_internalL17NewThreadIdentityEv:
  127|     14|static base_internal::ThreadIdentity* NewThreadIdentity() {
  128|     14|  base_internal::ThreadIdentity* identity = nullptr;
  129|       |
  130|     14|  {
  131|       |    // Re-use a previously released object if possible.
  132|     14|    base_internal::SpinLockHolder l(freelist_lock);
  133|     14|    if (thread_identity_freelist) {
  ------------------
  |  Branch (133:9): [True: 12, False: 2]
  ------------------
  134|     12|      identity = thread_identity_freelist;  // Take list-head.
  135|     12|      thread_identity_freelist = thread_identity_freelist->next;
  136|     12|    }
  137|     14|  }
  138|       |
  139|     14|  if (identity == nullptr) {
  ------------------
  |  Branch (139:7): [True: 2, False: 12]
  ------------------
  140|       |    // Allocate enough space to align ThreadIdentity to a multiple of
  141|       |    // PerThreadSynch::kAlignment. This space is never released (it is
  142|       |    // added to a freelist by ReclaimThreadIdentity instead).
  143|      2|    void* allocation = base_internal::LowLevelAlloc::Alloc(
  144|      2|        sizeof(*identity) + base_internal::PerThreadSynch::kAlignment - 1);
  145|       |    // Round up the address to the required alignment.
  146|      2|    identity = reinterpret_cast<base_internal::ThreadIdentity*>(
  147|      2|        RoundUp(reinterpret_cast<intptr_t>(allocation),
  148|      2|                base_internal::PerThreadSynch::kAlignment));
  149|       |    // Note that *identity is never constructed.
  150|       |    // TODO(b/357097463): change this "one time init" to be a proper
  151|       |    // constructor.
  152|      2|    OneTimeInitThreadIdentity(identity);
  153|      2|  }
  154|     14|  ResetThreadIdentityBetweenReuse(identity);
  155|       |
  156|     14|  return identity;
  157|     14|}
create_thread_identity.cc:_ZN4absl12lts_2026052624synchronization_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_2026052624synchronization_internalL31ResetThreadIdentityBetweenReuseEPNS0_13base_internal14ThreadIdentityE:
   93|     14|    base_internal::ThreadIdentity* identity) {
   94|     14|  base_internal::PerThreadSynch* pts = &identity->per_thread_synch;
   95|     14|  pts->next = nullptr;
   96|     14|  pts->skip = nullptr;
   97|     14|  pts->may_skip = false;
   98|     14|  pts->waitp = nullptr;
   99|     14|  pts->suppress_fatal_errors = false;
  100|     14|  pts->readers = 0;
  101|     14|  pts->priority = 0;
  102|     14|  pts->next_priority_read_cycles = 0;
  103|     14|  pts->state.store(base_internal::PerThreadSynch::State::kAvailable,
  104|     14|                   std::memory_order_relaxed);
  105|     14|  pts->maybe_unlocking = false;
  106|     14|  pts->wake = false;
  107|     14|  pts->cond_waiter = false;
  108|     14|  pts->all_locks = nullptr;
  109|     14|  base_internal::ThreadIdentity::SchedulerState* ss =
  110|     14|      &identity->scheduler_state;
  111|     14|  ss->bound_schedulable.store(nullptr, std::memory_order_relaxed);
  112|     14|  ss->association_lock_word = 0;
  113|     14|  ss->scheduling_disabled_depth.store(0, std::memory_order_relaxed);
  114|     14|  ss->potentially_blocking_depth = 0;
  115|     14|  ss->schedule_next_state = 0;
  116|     14|  ss->waking_designated_waker = false;
  117|     14|  identity->static_initialization_depth = 0;
  118|     14|  identity->wait_state.store(base_internal::ThreadIdentity::WaitState::kActive,
  119|     14|                             std::memory_order_relaxed);
  120|     14|  identity->blocked_count_ptr = nullptr;
  121|     14|  identity->ticker.store(0, std::memory_order_relaxed);
  122|     14|  identity->wait_start.store(0, std::memory_order_relaxed);
  123|     14|  identity->is_idle.store(false, std::memory_order_relaxed);
  124|     14|  identity->next = nullptr;
  125|     14|}
create_thread_identity.cc:_ZN4absl12lts_2026052624synchronization_internalL21ReclaimThreadIdentityEPv:
   44|     13|static void ReclaimThreadIdentity(void* v) {
   45|     13|  base_internal::ThreadIdentity* identity =
   46|     13|      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|     13|  if (identity->per_thread_synch.all_locks != nullptr) {
  ------------------
  |  Branch (50:7): [True: 0, False: 13]
  ------------------
   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|     13|  base_internal::ClearCurrentThreadIdentity();
   62|     13|  {
   63|     13|    base_internal::SpinLockHolder l(freelist_lock);
   64|     13|    identity->next = thread_identity_freelist;
   65|     13|    thread_identity_freelist = identity;
   66|     13|  }
   67|     13|}

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

_ZN4absl12lts_2026052624synchronization_internal9FutexImpl4WaitEPNSt3__16atomicIiEEi:
  101|     12|  static int Wait(std::atomic<int32_t>* v, int32_t val) {
  102|     12|    return WaitAbsoluteTimeout(v, val, nullptr);
  103|     12|  }
_ZN4absl12lts_2026052624synchronization_internal9FutexImpl19WaitAbsoluteTimeoutEPNSt3__16atomicIiEEiPK8timespec:
  108|     12|                                 const struct timespec* abs_timeout) {
  109|     12|    FutexTimespec ts;
  110|       |    // https://locklessinc.com/articles/futex_cheat_sheet/
  111|       |    // Unlike FUTEX_WAIT, FUTEX_WAIT_BITSET uses absolute time.
  112|     12|    auto err = syscall(
  113|     12|        SYS_futex, reinterpret_cast<int32_t*>(v),
  114|     12|        FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG | FUTEX_CLOCK_REALTIME, val,
  115|     12|        ToFutexTimespec(abs_timeout, &ts), nullptr, FUTEX_BITSET_MATCH_ANY);
  116|     12|    if (err != 0) {
  ------------------
  |  Branch (116:9): [True: 0, False: 12]
  ------------------
  117|      0|      return -errno;
  118|      0|    }
  119|     12|    return 0;
  120|     12|  }
_ZN4absl12lts_2026052624synchronization_internal9FutexImpl4WakeEPNSt3__16atomicIiEEi:
  139|     12|  static int Wake(std::atomic<int32_t>* v, int32_t count) {
  140|     12|    auto err = syscall(SYS_futex, reinterpret_cast<int32_t*>(v),
  141|     12|                       FUTEX_WAKE | FUTEX_PRIVATE_FLAG, count);
  142|     12|    if (ABSL_PREDICT_FALSE(err < 0)) {
  ------------------
  |  |  190|     12|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 12]
  |  |  |  Branch (190:49): [Folded, False: 12]
  |  |  |  Branch (190:58): [True: 0, False: 12]
  |  |  ------------------
  ------------------
  143|      0|      return -errno;
  144|      0|    }
  145|     12|    return 0;
  146|     12|  }
_ZN4absl12lts_2026052624synchronization_internal9FutexImpl15ToFutexTimespecEPK8timespecPNS1_13FutexTimespecE:
  150|     12|                                        FutexTimespec* futex_ts) {
  151|     12|    if (userspace_ts == nullptr) {
  ------------------
  |  Branch (151:9): [True: 12, False: 0]
  ------------------
  152|     12|      return nullptr;
  153|     12|    }
  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|     12|  }

_ZN4absl12lts_2026052624synchronization_internal11FutexWaiter9WaitUntilEPNSt3__16atomicIiEEiNS1_13KernelTimeoutE:
   35|     12|                           KernelTimeout t) {
   36|     12|#ifdef CLOCK_MONOTONIC
   37|     12|  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|     12|  if (!t.has_timeout()) {
  ------------------
  |  Branch (44:7): [True: 12, False: 0]
  ------------------
   45|     12|    return Futex::Wait(v, val);
   46|     12|  } 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|     12|}
_ZN4absl12lts_2026052624synchronization_internal11FutexWaiter4WaitENS1_13KernelTimeoutE:
   56|     12|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|     12|  bool first_pass = true;
   62|     24|  while (true) {
  ------------------
  |  Branch (62:10): [True: 24, Folded]
  ------------------
   63|     24|    int32_t x = futex_.load(std::memory_order_relaxed);
   64|     24|    while (x != 0) {
  ------------------
  |  Branch (64:12): [True: 12, False: 12]
  ------------------
   65|     12|      if (!futex_.compare_exchange_weak(x, x - 1,
  ------------------
  |  Branch (65:11): [True: 0, False: 12]
  ------------------
   66|     12|                                        std::memory_order_acquire,
   67|     12|                                        std::memory_order_relaxed)) {
   68|      0|        continue;  // Raced with someone, retry.
   69|      0|      }
   70|     12|      return true;  // Consumed a wakeup, we are done.
   71|     12|    }
   72|       |
   73|     12|    if (!first_pass) MaybeBecomeIdle();
  ------------------
  |  Branch (73:9): [True: 0, False: 12]
  ------------------
   74|     12|    const int err = WaitUntil(&futex_, 0, t);
   75|     12|    if (err != 0) {
  ------------------
  |  Branch (75:9): [True: 0, False: 12]
  ------------------
   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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
   82|      0|      }
   83|      0|    }
   84|     12|    first_pass = false;
   85|     12|  }
   86|     12|}
_ZN4absl12lts_2026052624synchronization_internal11FutexWaiter4PostEv:
   88|     12|void FutexWaiter::Post() {
   89|     12|  if (futex_.fetch_add(1, std::memory_order_release) == 0) {
  ------------------
  |  Branch (89:7): [True: 12, False: 0]
  ------------------
   90|       |    // We incremented from 0, need to wake a potential waiter.
   91|     12|    Poke();
   92|     12|  }
   93|     12|}
_ZN4absl12lts_2026052624synchronization_internal11FutexWaiter4PokeEv:
   95|     12|void FutexWaiter::Poke() {
   96|       |  // Wake one thread waiting on the futex.
   97|     12|  const int err = Futex::Wake(&futex_, 1);
   98|     12|  if (ABSL_PREDICT_FALSE(err < 0)) {
  ------------------
  |  |  190|     12|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 12]
  |  |  |  Branch (190:49): [Folded, False: 12]
  |  |  |  Branch (190:58): [True: 0, False: 12]
  |  |  ------------------
  ------------------
   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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  100|      0|  }
  101|     12|}

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

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

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

AbslInternalPerThreadSemInit_lts_20260526:
   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_20260526:
   67|     12|    absl::base_internal::ThreadIdentity *identity) {
   68|     12|  absl::synchronization_internal::Waiter::GetWaiter(identity)->Post();
   69|     12|}
AbslInternalPerThreadSemWait_lts_20260526:
   77|     12|    absl::synchronization_internal::KernelTimeout t) {
   78|     12|  bool timeout = false;
   79|     12|  absl::base_internal::ThreadIdentity *identity;
   80|     12|  identity = absl::synchronization_internal::GetOrCreateCurrentThreadIdentity();
   81|       |
   82|       |  // Ensure wait_start != 0.
   83|     12|  int ticker = identity->ticker.load(std::memory_order_relaxed);
   84|     12|  identity->wait_start.store(ticker ? ticker : 1, std::memory_order_relaxed);
  ------------------
  |  Branch (84:30): [True: 0, False: 12]
  ------------------
   85|     12|  identity->is_idle.store(false, std::memory_order_relaxed);
   86|       |
   87|     12|  if (identity->blocked_count_ptr != nullptr) {
  ------------------
  |  Branch (87:7): [True: 0, False: 12]
  ------------------
   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|     12|  timeout =
   93|     12|      !absl::synchronization_internal::Waiter::GetWaiter(identity)->Wait(t);
   94|       |
   95|     12|  if (identity->blocked_count_ptr != nullptr) {
  ------------------
  |  Branch (95:7): [True: 0, False: 12]
  ------------------
   96|      0|    identity->blocked_count_ptr->fetch_sub(1, std::memory_order_relaxed);
   97|      0|  }
   98|       |
   99|     12|  identity->is_idle.store(false, std::memory_order_relaxed);
  100|     12|  identity->wait_start.store(0, std::memory_order_relaxed);
  101|     12|  return !timeout;
  102|     12|}

_ZN4absl12lts_2026052624synchronization_internal12PerThreadSem4InitEPNS0_13base_internal14ThreadIdentityE:
  110|      2|    absl::base_internal::ThreadIdentity* identity) {
  111|      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
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  112|      2|}
_ZN4absl12lts_2026052624synchronization_internal12PerThreadSem4PostEPNS0_13base_internal14ThreadIdentityE:
  115|     12|    absl::base_internal::ThreadIdentity* identity) {
  116|     12|  ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemPost)(identity);
  ------------------
  |  |  187|     12|  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
  |  |  ------------------
  |  |  |  |  185|     12|  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
  |  |  |  |  ------------------
  |  |  |  |  |  |  183|     12|#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  117|     12|}
_ZN4absl12lts_2026052624synchronization_internal12PerThreadSem4WaitENS1_13KernelTimeoutE:
  120|     12|    absl::synchronization_internal::KernelTimeout t) {
  121|     12|  return ABSL_INTERNAL_C_SYMBOL(AbslInternalPerThreadSemWait)(t);
  ------------------
  |  |  187|     12|  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
  |  |  ------------------
  |  |  |  |  185|     12|  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
  |  |  |  |  ------------------
  |  |  |  |  |  |  183|     12|#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  122|     12|}

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

AbslInternalMutexYield_lts_20260526:
   76|     42|ABSL_ATTRIBUTE_WEAK void ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)() {
   77|     42|  std::this_thread::yield();
   78|     42|}
_ZN4absl12lts_2026052624synchronization_internal10MutexDelayEii:
  178|  10.7k|int MutexDelay(int32_t c, int mode) {
  179|  10.7k|  const int32_t limit = GetMutexGlobals().mutex_sleep_spins[mode];
  180|  10.7k|  const absl::Duration sleep_time = GetMutexGlobals().mutex_sleep_time;
  181|  10.7k|  if (c < limit) {
  ------------------
  |  Branch (181:7): [True: 10.7k, False: 84]
  ------------------
  182|       |    // Spin.
  183|  10.7k|    c++;
  184|  10.7k|  } else {
  185|     84|    SchedulingGuard::ScopedEnable enable_rescheduling;
  186|     84|    ABSL_TSAN_MUTEX_PRE_DIVERT(nullptr, 0);
  187|     84|    if (c == limit) {
  ------------------
  |  Branch (187:9): [True: 42, False: 42]
  ------------------
  188|       |      // Yield once.
  189|     42|      ABSL_INTERNAL_C_SYMBOL(AbslInternalMutexYield)();
  ------------------
  |  |  187|     42|  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
  |  |  ------------------
  |  |  |  |  185|     42|  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
  |  |  |  |  ------------------
  |  |  |  |  |  |  183|     42|#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  190|     42|      c++;
  191|     42|    } else {
  192|       |      // Then wait.
  193|     42|      absl::SleepFor(sleep_time);
  194|     42|      c = 0;
  195|     42|    }
  196|     84|    ABSL_TSAN_MUTEX_POST_DIVERT(nullptr, 0);
  197|     84|  }
  198|  10.7k|  return c;
  199|  10.7k|}
_ZN4absl12lts_202605265Mutex17IncrementSynchSemEPS1_PNS0_13base_internal14PerThreadSynchE:
  580|     12|void Mutex::IncrementSynchSem(Mutex* mu, PerThreadSynch* w) {
  581|     12|  static_cast<void>(mu);  // Prevent unused param warning in non-TSAN builds.
  582|     12|  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|     12|  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
  ------------------
  |  |  383|     12|  do {                                                \
  |  |  384|     12|    ABSL_ANNOTATE_IGNORE_READS_BEGIN();               \
  |  |  ------------------
  |  |  |  |  317|     12|  ABSL_INTERNAL_GLOBAL_SCOPED(                                      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|     12|#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
  |  |  |  |  ------------------
  |  |  |  |  318|     12|      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin)) \
  |  |  |  |  319|     12|  ()
  |  |  ------------------
  |  |  385|     12|    ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();              \
  |  |  386|     12|  } while (0)
  |  |  ------------------
  |  |  |  Branch (386:12): [Folded, False: 12]
  |  |  ------------------
  ------------------
  587|     12|  PerThreadSem::Post(w->thread_identity());
  588|     12|  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END();
  ------------------
  |  |  390|     12|  do {                                              \
  |  |  391|     12|    ABSL_ANNOTATE_IGNORE_WRITES_END();              \
  |  |  392|     12|    ABSL_ANNOTATE_IGNORE_READS_END();               \
  |  |  ------------------
  |  |  |  |  322|     12|  ABSL_INTERNAL_GLOBAL_SCOPED(                                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|     12|#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
  |  |  |  |  ------------------
  |  |  |  |  323|     12|      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \
  |  |  |  |  324|     12|  ()
  |  |  ------------------
  |  |  393|     12|  } while (0)
  |  |  ------------------
  |  |  |  Branch (393:12): [Folded, False: 12]
  |  |  ------------------
  ------------------
  589|     12|  ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
  590|     12|}
_ZN4absl12lts_202605265Mutex17DecrementSynchSemEPS1_PNS0_13base_internal14PerThreadSynchENS0_24synchronization_internal13KernelTimeoutE:
  593|     12|bool Mutex::DecrementSynchSem(Mutex* mu, PerThreadSynch* w, KernelTimeout t) {
  594|     12|  static_cast<void>(mu);  // Prevent unused param warning in non-TSAN builds.
  595|     12|  ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
  596|       |  assert(w == Synch_GetPerThread());
  597|     12|  static_cast<void>(w);
  598|     12|  bool res = PerThreadSem::Wait(t);
  599|     12|  ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
  600|     12|  return res;
  601|     12|}
_ZN4absl12lts_202605265Mutex5BlockEPNS0_13base_internal14PerThreadSynchE:
 1178|     12|void Mutex::Block(PerThreadSynch* s) {
 1179|     24|  while (s->state.load(std::memory_order_acquire) == PerThreadSynch::kQueued) {
  ------------------
  |  Branch (1179:10): [True: 12, False: 12]
  ------------------
 1180|     12|    if (!DecrementSynchSem(this, s, s->waitp->timeout)) {
  ------------------
  |  Branch (1180:9): [True: 0, False: 12]
  ------------------
 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|     12|  }
 1201|     12|  ABSL_RAW_CHECK(s->waitp != nullptr || s->suppress_fatal_errors,
  ------------------
  |  |   60|     12|  do {                                                                 \
  |  |   61|     12|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     12|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 12]
  |  |  |  |  |  Branch (190:49): [Folded, False: 12]
  |  |  |  |  |  Branch (190:59): [True: 12, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     12|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 12]
  |  |  ------------------
  ------------------
 1202|     12|                 "detected illegal recursion in Mutex code");
 1203|     12|  s->waitp = nullptr;
 1204|     12|}
_ZN4absl12lts_202605265Mutex6WakeupEPNS0_13base_internal14PerThreadSynchE:
 1207|     12|PerThreadSynch* Mutex::Wakeup(PerThreadSynch* w) {
 1208|     12|  PerThreadSynch* next = w->next;
 1209|     12|  w->next = nullptr;
 1210|     12|  w->state.store(PerThreadSynch::kAvailable, std::memory_order_release);
 1211|     12|  IncrementSynchSem(this, w);
 1212|       |
 1213|     12|  return next;
 1214|     12|}
_ZN4absl12lts_202605265Mutex4lockEv:
 1530|   199k|void Mutex::lock() {
 1531|   199k|  ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
 1532|   199k|  GraphId id = DebugOnlyDeadlockCheck(this);
 1533|   199k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1534|       |  // try fast acquire, then spin loop
 1535|   199k|  if (ABSL_PREDICT_FALSE((v & (kMuWriter | kMuReader | kMuEvent)) != 0) ||
  ------------------
  |  |  190|   398k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 10, False: 199k]
  |  |  |  Branch (190:49): [Folded, False: 199k]
  |  |  |  Branch (190:58): [True: 10, False: 199k]
  |  |  ------------------
  ------------------
 1536|   199k|      ABSL_PREDICT_FALSE(!mu_.compare_exchange_strong(
  ------------------
  |  |  190|   199k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2, False: 199k]
  |  |  |  Branch (190:49): [Folded, False: 199k]
  |  |  |  Branch (190:58): [True: 2, False: 199k]
  |  |  ------------------
  ------------------
 1537|   199k|          v, kMuWriter | v, std::memory_order_acquire,
 1538|   199k|          std::memory_order_relaxed))) {
 1539|       |    // try spin acquire, then slow loop
 1540|     12|    if (ABSL_PREDICT_FALSE(!TryAcquireWithSpinning(&this->mu_))) {
  ------------------
  |  |  190|     12|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 5, False: 7]
  |  |  |  Branch (190:49): [Folded, False: 12]
  |  |  |  Branch (190:58): [True: 5, False: 7]
  |  |  ------------------
  ------------------
 1541|      5|      this->LockSlow(kExclusive, nullptr, 0);
 1542|      5|    }
 1543|     12|  }
 1544|   199k|  DebugOnlyLockEnter(this, id);
 1545|   199k|  ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
 1546|   199k|}
_ZN4absl12lts_202605265Mutex11lock_sharedEv:
 1548|   612k|void Mutex::lock_shared() {
 1549|   612k|  ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
 1550|   612k|  GraphId id = DebugOnlyDeadlockCheck(this);
 1551|   612k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1552|   612k|  for (;;) {
 1553|       |    // If there are non-readers holding the lock, use the slow loop.
 1554|   612k|    if (ABSL_PREDICT_FALSE(v & (kMuWriter | kMuWait | kMuEvent)) != 0) {
  ------------------
  |  |  190|   612k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:49): [Folded, False: 612k]
  |  |  |  Branch (190:58): [True: 0, False: 612k]
  |  |  ------------------
  ------------------
  |  Branch (1554:9): [True: 0, False: 612k]
  ------------------
 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|   612k|    if (ABSL_PREDICT_TRUE(mu_.compare_exchange_weak(
  ------------------
  |  |  191|   612k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 612k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 612k]
  |  |  |  Branch (191:57): [True: 612k, False: 0]
  |  |  ------------------
  ------------------
 1561|   612k|            v, (kMuReader | v) + kMuOne, std::memory_order_acquire,
 1562|   612k|            std::memory_order_relaxed))) {
 1563|   612k|      break;
 1564|   612k|    }
 1565|   612k|  }
 1566|   612k|  DebugOnlyLockEnter(this, id);
 1567|   612k|  ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
 1568|   612k|}
_ZN4absl12lts_202605265Mutex11AwaitCommonERKNS0_9ConditionENS0_24synchronization_internal13KernelTimeoutE:
 1582|  99.6k|bool Mutex::AwaitCommon(const Condition& cond, KernelTimeout t) {
 1583|  99.6k|  if (kDebugMode) {
  ------------------
  |  Branch (1583:7): [Folded, False: 99.6k]
  ------------------
 1584|      0|    this->AssertReaderHeld();
 1585|      0|  }
 1586|  99.6k|  if (cond.Eval()) {  // condition already true; nothing to do
  ------------------
  |  Branch (1586:7): [True: 99.6k, False: 10]
  ------------------
 1587|  99.6k|    return true;
 1588|  99.6k|  }
 1589|     10|  MuHow how =
 1590|     10|      (mu_.load(std::memory_order_relaxed) & kMuWriter) ? kExclusive : kShared;
  ------------------
  |  Branch (1590:7): [True: 10, False: 0]
  ------------------
 1591|     10|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, TsanFlags(how));
 1592|     10|  SynchWaitParams waitp(how, &cond, t, nullptr /*no cvmu*/,
 1593|     10|                        Synch_GetPerThreadAnnotated(this),
 1594|     10|                        nullptr /*no cv_word*/);
 1595|     10|  this->UnlockSlow(&waitp);
 1596|     10|  this->Block(waitp.thread);
 1597|     10|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, TsanFlags(how));
 1598|     10|  ABSL_TSAN_MUTEX_PRE_LOCK(this, TsanFlags(how));
 1599|     10|  this->LockSlowLoop(&waitp, kMuHasBlocked | kMuIsCond);
 1600|     10|  bool res = waitp.cond != nullptr ||  // => cond known true from LockSlowLoop
  ------------------
  |  Branch (1600:14): [True: 10, False: 0]
  ------------------
 1601|      0|             EvalConditionAnnotated(&cond, this, true, false, how == kShared);
  ------------------
  |  Branch (1601:14): [True: 0, False: 0]
  ------------------
 1602|     10|  ABSL_TSAN_MUTEX_POST_LOCK(this, TsanFlags(how), 0);
 1603|     10|  ABSL_RAW_CHECK(res || t.has_timeout(),
  ------------------
  |  |   60|     10|  do {                                                                 \
  |  |   61|     10|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     10|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 10]
  |  |  |  |  |  Branch (190:49): [Folded, False: 10]
  |  |  |  |  |  Branch (190:59): [True: 10, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     10|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 10]
  |  |  ------------------
  ------------------
 1604|     10|                 "condition untrue on return from Await");
 1605|     10|  return res;
 1606|     10|}
_ZN4absl12lts_202605265Mutex6unlockEv:
 1708|   199k|void Mutex::unlock() {
 1709|   199k|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
 1710|   199k|  DebugOnlyLockLeave(this);
 1711|   199k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1712|       |
 1713|   199k|  if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) {
  ------------------
  |  Branch (1713:7): [Folded, False: 199k]
  |  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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241: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|   199k|  bool should_try_cas = ((v & (kMuEvent | kMuWriter)) == kMuWriter &&
  ------------------
  |  Branch (1720:26): [True: 199k, False: 0]
  ------------------
 1721|   199k|                         (v & (kMuWait | kMuDesig)) != kMuWait);
  ------------------
  |  Branch (1721:26): [True: 199k, False: 12]
  ------------------
 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|   199k|  static_assert(kMuEvent > kMuWait, "Needed for should_try_cas_fast");
 1740|   199k|  static_assert(kMuEvent > kMuDesig, "Needed for should_try_cas_fast");
 1741|   199k|  static_assert(kMuWriter > kMuWait, "Needed for should_try_cas_fast");
 1742|   199k|  static_assert(kMuWriter > kMuDesig, "Needed for should_try_cas_fast");
 1743|       |
 1744|   199k|  bool should_try_cas_fast =
 1745|   199k|      ((v ^ (kMuWriter | kMuDesig)) &
 1746|   199k|       (kMuEvent | kMuWriter | kMuWait | kMuDesig)) < (kMuWait | kMuDesig);
 1747|       |
 1748|   199k|  if (kDebugMode && should_try_cas != should_try_cas_fast) {
  ------------------
  |  Branch (1748:7): [Folded, False: 199k]
  |  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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241: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|   199k|  if (should_try_cas_fast &&
  ------------------
  |  Branch (1756:7): [True: 199k, False: 12]
  ------------------
 1757|   199k|      mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
  ------------------
  |  Branch (1757:7): [True: 199k, False: 0]
  ------------------
 1758|   199k|                                  std::memory_order_release,
 1759|   199k|                                  std::memory_order_relaxed)) {
 1760|       |    // fast writer release (writer with no waiters or with designated waker)
 1761|   199k|  } else {
 1762|     12|    this->UnlockSlow(nullptr /*no waitp*/);  // take slow path
 1763|     12|  }
 1764|   199k|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
 1765|   199k|}
_ZN4absl12lts_202605265Mutex13unlock_sharedEv:
 1778|   612k|void Mutex::unlock_shared() {
 1779|   612k|  ABSL_TSAN_MUTEX_PRE_UNLOCK(this, __tsan_mutex_read_lock);
 1780|   612k|  DebugOnlyLockLeave(this);
 1781|   612k|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1782|   612k|  assert((v & (kMuWriter | kMuReader)) == kMuReader);
 1783|   612k|  for (;;) {
 1784|   612k|    if (ABSL_PREDICT_FALSE((v & (kMuReader | kMuWait | kMuEvent)) !=
  ------------------
  |  |  190|   612k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 612k]
  |  |  |  Branch (190:49): [Folded, False: 612k]
  |  |  |  Branch (190:58): [True: 0, False: 612k]
  |  |  ------------------
  ------------------
 1785|   612k|                           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|   612k|    intptr_t clear = ExactlyOneReader(v) ? kMuReader | kMuOne : kMuOne;
  ------------------
  |  Branch (1790:22): [True: 612k, False: 0]
  ------------------
 1791|   612k|    if (ABSL_PREDICT_TRUE(
  ------------------
  |  |  191|   612k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 612k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 612k]
  |  |  |  Branch (191:57): [True: 612k, False: 0]
  |  |  ------------------
  ------------------
 1792|   612k|            mu_.compare_exchange_strong(v, v - clear, std::memory_order_release,
 1793|   612k|                                        std::memory_order_relaxed))) {
 1794|   612k|      break;
 1795|   612k|    }
 1796|   612k|  }
 1797|   612k|  ABSL_TSAN_MUTEX_POST_UNLOCK(this, __tsan_mutex_read_lock);
 1798|   612k|}
_ZN4absl12lts_202605265Mutex8LockSlowEPKNS0_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(
  ------------------
  |  |  190|      5|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1, False: 4]
  |  |  |  Branch (190:49): [Folded, False: 5]
  |  |  |  Branch (190: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))) {                            \
  |  |  ------------------
  |  |  |  |  190|      5|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 5]
  |  |  |  |  |  Branch (190:49): [Folded, False: 5]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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_202605265Mutex20LockSlowWithDeadlineEPKNS0_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_202605265Mutex12LockSlowLoopEPNS0_15SynchWaitParamsEi:
 1995|     15|void Mutex::LockSlowLoop(SynchWaitParams* waitp, int flags) {
 1996|     15|  SchedulingGuard::ScopedDisable disable_rescheduling;
 1997|     15|  int c = 0;
 1998|     15|  intptr_t v = mu_.load(std::memory_order_relaxed);
 1999|     15|  if ((v & kMuEvent) != 0) {
  ------------------
  |  Branch (1999:7): [True: 0, False: 15]
  ------------------
 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|     15|  ABSL_RAW_CHECK(
  ------------------
  |  |   60|     15|  do {                                                                 \
  |  |   61|     15|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     15|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 15]
  |  |  |  |  |  Branch (190:49): [Folded, False: 15]
  |  |  |  |  |  Branch (190:59): [True: 15, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     15|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 15]
  |  |  ------------------
  ------------------
 2004|     15|      waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
 2005|     15|      "detected illegal recursion into Mutex code");
 2006|  10.8k|  for (;;) {
 2007|  10.8k|    v = mu_.load(std::memory_order_relaxed);
 2008|  10.8k|    CheckForMutexCorruption(v, "Lock");
 2009|  10.8k|    if ((v & waitp->how->slow_need_zero) == 0) {
  ------------------
  |  Branch (2009:9): [True: 15, False: 10.7k]
  ------------------
 2010|     15|      if (mu_.compare_exchange_strong(
  ------------------
  |  Branch (2010:11): [True: 15, False: 0]
  ------------------
 2011|     15|              v,
 2012|     15|              (waitp->how->fast_or |
 2013|     15|               (v & ClearDesignatedWakerMask(flags & kMuHasBlocked))) +
 2014|     15|                  waitp->how->fast_add,
 2015|     15|              std::memory_order_acquire, std::memory_order_relaxed)) {
 2016|     15|        if (waitp->cond == nullptr ||
  ------------------
  |  Branch (2016:13): [True: 5, False: 10]
  ------------------
 2017|     10|            EvalConditionAnnotated(waitp->cond, this, true, false,
  ------------------
  |  Branch (2017:13): [True: 10, False: 0]
  ------------------
 2018|     15|                                   waitp->how == kShared)) {
 2019|     15|          break;  // we timed out, or condition true, so return
 2020|     15|        }
 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.7k|    } else {  // need to access waiter list
 2027|  10.7k|      bool dowait = false;
 2028|  10.7k|      if ((v & (kMuSpin | kMuWait)) == 0) {  // no waiters
  ------------------
  |  Branch (2028:11): [True: 2, False: 10.7k]
  ------------------
 2029|       |        // This thread tries to become the one and only waiter.
 2030|      2|        PerThreadSynch* new_h = Enqueue(nullptr, waitp, v, flags);
 2031|      2|        intptr_t nv =
 2032|      2|            (v & ClearDesignatedWakerMask(flags & kMuHasBlocked) & kMuLow) |
 2033|      2|            kMuWait;
 2034|      2|        ABSL_RAW_CHECK(new_h != nullptr, "Enqueue to empty list failed");
  ------------------
  |  |   60|      2|  do {                                                                 \
  |  |   61|      2|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      2|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
 2035|      2|        if (waitp->how == kExclusive && (v & kMuReader) != 0) {
  ------------------
  |  Branch (2035:13): [True: 2, False: 0]
  |  Branch (2035:41): [True: 0, False: 2]
  ------------------
 2036|      0|          nv |= kMuWrWait;
 2037|      0|        }
 2038|      2|        if (mu_.compare_exchange_strong(
  ------------------
  |  Branch (2038:13): [True: 2, False: 0]
  ------------------
 2039|      2|                v, reinterpret_cast<intptr_t>(new_h) | nv,
 2040|      2|                std::memory_order_release, std::memory_order_relaxed)) {
 2041|      2|          dowait = true;
 2042|      2|        } else {  // attempted Enqueue() failed
 2043|       |          // zero out the waitp field set by Enqueue()
 2044|      0|          waitp->thread->waitp = nullptr;
 2045|      0|        }
 2046|  10.7k|      } else if ((v & waitp->how->slow_inc_need_zero &
  ------------------
  |  Branch (2046:18): [True: 0, False: 10.7k]
  ------------------
 2047|  10.7k|                  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.7k|      } else if ((v & kMuSpin) == 0 &&  // attempt to queue ourselves
  ------------------
  |  Branch (2072:18): [True: 0, False: 10.7k]
  ------------------
 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))) {                            \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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.7k|      if (dowait) {
  ------------------
  |  Branch (2094:11): [True: 2, False: 10.7k]
  ------------------
 2095|      2|        this->Block(waitp->thread);  // wait until removed from list or timeout
 2096|      2|        flags |= kMuHasBlocked;
 2097|      2|        c = 0;
 2098|      2|      }
 2099|  10.7k|    }
 2100|  10.7k|    ABSL_RAW_CHECK(
  ------------------
  |  |   60|  10.7k|  do {                                                                 \
  |  |   61|  10.7k|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|  10.7k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 10.7k]
  |  |  |  |  |  Branch (190:49): [Folded, False: 10.7k]
  |  |  |  |  |  Branch (190:59): [True: 10.7k, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|  10.7k|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 10.7k]
  |  |  ------------------
  ------------------
 2101|  10.7k|        waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
 2102|  10.7k|        "detected illegal recursion into Mutex code");
 2103|       |    // delay, then try again
 2104|  10.7k|    c = synchronization_internal::MutexDelay(c, GENTLE);
 2105|  10.7k|  }
 2106|     15|  ABSL_RAW_CHECK(
  ------------------
  |  |   60|     15|  do {                                                                 \
  |  |   61|     15|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     15|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 15]
  |  |  |  |  |  Branch (190:49): [Folded, False: 15]
  |  |  |  |  |  Branch (190:59): [True: 15, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     15|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 15]
  |  |  ------------------
  ------------------
 2107|     15|      waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
 2108|     15|      "detected illegal recursion into Mutex code");
 2109|     15|  if ((v & kMuEvent) != 0) {
  ------------------
  |  Branch (2109:7): [True: 0, False: 15]
  ------------------
 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|     15|}
_ZN4absl12lts_202605265Mutex10UnlockSlowEPNS0_15SynchWaitParamsE:
 2121|     22|ABSL_ATTRIBUTE_NOINLINE void Mutex::UnlockSlow(SynchWaitParams* waitp) {
 2122|     22|  SchedulingGuard::ScopedDisable disable_rescheduling;
 2123|     22|  intptr_t v = mu_.load(std::memory_order_relaxed);
 2124|     22|  this->AssertReaderHeld();
 2125|     22|  CheckForMutexCorruption(v, "Unlock");
 2126|     22|  if ((v & kMuEvent) != 0) {
  ------------------
  |  Branch (2126:7): [True: 0, False: 22]
  ------------------
 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|     22|  int c = 0;
 2131|       |  // the waiter under consideration to wake, or zero
 2132|     22|  PerThreadSynch* w = nullptr;
 2133|       |  // the predecessor to w or zero
 2134|     22|  PerThreadSynch* pw = nullptr;
 2135|       |  // head of the list searched previously, or zero
 2136|     22|  PerThreadSynch* old_h = nullptr;
 2137|       |  // a condition that's known to be false.
 2138|     22|  PerThreadSynch* wake_list = kPerThreadSynchNull;  // list of threads to wake
 2139|     22|  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|       |  // When non-null, clear its "woken_has_waiters" field before returning.
 2143|     22|  absl::base_internal::ThreadIdentity* clear_waking_des_waker = nullptr;
 2144|     22|  ABSL_RAW_CHECK(waitp == nullptr || waitp->thread->waitp == nullptr ||
  ------------------
  |  |   60|     22|  do {                                                                 \
  |  |   61|     22|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     54|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 22]
  |  |  |  |  |  Branch (190:49): [Folded, False: 22]
  |  |  |  |  |  Branch (190:59): [True: 12, False: 10]
  |  |  |  |  |  Branch (190:59): [True: 10, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     22|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 22]
  |  |  ------------------
  ------------------
 2145|     22|                     waitp->thread->suppress_fatal_errors,
 2146|     22|                 "detected illegal recursion into Mutex code");
 2147|       |  // This loop finds threads wake_list to wakeup if any, and removes them from
 2148|       |  // the list of waiters.  In addition, it places waitp.thread on the queue of
 2149|       |  // waiters if waitp is non-zero.
 2150|     32|  for (;;) {
 2151|     32|    v = mu_.load(std::memory_order_relaxed);
 2152|     32|    if ((v & kMuWriter) != 0 && (v & (kMuWait | kMuDesig)) != kMuWait &&
  ------------------
  |  Branch (2152:9): [True: 32, False: 0]
  |  Branch (2152:33): [True: 10, False: 22]
  ------------------
 2153|     10|        waitp == nullptr) {
  ------------------
  |  Branch (2153:9): [True: 0, False: 10]
  ------------------
 2154|       |      // fast writer release (writer with no waiters or with designated waker)
 2155|      0|      if (mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
  ------------------
  |  Branch (2155:11): [True: 0, False: 0]
  ------------------
 2156|      0|                                      std::memory_order_release,
 2157|      0|                                      std::memory_order_relaxed)) {
 2158|      0|        return;
 2159|      0|      }
 2160|     32|    } else if ((v & (kMuReader | kMuWait)) == kMuReader && waitp == nullptr) {
  ------------------
  |  Branch (2160:16): [True: 0, False: 32]
  |  Branch (2160:60): [True: 0, False: 0]
  ------------------
 2161|       |      // fast reader release (reader with no waiters)
 2162|      0|      intptr_t clear = ExactlyOneReader(v) ? kMuReader | kMuOne : kMuOne;
  ------------------
  |  Branch (2162:24): [True: 0, False: 0]
  ------------------
 2163|      0|      if (mu_.compare_exchange_strong(v, v - clear, std::memory_order_release,
  ------------------
  |  Branch (2163:11): [True: 0, False: 0]
  ------------------
 2164|      0|                                      std::memory_order_relaxed)) {
 2165|      0|        return;
 2166|      0|      }
 2167|     32|    } else if ((v & kMuSpin) == 0 &&  // attempt to get spinlock
  ------------------
  |  Branch (2167:16): [True: 32, False: 0]
  ------------------
 2168|     32|               mu_.compare_exchange_strong(v, v | kMuSpin,
  ------------------
  |  Branch (2168:16): [True: 32, False: 0]
  ------------------
 2169|     32|                                           std::memory_order_acquire,
 2170|     32|                                           std::memory_order_relaxed)) {
 2171|     32|      if ((v & kMuWait) == 0) {  // no one to wake
  ------------------
  |  Branch (2171:11): [True: 10, False: 22]
  ------------------
 2172|     10|        intptr_t nv;
 2173|     10|        bool do_enqueue = true;  // always Enqueue() the first time
 2174|     10|        ABSL_RAW_CHECK(waitp != nullptr,
  ------------------
  |  |   60|     10|  do {                                                                 \
  |  |   61|     10|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     10|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 10]
  |  |  |  |  |  Branch (190:49): [Folded, False: 10]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     10|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 10]
  |  |  ------------------
  ------------------
 2175|     10|                       "UnlockSlow is confused");  // about to sleep
 2176|     10|        do {  // must loop to release spinlock as reader count may change
 2177|     10|          v = mu_.load(std::memory_order_relaxed);
 2178|       |          // decrement reader count if there are readers
 2179|     10|          intptr_t new_readers = (v >= kMuOne) ? v - kMuOne : v;
  ------------------
  |  Branch (2179:34): [True: 0, False: 10]
  ------------------
 2180|     10|          PerThreadSynch* new_h = nullptr;
 2181|     10|          if (do_enqueue) {
  ------------------
  |  Branch (2181:15): [True: 10, False: 0]
  ------------------
 2182|       |            // If we are enqueuing on a CondVar (waitp->cv_word != nullptr) then
 2183|       |            // we must not retry here.  The initial attempt will always have
 2184|       |            // succeeded, further attempts would enqueue us against *this due to
 2185|       |            // Fer() handling.
 2186|     10|            do_enqueue = (waitp->cv_word == nullptr);
 2187|     10|            new_h = Enqueue(nullptr, waitp, new_readers, kMuIsCond);
 2188|     10|          }
 2189|     10|          intptr_t clear = kMuWrWait | kMuWriter;  // by default clear write bit
 2190|     10|          if ((v & kMuWriter) == 0 && ExactlyOneReader(v)) {  // last reader
  ------------------
  |  Branch (2190:15): [True: 0, False: 10]
  |  Branch (2190:39): [True: 0, False: 0]
  ------------------
 2191|      0|            clear = kMuWrWait | kMuReader;                    // clear read bit
 2192|      0|          }
 2193|     10|          nv = (v & kMuLow & ~clear & ~kMuSpin);
 2194|     10|          if (new_h != nullptr) {
  ------------------
  |  Branch (2194:15): [True: 10, False: 0]
  ------------------
 2195|     10|            nv |= kMuWait | reinterpret_cast<intptr_t>(new_h);
 2196|     10|          } else {  // new_h could be nullptr if we queued ourselves on a
 2197|       |                    // CondVar
 2198|       |            // In that case, we must place the reader count back in the mutex
 2199|       |            // word, as Enqueue() did not store it in the new waiter.
 2200|      0|            nv |= new_readers & kMuHigh;
 2201|      0|          }
 2202|       |          // release spinlock & our lock; retry if reader-count changed
 2203|       |          // (writer count cannot change since we hold lock)
 2204|     10|        } while (!mu_.compare_exchange_weak(v, nv, std::memory_order_release,
  ------------------
  |  Branch (2204:18): [True: 0, False: 10]
  ------------------
 2205|     10|                                            std::memory_order_relaxed));
 2206|     10|        break;
 2207|     10|      }
 2208|       |
 2209|       |      // There are waiters.
 2210|       |      // Set h to the head of the circular waiter list.
 2211|     22|      PerThreadSynch* h = GetPerThreadSynch(v);
 2212|     22|      if ((v & kMuReader) != 0 && (h->readers & kMuHigh) > kMuOne) {
  ------------------
  |  Branch (2212:11): [True: 0, False: 22]
  |  Branch (2212:35): [True: 0, False: 0]
  ------------------
 2213|       |        // a reader but not the last
 2214|      0|        h->readers -= kMuOne;    // release our lock
 2215|      0|        intptr_t nv = v;         // normally just release spinlock
 2216|      0|        if (waitp != nullptr) {  // but waitp!=nullptr => must queue ourselves
  ------------------
  |  Branch (2216:13): [True: 0, False: 0]
  ------------------
 2217|      0|          PerThreadSynch* new_h = Enqueue(h, waitp, v, kMuIsCond);
 2218|      0|          ABSL_RAW_CHECK(new_h != nullptr,
  ------------------
  |  |   60|      0|  do {                                                                 \
  |  |   61|      0|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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]
  |  |  ------------------
  ------------------
 2219|      0|                         "waiters disappeared during Enqueue()!");
 2220|      0|          nv &= kMuLow;
 2221|      0|          nv |= kMuWait | reinterpret_cast<intptr_t>(new_h);
 2222|      0|        }
 2223|      0|        mu_.store(nv, std::memory_order_release);  // release spinlock
 2224|       |        // can release with a store because there were waiters
 2225|      0|        break;
 2226|      0|      }
 2227|       |
 2228|       |      // Either we didn't search before, or we marked the queue
 2229|       |      // as "maybe_unlocking" and no one else should have changed it.
 2230|     22|      ABSL_RAW_CHECK(old_h == nullptr || h->maybe_unlocking,
  ------------------
  |  |   60|     22|  do {                                                                 \
  |  |   61|     22|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     32|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 22]
  |  |  |  |  |  Branch (190:49): [Folded, False: 22]
  |  |  |  |  |  Branch (190:59): [True: 12, False: 10]
  |  |  |  |  |  Branch (190:59): [True: 10, 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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     22|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 22]
  |  |  ------------------
  ------------------
 2231|     22|                     "Mutex queue changed beneath us");
 2232|       |
 2233|       |      // The lock is becoming free, and there's a waiter
 2234|     22|      if (old_h != nullptr &&
  ------------------
  |  Branch (2234:11): [True: 10, False: 12]
  ------------------
 2235|     10|          !old_h->may_skip) {    // we used old_h as a terminator
  ------------------
  |  Branch (2235:11): [True: 10, False: 0]
  ------------------
 2236|     10|        old_h->may_skip = true;  // allow old_h to skip once more
 2237|     10|        ABSL_RAW_CHECK(old_h->skip == nullptr, "illegal skip from head");
  ------------------
  |  |   60|     10|  do {                                                                 \
  |  |   61|     10|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     10|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 10]
  |  |  |  |  |  Branch (190:49): [Folded, False: 10]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     10|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 10]
  |  |  ------------------
  ------------------
 2238|     10|        if (h != old_h && MuEquivalentWaiter(old_h, old_h->next)) {
  ------------------
  |  Branch (2238:13): [True: 0, False: 10]
  |  Branch (2238:27): [True: 0, False: 0]
  ------------------
 2239|      0|          old_h->skip = old_h->next;  // old_h not head & can skip to successor
 2240|      0|        }
 2241|     10|      }
 2242|     22|      if (h->next->waitp->how == kExclusive &&
  ------------------
  |  Branch (2242:11): [True: 22, False: 0]
  ------------------
 2243|     22|          h->next->waitp->cond == nullptr) {
  ------------------
  |  Branch (2243:11): [True: 2, False: 20]
  ------------------
 2244|       |        // easy case: writer with no condition; no need to search
 2245|      2|        pw = h;  // wake w, the successor of h (=pw)
 2246|      2|        w = h->next;
 2247|      2|        w->wake = true;
 2248|       |        // We are waking up a writer.  This writer may be racing against
 2249|       |        // an already awake reader for the lock.  We want the
 2250|       |        // writer to usually win this race,
 2251|       |        // because if it doesn't, we can potentially keep taking a reader
 2252|       |        // perpetually and writers will starve.  Worse than
 2253|       |        // that, this can also starve other readers if kMuWrWait gets set
 2254|       |        // later.
 2255|      2|        wr_wait = kMuWrWait;
 2256|     20|      } else if (w != nullptr && (w->waitp->how == kExclusive || h == old_h)) {
  ------------------
  |  Branch (2256:18): [True: 10, False: 10]
  |  Branch (2256:35): [True: 10, False: 0]
  |  Branch (2256:66): [True: 0, False: 0]
  ------------------
 2257|       |        // we found a waiter w to wake on a previous iteration and either it's
 2258|       |        // a writer, or we've searched the entire list so we have all the
 2259|       |        // readers.
 2260|     10|        if (pw == nullptr) {  // if w's predecessor is unknown, it must be h
  ------------------
  |  Branch (2260:13): [True: 10, False: 0]
  ------------------
 2261|     10|          pw = h;
 2262|     10|        }
 2263|     10|      } else {
 2264|       |        // At this point we don't know all the waiters to wake, and the first
 2265|       |        // waiter has a condition or is a reader.  We avoid searching over
 2266|       |        // waiters we've searched on previous iterations by starting at
 2267|       |        // old_h if it's set.  If old_h==h, there's no one to wakeup at all.
 2268|     10|        if (old_h == h) {  // we've searched before, and nothing's new
  ------------------
  |  Branch (2268:13): [True: 0, False: 10]
  ------------------
 2269|       |                           // so there's no one to wake.
 2270|      0|          intptr_t nv = (v & ~(kMuReader | kMuWriter | kMuWrWait));
 2271|      0|          h->readers = 0;
 2272|      0|          h->maybe_unlocking = false;  // finished unlocking
 2273|      0|          if (waitp != nullptr) {      // we must queue ourselves and sleep
  ------------------
  |  Branch (2273:15): [True: 0, False: 0]
  ------------------
 2274|      0|            PerThreadSynch* new_h = Enqueue(h, waitp, v, kMuIsCond);
 2275|      0|            nv &= kMuLow;
 2276|      0|            if (new_h != nullptr) {
  ------------------
  |  Branch (2276:17): [True: 0, False: 0]
  ------------------
 2277|      0|              nv |= kMuWait | reinterpret_cast<intptr_t>(new_h);
 2278|      0|            }  // else new_h could be nullptr if we queued ourselves on a
 2279|       |               // CondVar
 2280|      0|          }
 2281|       |          // release spinlock & lock
 2282|       |          // can release with a store because there were waiters
 2283|      0|          mu_.store(nv, std::memory_order_release);
 2284|      0|          break;
 2285|      0|        }
 2286|       |
 2287|       |        // set up to walk the list
 2288|     10|        PerThreadSynch* w_walk;   // current waiter during list walk
 2289|     10|        PerThreadSynch* pw_walk;  // previous waiter during list walk
 2290|     10|        if (old_h != nullptr) {   // we've searched up to old_h before
  ------------------
  |  Branch (2290:13): [True: 0, False: 10]
  ------------------
 2291|      0|          pw_walk = old_h;
 2292|      0|          w_walk = old_h->next;
 2293|     10|        } else {  // no prior search, start at beginning
 2294|     10|          pw_walk =
 2295|     10|              nullptr;  // h->next's predecessor may change; don't record it
 2296|     10|          w_walk = h->next;
 2297|     10|        }
 2298|       |
 2299|     10|        h->may_skip = false;  // ensure we never skip past h in future searches
 2300|       |                              // even if other waiters are queued after it.
 2301|     10|        ABSL_RAW_CHECK(h->skip == nullptr, "illegal skip from head");
  ------------------
  |  |   60|     10|  do {                                                                 \
  |  |   61|     10|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     10|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 10]
  |  |  |  |  |  Branch (190:49): [Folded, False: 10]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 10]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     10|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 10]
  |  |  ------------------
  ------------------
 2302|       |
 2303|     10|        h->maybe_unlocking = true;  // we're about to scan the waiter list
 2304|       |                                    // without the spinlock held.
 2305|       |                                    // Enqueue must be conservative about
 2306|       |                                    // priority queuing.
 2307|       |
 2308|       |        // We must release the spinlock to evaluate the conditions.
 2309|     10|        mu_.store(v, std::memory_order_release);  // release just spinlock
 2310|       |        // can release with a store because there were waiters
 2311|       |
 2312|       |        // h is the last waiter queued, and w_walk the first unsearched waiter.
 2313|       |        // Without the spinlock, the locations mu_ and h->next may now change
 2314|       |        // underneath us, but since we hold the lock itself, the only legal
 2315|       |        // change is to add waiters between h and w_walk.  Therefore, it's safe
 2316|       |        // to walk the path from w_walk to h inclusive. (TryRemove() can remove
 2317|       |        // a waiter anywhere, but it acquires both the spinlock and the Mutex)
 2318|       |
 2319|     10|        old_h = h;  // remember we searched to here
 2320|       |
 2321|       |        // Walk the path upto and including h looking for waiters we can wake.
 2322|     10|        while (pw_walk != h) {
  ------------------
  |  Branch (2322:16): [True: 10, False: 0]
  ------------------
 2323|     10|          w_walk->wake = false;
 2324|     10|          if (w_walk->waitp->cond ==
  ------------------
  |  Branch (2324:15): [True: 0, False: 10]
  ------------------
 2325|     10|                  nullptr ||  // no condition => vacuously true OR
 2326|       |                              // this thread's condition is true
 2327|     10|              EvalConditionIgnored(this, w_walk->waitp->cond)) {
  ------------------
  |  Branch (2327:15): [True: 10, False: 0]
  ------------------
 2328|     10|            if (w == nullptr) {
  ------------------
  |  Branch (2328:17): [True: 10, False: 0]
  ------------------
 2329|     10|              w_walk->wake = true;  // can wake this waiter
 2330|     10|              w = w_walk;
 2331|     10|              pw = pw_walk;
 2332|     10|              if (w_walk->waitp->how == kExclusive) {
  ------------------
  |  Branch (2332:19): [True: 10, False: 0]
  ------------------
 2333|     10|                wr_wait = kMuWrWait;
 2334|     10|                break;  // bail if waking this writer
 2335|     10|              }
 2336|     10|            } else if (w_walk->waitp->how == kShared) {  // wake if a reader
  ------------------
  |  Branch (2336:24): [True: 0, False: 0]
  ------------------
 2337|      0|              w_walk->wake = true;
 2338|      0|            } else {  // writer with true condition
 2339|      0|              wr_wait = kMuWrWait;
 2340|      0|            }
 2341|     10|          }
 2342|      0|          if (w_walk->wake) {  // we're waking reader w_walk
  ------------------
  |  Branch (2342:15): [True: 0, False: 0]
  ------------------
 2343|      0|            pw_walk = w_walk;  // don't skip similar waiters
 2344|      0|          } else {             // not waking; skip as much as possible
 2345|      0|            pw_walk = Skip(w_walk);
 2346|      0|          }
 2347|       |          // If pw_walk == h, then load of pw_walk->next can race with
 2348|       |          // concurrent write in Enqueue(). However, at the same time
 2349|       |          // we do not need to do the load, because we will bail out
 2350|       |          // from the loop anyway.
 2351|      0|          if (pw_walk != h) {
  ------------------
  |  Branch (2351:15): [True: 0, False: 0]
  ------------------
 2352|      0|            w_walk = pw_walk->next;
 2353|      0|          }
 2354|      0|        }
 2355|       |
 2356|     10|        continue;  // restart for(;;)-loop to wakeup w or to find more waiters
 2357|     10|      }
 2358|     12|      ABSL_RAW_CHECK(pw->next == w, "pw not w's predecessor");
  ------------------
  |  |   60|     12|  do {                                                                 \
  |  |   61|     12|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     12|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 12]
  |  |  |  |  |  Branch (190:49): [Folded, False: 12]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 12]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     12|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 12]
  |  |  ------------------
  ------------------
 2359|       |      // The first (and perhaps only) waiter we've chosen to wake is w, whose
 2360|       |      // predecessor is pw.  If w is a reader, we must wake all the other
 2361|       |      // waiters with wake==true as well.  We may also need to queue
 2362|       |      // ourselves if waitp != null.  The spinlock and the lock are still
 2363|       |      // held.
 2364|       |
 2365|       |      // This traverses the list in [ pw->next, h ], where h is the head,
 2366|       |      // removing all elements with wake==true and placing them in the
 2367|       |      // singly-linked list wake_list.  Returns the new head.
 2368|     12|      h = DequeueAllWakeable(h, pw, &wake_list);
 2369|       |
 2370|     12|      intptr_t nv = (v & kMuEvent) | kMuDesig;
 2371|       |      // assume no waiters left,
 2372|       |      // set kMuDesig for INV1a
 2373|       |
 2374|     12|      if (waitp != nullptr) {  // we must queue ourselves and sleep
  ------------------
  |  Branch (2374:11): [True: 0, False: 12]
  ------------------
 2375|      0|        h = Enqueue(h, waitp, v, kMuIsCond);
 2376|       |        // h is new last waiter; could be null if we queued ourselves on a
 2377|       |        // CondVar
 2378|      0|      }
 2379|       |
 2380|     12|      ABSL_RAW_CHECK(wake_list != kPerThreadSynchNull,
  ------------------
  |  |   60|     12|  do {                                                                 \
  |  |   61|     12|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     12|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 12]
  |  |  |  |  |  Branch (190:49): [Folded, False: 12]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 12]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     12|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 12]
  |  |  ------------------
  ------------------
 2381|     12|                     "unexpected empty wake list");
 2382|       |
 2383|     12|      if (h != nullptr) {  // there are waiters left
  ------------------
  |  Branch (2383:11): [True: 0, False: 12]
  ------------------
 2384|      0|        h->readers = 0;
 2385|      0|        h->maybe_unlocking = false;  // finished unlocking
 2386|      0|        nv |= wr_wait | kMuWait | reinterpret_cast<intptr_t>(h);
 2387|       |
 2388|       |        // Signal to any Scheduler that we are waking from Mutex Unlock
 2389|       |        // and there are more waiters left, signaling possible contention.
 2390|      0|        ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
 2391|      0|        clear_waking_des_waker = GetOrCreateCurrentThreadIdentity();
 2392|      0|        ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
 2393|      0|        clear_waking_des_waker->scheduler_state.waking_designated_waker = true;
 2394|      0|      }
 2395|       |
 2396|       |      // release both spinlock & lock
 2397|       |      // can release with a store because there were waiters
 2398|     12|      mu_.store(nv, std::memory_order_release);
 2399|     12|      break;  // out of for(;;)-loop
 2400|     12|    }
 2401|       |    // aggressive here; no one can proceed till we do
 2402|      0|    c = synchronization_internal::MutexDelay(c, AGGRESSIVE);
 2403|      0|  }  // end of for(;;)-loop
 2404|       |
 2405|     22|  if (wake_list != kPerThreadSynchNull) {
  ------------------
  |  Branch (2405:7): [True: 12, False: 10]
  ------------------
 2406|     12|    int64_t total_wait_cycles = 0;
 2407|     12|    int64_t max_wait_cycles = 0;
 2408|     12|    int64_t now = CycleClock::Now();
 2409|     12|    do {
 2410|       |      // Profile lock contention events only if the waiter was trying to acquire
 2411|       |      // the lock, not waiting on a condition variable or Condition.
 2412|     12|      if (!wake_list->cond_waiter) {
  ------------------
  |  Branch (2412:11): [True: 2, False: 10]
  ------------------
 2413|      2|        int64_t cycles_waited =
 2414|      2|            (now - wake_list->waitp->contention_start_cycles);
 2415|      2|        total_wait_cycles += cycles_waited;
 2416|      2|        if (max_wait_cycles == 0) max_wait_cycles = cycles_waited;
  ------------------
  |  Branch (2416:13): [True: 2, False: 0]
  ------------------
 2417|      2|        wake_list->waitp->contention_start_cycles = now;
 2418|      2|        wake_list->waitp->should_submit_contention_data = true;
 2419|      2|      }
 2420|     12|      wake_list = Wakeup(wake_list);  // wake waiters
 2421|     12|    } while (wake_list != kPerThreadSynchNull);
  ------------------
  |  Branch (2421:14): [True: 0, False: 12]
  ------------------
 2422|     12|    if (total_wait_cycles > 0) {
  ------------------
  |  Branch (2422:9): [True: 2, False: 10]
  ------------------
 2423|      2|      mutex_tracer("slow release", this, total_wait_cycles);
 2424|      2|      ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
 2425|      2|      submit_profile_data(total_wait_cycles);
 2426|      2|      ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
 2427|      2|    }
 2428|     12|  }
 2429|       |
 2430|     22|  if (clear_waking_des_waker) {
  ------------------
  |  Branch (2430:7): [True: 0, False: 22]
  ------------------
 2431|      0|    clear_waking_des_waker->scheduler_state.waking_designated_waker = false;
 2432|      0|  }
 2433|     22|}
_ZNK4absl12lts_202605265Mutex16AssertReaderHeldEv:
 2516|     22|void Mutex::AssertReaderHeld() const {
 2517|     22|  if ((mu_.load(std::memory_order_relaxed) & (kMuReader | kMuWriter)) == 0) {
  ------------------
  |  Branch (2517:7): [True: 0, False: 22]
  ------------------
 2518|      0|    SynchEvent* e = GetSynchEvent(this);
 2519|       |    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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 2520|      0|                 "thread should hold at least a read lock on Mutex %p %s",
 2521|      0|                 static_cast<const void*>(this), (e == nullptr ? "" : e->name));
 2522|      0|  }
 2523|     22|}
_ZNK4absl12lts_202605269Condition4EvalEv:
 2821|  99.6k|bool Condition::Eval() const { return (*this->eval_)(this); }
mutex.cc:_ZN4absl12lts_2026052612_GLOBAL__N_115GetMutexGlobalsEv:
  147|  21.5k|const MutexGlobals& GetMutexGlobals() {
  148|  21.5k|  absl::base_internal::LowLevelCallOnce(&globals.once, [&]() {
  149|  21.5k|    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|  21.5k|      globals.mutex_sleep_spins[AGGRESSIVE] = 5000;
  156|  21.5k|      globals.mutex_sleep_spins[GENTLE] = 250;
  157|  21.5k|      globals.mutex_sleep_time = absl::Microseconds(10);
  158|  21.5k|    } 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|  21.5k|      globals.mutex_sleep_spins[AGGRESSIVE] = 0;
  163|  21.5k|      globals.mutex_sleep_spins[GENTLE] = 0;
  164|  21.5k|      globals.mutex_sleep_time = MeasureTimeToYield() * 5;
  165|  21.5k|      globals.mutex_sleep_time =
  166|  21.5k|          std::min(globals.mutex_sleep_time, absl::Milliseconds(1));
  167|  21.5k|      globals.mutex_sleep_time =
  168|  21.5k|          std::max(globals.mutex_sleep_time, absl::Microseconds(10));
  169|  21.5k|    }
  170|  21.5k|  });
  171|  21.5k|  return globals;
  172|  21.5k|}
mutex.cc:_ZZN4absl12lts_2026052612_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_20260526L17GetPerThreadSynchEl:
  813|     22|static inline PerThreadSynch* GetPerThreadSynch(intptr_t v) {
  814|     22|  return reinterpret_cast<PerThreadSynch*>(v & kMuHigh);
  815|     22|}
mutex.cc:_ZN4absl12lts_20260526L7DequeueEPNS0_13base_internal14PerThreadSynchES3_:
 1061|     12|static PerThreadSynch* Dequeue(PerThreadSynch* head, PerThreadSynch* pw) {
 1062|     12|  PerThreadSynch* w = pw->next;
 1063|     12|  pw->next = w->next;                 // snip w out of list
 1064|     12|  if (head == w) {                    // we removed the head
  ------------------
  |  Branch (1064:7): [True: 12, False: 0]
  ------------------
 1065|     12|    head = (pw == w) ? nullptr : pw;  // either emptied list, or pw is new head
  ------------------
  |  Branch (1065:12): [True: 12, False: 0]
  ------------------
 1066|     12|  } 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|     12|  return head;
 1076|     12|}
mutex.cc:_ZN4absl12lts_20260526L22DebugOnlyDeadlockCheckEPNS0_5MutexE:
 1472|   812k|static inline GraphId DebugOnlyDeadlockCheck(Mutex* mu) {
 1473|   812k|  if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
  ------------------
  |  Branch (1473:7): [Folded, False: 812k]
  |  Branch (1473:21): [True: 0, False: 0]
  ------------------
 1474|      0|                        OnDeadlockCycle::kIgnore) {
 1475|      0|    return DeadlockCheck(mu);
 1476|   812k|  } else {
 1477|   812k|    return InvalidGraphId();
 1478|   812k|  }
 1479|   812k|}
mutex.cc:_ZN4absl12lts_20260526L22TryAcquireWithSpinningEPNSt3__16atomicIlEE:
 1514|     12|static bool TryAcquireWithSpinning(std::atomic<intptr_t>* mu) {
 1515|     12|  int c = globals.spinloop_iterations.load(std::memory_order_relaxed);
 1516|  8.23k|  do {  // do/while somewhat faster on AMD
 1517|  8.23k|    intptr_t v = mu->load(std::memory_order_relaxed);
 1518|  8.23k|    if ((v & (kMuReader | kMuEvent)) != 0) {
  ------------------
  |  Branch (1518:9): [True: 0, False: 8.23k]
  ------------------
 1519|      0|      return false;                       // a reader or tracing -> give up
 1520|  8.23k|    } else if (((v & kMuWriter) == 0) &&  // no holder -> try to acquire
  ------------------
  |  Branch (1520:16): [True: 7, False: 8.22k]
  ------------------
 1521|      7|               mu->compare_exchange_strong(v, kMuWriter | v,
  ------------------
  |  Branch (1521:16): [True: 7, False: 0]
  ------------------
 1522|      7|                                           std::memory_order_acquire,
 1523|      7|                                           std::memory_order_relaxed)) {
 1524|      7|      return true;
 1525|      7|    }
 1526|  8.23k|  } while (--c > 0);
  ------------------
  |  Branch (1526:12): [True: 8.21k, False: 5]
  ------------------
 1527|      5|  return false;
 1528|     12|}
mutex.cc:_ZN4absl12lts_20260526L18DebugOnlyLockEnterEPNS0_5MutexENS0_24synchronization_internal7GraphIdE:
 1305|   812k|static inline void DebugOnlyLockEnter(Mutex* mu, GraphId id) {
 1306|   812k|  if (kDebugMode) {
  ------------------
  |  Branch (1306:7): [Folded, False: 812k]
  ------------------
 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|   812k|}
mutex.cc:_ZN4absl12lts_20260526L27Synch_GetPerThreadAnnotatedEPNS0_5MutexE:
  560|     15|static PerThreadSynch* Synch_GetPerThreadAnnotated(Mutex* mu) {
  561|     15|  if (mu) {
  ------------------
  |  Branch (561:7): [True: 15, False: 0]
  ------------------
  562|     15|    ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
  563|     15|  }
  564|     15|  PerThreadSynch* w = Synch_GetPerThread();
  565|     15|  if (mu) {
  ------------------
  |  Branch (565:7): [True: 15, False: 0]
  ------------------
  566|     15|    ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
  567|     15|  }
  568|     15|  return w;
  569|     15|}
mutex.cc:_ZN4absl12lts_20260526L18Synch_GetPerThreadEv:
  555|     15|static PerThreadSynch* Synch_GetPerThread() {
  556|     15|  ThreadIdentity* identity = GetOrCreateCurrentThreadIdentity();
  557|     15|  return &identity->per_thread_synch;
  558|     15|}
_ZN4absl12lts_2026052615SynchWaitParamsC2EPKNS0_6MuHowSEPKNS0_9ConditionENS0_24synchronization_internal13KernelTimeoutEPNS0_5MutexEPNS0_13base_internal14PerThreadSynchEPNSt3__16atomicIlEE:
  499|     15|      : how(how_arg),
  500|     15|        cond(cond_arg),
  501|     15|        timeout(timeout_arg),
  502|     15|        cvmu(cvmu_arg),
  503|     15|        thread(thread_arg),
  504|     15|        cv_word(cv_word_arg),
  505|     15|        contention_start_cycles(CycleClock::Now()),
  506|     15|        should_submit_contention_data(false) {}
mutex.cc:_ZN4absl12lts_20260526L18DebugOnlyLockLeaveEPNS0_5MutexE:
 1315|   812k|static inline void DebugOnlyLockLeave(Mutex* mu) {
 1316|   812k|  if (kDebugMode) {
  ------------------
  |  Branch (1316:7): [Folded, False: 812k]
  ------------------
 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|   812k|}
mutex.cc:_ZN4absl12lts_20260526L16ExactlyOneReaderEl:
 1768|   612k|static bool ExactlyOneReader(intptr_t v) {
 1769|   612k|  assert((v & (kMuWriter | kMuReader)) == kMuReader);
 1770|   612k|  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|   612k|  constexpr intptr_t kMuMultipleWaitersMask = kMuHigh ^ kMuOne;
 1775|   612k|  return (v & kMuMultipleWaitersMask) == 0;
 1776|   612k|}
mutex.cc:_ZN4absl12lts_20260526L22EvalConditionAnnotatedEPKNS0_9ConditionEPNS0_5MutexEbbb:
 1855|     10|                                          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|     10|  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|     10|  if (locking) {
  ------------------
  |  Branch (1865:7): [True: 10, 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|     10|    ABSL_TSAN_MUTEX_POST_LOCK(mu, tryflags, 0);
 1873|     10|    res = cond->Eval();
 1874|       |    // There is no "try" version of Unlock, so use flags instead of tryflags.
 1875|     10|    ABSL_TSAN_MUTEX_PRE_UNLOCK(mu, flags);
 1876|     10|    ABSL_TSAN_MUTEX_POST_UNLOCK(mu, flags);
 1877|     10|    ABSL_TSAN_MUTEX_PRE_LOCK(mu, tryflags);
 1878|     10|  } 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|     10|  static_cast<void>(mu);
 1890|     10|  static_cast<void>(trylock);
 1891|     10|  static_cast<void>(read_lock);
 1892|     10|  return res;
 1893|     10|}
mutex.cc:_ZN4absl12lts_20260526L24ClearDesignatedWakerMaskEi:
 1802|     17|static intptr_t ClearDesignatedWakerMask(int flag) {
 1803|     17|  assert(flag >= 0);
 1804|     17|  assert(flag <= 1);
 1805|     17|  switch (flag) {
  ------------------
  |  Branch (1805:11): [True: 17, False: 0]
  ------------------
 1806|      5|    case 0:  // not blocked
  ------------------
  |  Branch (1806:5): [True: 5, False: 12]
  ------------------
 1807|      5|      return ~static_cast<intptr_t>(0);
 1808|     12|    case 1:  // blocked; turn off the designated waker bit
  ------------------
  |  Branch (1808:5): [True: 12, False: 5]
  ------------------
 1809|     12|      return ~static_cast<intptr_t>(kMuDesig);
 1810|     17|  }
 1811|      0|  ABSL_UNREACHABLE();
  ------------------
  |  |  237|      0|  do {                                           \
  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  ------------------
  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  ------------------
  |  |  241|      0|  } while (false)
  |  |  ------------------
  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1812|      0|}
mutex.cc:_ZN4absl12lts_20260526L23CheckForMutexCorruptionElPKc:
 1972|  10.8k|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.8k|  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.8k|  static_assert(kMuReader << 3 == kMuWriter, "must match");
 1984|  10.8k|  static_assert(kMuWait << 3 == kMuWrWait, "must match");
 1985|  10.8k|  if (ABSL_PREDICT_TRUE((w & (w << 3) & (kMuWriter | kMuWrWait)) == 0)) return;
  ------------------
  |  |  191|  10.8k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 10.8k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 10.8k]
  |  |  |  Branch (191:57): [True: 10.8k, False: 0]
  |  |  ------------------
  ------------------
 1986|      0|  RAW_CHECK_FMT((v & (kMuWriter | kMuReader)) != (kMuWriter | kMuReader),
  ------------------
  |  | 1966|      0|  do {                                                             \
  |  | 1967|      0|    if (ABSL_PREDICT_FALSE(!(cond))) {                             \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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))) {                             \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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_20260526L7EnqueueEPNS0_13base_internal14PerThreadSynchEPNS0_15SynchWaitParamsEli:
  925|     12|                               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|     12|  if (waitp->cv_word != nullptr) {
  ------------------
  |  Branch (928:7): [True: 0, False: 12]
  ------------------
  929|      0|    CondVarEnqueue(waitp);
  930|      0|    return head;
  931|      0|  }
  932|       |
  933|     12|  PerThreadSynch* s = waitp->thread;
  934|     12|  ABSL_RAW_CHECK(
  ------------------
  |  |   60|     12|  do {                                                                 \
  |  |   61|     12|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     24|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 12]
  |  |  |  |  |  Branch (190:49): [Folded, False: 12]
  |  |  |  |  |  Branch (190:59): [True: 12, False: 0]
  |  |  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     12|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 12]
  |  |  ------------------
  ------------------
  935|     12|      s->waitp == nullptr ||    // normal case
  936|     12|          s->waitp == waitp ||  // Fer()---transfer from condition variable
  937|     12|          s->suppress_fatal_errors,
  938|     12|      "detected illegal recursion into Mutex code");
  939|     12|  s->waitp = waitp;
  940|     12|  s->skip = nullptr;   // maintain skip invariant (see above)
  941|     12|  s->may_skip = true;  // always true on entering queue
  942|     12|  s->wake = false;     // not being woken
  943|     12|  s->cond_waiter = ((flags & kMuIsCond) != 0);
  944|     12|#ifdef ABSL_HAVE_PTHREAD_GETSCHEDPARAM
  945|     12|  if ((flags & kMuIsFer) == 0) {
  ------------------
  |  Branch (945:7): [True: 12, False: 0]
  ------------------
  946|     12|    assert(s == Synch_GetPerThread());
  947|     12|    int64_t now_cycles = CycleClock::Now();
  948|     12|    if (s->next_priority_read_cycles < now_cycles) {
  ------------------
  |  Branch (948:9): [True: 12, 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|     12|      int policy;
  953|     12|      struct sched_param param;
  954|     12|      const int err = pthread_getschedparam(pthread_self(), &policy, &param);
  955|     12|      if (err != 0) {
  ------------------
  |  Branch (955:11): [True: 0, False: 12]
  ------------------
  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|     12|      } else {
  958|     12|        s->priority = param.sched_priority;
  959|     12|        s->next_priority_read_cycles =
  960|     12|            now_cycles + static_cast<int64_t>(CycleClock::Frequency());
  961|     12|      }
  962|     12|    }
  963|     12|  }
  964|     12|#endif
  965|     12|  if (head == nullptr) {         // s is the only waiter
  ------------------
  |  Branch (965:7): [True: 12, False: 0]
  ------------------
  966|     12|    s->next = s;                 // it's the only entry in the cycle
  967|     12|    s->readers = mu;             // reader count is from mu word
  968|     12|    s->maybe_unlocking = false;  // no one is searching an empty list
  969|     12|    head = s;                    // s is new head
  970|     12|  } 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))) {                            \
  |  |  ------------------
  |  |  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  |  |  Branch (190:59): [True: 0, False: 0]
  |  |  |  |  |  Branch (190: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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241: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|     12|  s->state.store(PerThreadSynch::kQueued, std::memory_order_relaxed);
 1054|     12|  return head;
 1055|     12|}
mutex.cc:_ZN4absl12lts_20260526L24IgnoreWaitingWritersMaskEi:
 1816|  10.7k|static intptr_t IgnoreWaitingWritersMask(int flag) {
 1817|  10.7k|  assert(flag >= 0);
 1818|  10.7k|  assert(flag <= 1);
 1819|  10.7k|  switch (flag) {
  ------------------
  |  Branch (1819:11): [True: 10.7k, False: 0]
  ------------------
 1820|  10.7k|    case 0:  // not blocked
  ------------------
  |  Branch (1820:5): [True: 10.7k, False: 0]
  ------------------
 1821|  10.7k|      return ~static_cast<intptr_t>(0);
 1822|      0|    case 1:  // blocked; pretend there are no waiting writers
  ------------------
  |  Branch (1822:5): [True: 0, False: 10.7k]
  ------------------
 1823|      0|      return ~static_cast<intptr_t>(kMuWrWait);
 1824|  10.7k|  }
 1825|      0|  ABSL_UNREACHABLE();
  ------------------
  |  |  237|      0|  do {                                           \
  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  ------------------
  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  ------------------
  |  |  241|      0|  } while (false)
  |  |  ------------------
  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1826|      0|}
mutex.cc:_ZN4absl12lts_20260526L20EvalConditionIgnoredEPNS0_5MutexEPKNS0_9ConditionE:
 1903|     10|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|     10|  ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
 1911|     10|  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
  ------------------
  |  |  383|     10|  do {                                                \
  |  |  384|     10|    ABSL_ANNOTATE_IGNORE_READS_BEGIN();               \
  |  |  ------------------
  |  |  |  |  317|     10|  ABSL_INTERNAL_GLOBAL_SCOPED(                                      \
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|     10|#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
  |  |  |  |  ------------------
  |  |  |  |  318|     10|      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsBegin)) \
  |  |  |  |  319|     10|  ()
  |  |  ------------------
  |  |  385|     10|    ABSL_ANNOTATE_IGNORE_WRITES_BEGIN();              \
  |  |  386|     10|  } while (0)
  |  |  ------------------
  |  |  |  Branch (386:12): [Folded, False: 10]
  |  |  ------------------
  ------------------
 1912|     10|  bool res = cond->Eval();
 1913|     10|  ABSL_ANNOTATE_IGNORE_READS_AND_WRITES_END();
  ------------------
  |  |  390|     10|  do {                                              \
  |  |  391|     10|    ABSL_ANNOTATE_IGNORE_WRITES_END();              \
  |  |  392|     10|    ABSL_ANNOTATE_IGNORE_READS_END();               \
  |  |  ------------------
  |  |  |  |  322|     10|  ABSL_INTERNAL_GLOBAL_SCOPED(                                    \
  |  |  |  |  ------------------
  |  |  |  |  |  |  105|     10|#define ABSL_INTERNAL_GLOBAL_SCOPED(F) ::F
  |  |  |  |  ------------------
  |  |  |  |  323|     10|      ABSL_INTERNAL_C_SYMBOL(AbslInternalAnnotateIgnoreReadsEnd)) \
  |  |  |  |  324|     10|  ()
  |  |  ------------------
  |  |  393|     10|  } while (0)
  |  |  ------------------
  |  |  |  Branch (393:12): [Folded, False: 10]
  |  |  ------------------
  ------------------
 1914|     10|  ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
 1915|     10|  static_cast<void>(mu);  // Prevent unused param warning in non-TSAN builds.
 1916|     10|  return res;
 1917|     10|}
mutex.cc:_ZN4absl12lts_20260526L18DequeueAllWakeableEPNS0_13base_internal14PerThreadSynchES3_PS3_:
 1086|     12|                                          PerThreadSynch** wake_tail) {
 1087|     12|  PerThreadSynch* orig_h = head;
 1088|     12|  PerThreadSynch* w = pw->next;
 1089|     12|  bool skipped = false;
 1090|     12|  do {
 1091|     12|    if (w->wake) {  // remove this element
  ------------------
  |  Branch (1091:9): [True: 12, False: 0]
  ------------------
 1092|     12|      ABSL_RAW_CHECK(pw->skip == nullptr, "bad skip in DequeueAllWakeable");
  ------------------
  |  |   60|     12|  do {                                                                 \
  |  |   61|     12|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|     12|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 12]
  |  |  |  |  |  Branch (190:49): [Folded, False: 12]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 12]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|     12|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 12]
  |  |  ------------------
  ------------------
 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|     12|      head = Dequeue(head, pw);
 1097|     12|      w->next = *wake_tail;               // keep list terminated
 1098|     12|      *wake_tail = w;                     // add w to wake_list;
 1099|     12|      wake_tail = &w->next;               // next addition to end
 1100|     12|      if (w->waitp->how == kExclusive) {  // wake at most 1 writer
  ------------------
  |  Branch (1100:11): [True: 12, False: 0]
  ------------------
 1101|     12|        break;
 1102|     12|      }
 1103|     12|    } 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|     12|  return head;
 1118|     12|}

_ZN4absl12lts_2026052615ReaderMutexLockC2ERNS0_5MutexE:
  672|   612k|      : mu_(mu) {
  673|   612k|    mu.lock_shared();
  674|   612k|  }
_ZN4absl12lts_2026052615ReaderMutexLockD2Ev:
  698|   612k|  ~ReaderMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_.unlock_shared(); }
_ZN4absl12lts_2026052615WriterMutexLockC2ERNS0_5MutexE:
  712|      1|      : mu_(mu) {
  713|      1|    mu.lock();
  714|      1|  }
_ZN4absl12lts_2026052615WriterMutexLockD2Ev:
  740|      1|  ~WriterMutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_.unlock(); }

_ZN4absl12lts_202605263NowEv:
   39|  2.38M|Time Now() {
   40|       |  // TODO(bww): Get a timespec instead so we don't have to divide.
   41|  2.38M|  int64_t n = absl::GetCurrentTimeNanos();
   42|  2.38M|  if (n >= 0) {
  ------------------
  |  Branch (42:7): [True: 2.38M, False: 0]
  ------------------
   43|  2.38M|    return time_internal::FromUnixDuration(
   44|  2.38M|        time_internal::MakeDuration(n / 1000000000, n % 1000000000 * 4));
   45|  2.38M|  }
   46|      0|  return time_internal::FromUnixDuration(absl::Nanoseconds(n));
   47|  2.38M|}
_ZN4absl12lts_2026052619GetCurrentTimeNanosEv:
   77|  2.38M|int64_t GetCurrentTimeNanos() { return GET_CURRENT_TIME_NANOS_FROM_SYSTEM(); }
  ------------------
  |  |   71|  2.38M|  ::absl::time_internal::GetCurrentTimeNanosFromSystem()
  ------------------
AbslInternalSleepFor_lts_20260526:
  595|     42|    absl::Duration duration) {
  596|     84|  while (duration > absl::ZeroDuration()) {
  ------------------
  |  Branch (596:10): [True: 42, False: 42]
  ------------------
  597|     42|    absl::Duration to_sleep = std::min(duration, absl::MaxSleep());
  598|     42|    absl::SleepOnce(to_sleep);
  599|     42|    duration -= to_sleep;
  600|     42|  }
  601|     42|}
clock.cc:_ZN4absl12lts_2026052612_GLOBAL__N_18MaxSleepEv:
  565|     42|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|     42|  return absl::Seconds(std::numeric_limits<time_t>::max());
  572|     42|#endif
  573|     42|}
clock.cc:_ZN4absl12lts_2026052612_GLOBAL__N_19SleepOnceENS0_8DurationE:
  577|     42|void SleepOnce(absl::Duration to_sleep) {
  578|       |#ifdef _WIN32
  579|       |  Sleep(static_cast<DWORD>(to_sleep / absl::Milliseconds(1)));
  580|       |#else
  581|     42|  struct timespec sleep_time = absl::ToTimespec(to_sleep);
  582|     42|  while (nanosleep(&sleep_time, &sleep_time) != 0 && errno == EINTR) {
  ------------------
  |  Branch (582:10): [True: 0, False: 42]
  |  Branch (582:54): [True: 0, False: 0]
  ------------------
  583|       |    // Ignore signals and wait for the full interval to elapse.
  584|      0|  }
  585|     42|#endif
  586|     42|}

_ZN4absl12lts_202605268SleepForENS0_8DurationE:
   77|     42|inline void absl::SleepFor(absl::Duration duration) {
   78|     42|  ABSL_INTERNAL_C_SYMBOL(AbslInternalSleepFor)(duration);
  ------------------
  |  |  187|     42|  ABSL_INTERNAL_C_SYMBOL_HELPER_1(x, ABSL_OPTION_INLINE_NAMESPACE_NAME)
  |  |  ------------------
  |  |  |  |  185|     42|  ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v)
  |  |  |  |  ------------------
  |  |  |  |  |  |  183|     42|#define ABSL_INTERNAL_C_SYMBOL_HELPER_2(x, v) x##_##v
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   79|     42|}

_ZN4absl12lts_202605268DurationmIES1_:
  436|     42|Duration& Duration::operator-=(Duration rhs) {
  437|     42|  if (time_internal::IsInfiniteDuration(*this)) return *this;
  ------------------
  |  Branch (437:7): [True: 0, False: 42]
  ------------------
  438|     42|  if (time_internal::IsInfiniteDuration(rhs)) {
  ------------------
  |  Branch (438:7): [True: 0, False: 42]
  ------------------
  439|      0|    return *this = rhs.rep_hi_.Get() >= 0 ? -InfiniteDuration()
  ------------------
  |  Branch (439:20): [True: 0, False: 0]
  ------------------
  440|      0|                                          : InfiniteDuration();
  441|      0|  }
  442|     42|  const int64_t orig_rep_hi = rep_hi_.Get();
  443|     42|  rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_.Get()) -
  444|     42|                           EncodeTwosComp(rhs.rep_hi_.Get()));
  445|     42|  if (rep_lo_ < rhs.rep_lo_) {
  ------------------
  |  Branch (445:7): [True: 0, False: 42]
  ------------------
  446|      0|    rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_.Get()) - 1);
  447|      0|    rep_lo_ += kTicksPerSecond;
  448|      0|  }
  449|     42|  rep_lo_ -= rhs.rep_lo_;
  450|     42|  if (rhs.rep_hi_.Get() < 0 ? rep_hi_.Get() < orig_rep_hi
  ------------------
  |  Branch (450:7): [True: 0, False: 42]
  |  Branch (450:7): [True: 0, False: 42]
  ------------------
  451|     42|                            : 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|     42|  return *this;
  456|     42|}
_ZN4absl12lts_2026052610ToTimespecENS0_8DurationE:
  569|     42|timespec ToTimespec(Duration d) {
  570|     42|  timespec ts;
  571|     42|  if (!time_internal::IsInfiniteDuration(d)) {
  ------------------
  |  Branch (571:7): [True: 42, False: 0]
  ------------------
  572|     42|    int64_t rep_hi = time_internal::GetRepHi(d);
  573|     42|    uint32_t rep_lo = time_internal::GetRepLo(d);
  574|     42|    if (rep_hi < 0) {
  ------------------
  |  Branch (574:9): [True: 0, False: 42]
  ------------------
  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|     42|    ts.tv_sec = static_cast<decltype(ts.tv_sec)>(rep_hi);
  584|     42|    if (ts.tv_sec == rep_hi) {  // no time_t narrowing
  ------------------
  |  Branch (584:9): [True: 42, False: 0]
  ------------------
  585|     42|      ts.tv_nsec = rep_lo / kTicksPerNanosecond;
  586|     42|      return ts;
  587|     42|    }
  588|     42|  }
  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|     42|}
duration.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114DecodeTwosCompEm:
  187|     42|inline int64_t DecodeTwosComp(uint64_t v) { return absl::bit_cast<int64_t>(v); }
duration.cc:_ZN4absl12lts_2026052612_GLOBAL__N_114EncodeTwosCompEl:
  184|     84|inline uint64_t EncodeTwosComp(int64_t v) {
  185|     84|  return absl::bit_cast<uint64_t>(v);
  186|     84|}

clock.cc:_ZN4absl12lts_2026052613time_internalL29GetCurrentTimeNanosFromSystemEv:
   13|  2.38M|static int64_t GetCurrentTimeNanosFromSystem() {
   14|  2.38M|  const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
   15|  2.38M|  struct timespec ts;
   16|  2.38M|  ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0,
  ------------------
  |  |   60|  2.38M|  do {                                                                 \
  |  |   61|  2.38M|    if (ABSL_PREDICT_FALSE(!(condition))) {                            \
  |  |  ------------------
  |  |  |  |  190|  2.38M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (190:31): [True: 0, False: 2.38M]
  |  |  |  |  |  Branch (190:49): [Folded, False: 2.38M]
  |  |  |  |  |  Branch (190:58): [True: 0, False: 2.38M]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   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()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   52|      0|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   63|      0|    }                                                                  \
  |  |   64|  2.38M|  } while (0)
  |  |  ------------------
  |  |  |  Branch (64:12): [Folded, False: 2.38M]
  |  |  ------------------
  ------------------
   17|  2.38M|                 "Failed to read real-time clock.");
   18|  2.38M|  return (int64_t{ts.tv_sec} * kNanosPerSecond +
   19|  2.38M|          int64_t{ts.tv_nsec});
   20|  2.38M|}

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

_ZN4absl12lts_202605268DurationC2Ev:
  186|   625k|  constexpr Duration() : rep_hi_(0), rep_lo_(0) {}  // zero-length duration
_ZN4absl12lts_2026052612MicrosecondsIiTnNSt3__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_202605264TimeC2ENS0_8DurationE:
  878|  2.38M|  constexpr explicit Time(Duration rep) : rep_(rep) {}
_ZN4absl12lts_2026052613time_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_2026052613time_internal9FromInt64ILl1EEENS0_8DurationElNSt3__15ratioILl1EXT_EEE:
 1672|     42|                                                           std::ratio<1, N>) {
 1673|     42|  static_assert(0 < N && N <= 1000 * 1000 * 1000, "Unsupported ratio");
 1674|       |  // Subsecond ratios cannot overflow.
 1675|     42|  return MakeNormalizedDuration(
 1676|     42|      v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N);
 1677|     42|}
_ZN4absl12lts_202605267SecondsIlTnNSt3__19enable_ifIXoosr3std11is_integralIT_EE5valuesr3std7is_enumIS4_EE5valueEiE4typeELi0EEENS0_8DurationES4_:
  551|     42|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration Seconds(T n) {
  552|     42|  return time_internal::FromInt64(n, std::ratio<1>{});
  553|     42|}
_ZN4absl12lts_20260526gtENS0_8DurationES1_:
  337|     84|                                                       Duration rhs) {
  338|     84|  return rhs < lhs;
  339|     84|}
_ZN4absl12lts_2026052612ZeroDurationEv:
  438|     84|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ZeroDuration() {
  439|     84|  return Duration();
  440|     84|}
_ZN4absl12lts_2026052613time_internal18IsInfiniteDurationENS0_8DurationE:
 1638|   612k|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr bool IsInfiniteDuration(Duration d) {
 1639|   612k|  return GetRepLo(d) == ~uint32_t{0};
 1640|   612k|}
_ZN4absl12lts_2026052613time_internal16FromUnixDurationENS0_8DurationE:
 1663|  2.38M|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Time FromUnixDuration(Duration d) {
 1664|  2.38M|  return Time(d);
 1665|  2.38M|}
_ZN4absl12lts_2026052613time_internal14ToUnixDurationENS0_4TimeE:
 1666|  1.22M|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr Duration ToUnixDuration(Time t) {
 1667|  1.22M|  return t.rep_;
 1668|  1.22M|}
_ZN4absl12lts_20260526ltENS0_8DurationES1_:
 1760|    126|                                                       Duration rhs) {
 1761|    126|  return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
  ------------------
  |  Branch (1761:10): [True: 42, False: 84]
  ------------------
 1762|    126|             ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
 1763|    126|         : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)()
  ------------------
  |  Branch (1763:12): [True: 0, False: 84]
  ------------------
 1764|     84|             ? time_internal::GetRepLo(lhs) + 1 <
 1765|      0|                   time_internal::GetRepLo(rhs) + 1
 1766|     84|             : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs);
 1767|    126|}
_ZN4absl12lts_202605264TimeC2Ev:
  803|   612k|  constexpr Time() = default;

_ZN4absl12lts_2026052613span_internal11GetDataImplIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEDTcldtfp_4dataEERT_c:
   38|  1.44M|    -> decltype(c.data()) {
   39|  1.44M|  return c.data();
   40|  1.44M|}
_ZN4absl12lts_2026052613span_internal7GetDataIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|  1.44M|    -> decltype(GetDataImpl(c, 0)) {
   51|  1.44M|  return GetDataImpl(c, 0);
   52|  1.44M|}
_ZN4absl12lts_2026052613span_internal7GetDataINSt3__15arrayIcLm15000EEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|  1.83M|    -> decltype(GetDataImpl(c, 0)) {
   51|  1.83M|  return GetDataImpl(c, 0);
   52|  1.83M|}
_ZN4absl12lts_2026052613span_internal11GetDataImplINSt3__15arrayIcLm15000EEEEEDTcldtfp_4dataEERT_c:
   38|  1.83M|    -> decltype(c.data()) {
   39|  1.83M|  return c.data();
   40|  1.83M|}
_ZN4absl12lts_2026052613span_internal7GetDataIKNS0_4SpanIcEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|   612k|    -> decltype(GetDataImpl(c, 0)) {
   51|   612k|  return GetDataImpl(c, 0);
   52|   612k|}
_ZN4absl12lts_2026052613span_internal11GetDataImplIKNS0_4SpanIcEEEEDTcldtfp_4dataEERT_c:
   38|   612k|    -> decltype(c.data()) {
   39|   612k|  return c.data();
   40|   612k|}
_ZN4absl12lts_2026052613span_internal7GetDataINS0_13InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS5_EEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|   612k|    -> decltype(GetDataImpl(c, 0)) {
   51|   612k|  return GetDataImpl(c, 0);
   52|   612k|}
_ZN4absl12lts_2026052613span_internal11GetDataImplINS0_13InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS5_EEEEEEDTcldtfp_4dataEERT_c:
   38|   612k|    -> decltype(c.data()) {
   39|   612k|  return c.data();
   40|   612k|}
_ZN4absl12lts_2026052613span_internal7GetDataIKNS0_4SpanIjEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|      8|    -> decltype(GetDataImpl(c, 0)) {
   51|      8|  return GetDataImpl(c, 0);
   52|      8|}
_ZN4absl12lts_2026052613span_internal11GetDataImplIKNS0_4SpanIjEEEEDTcldtfp_4dataEERT_c:
   38|      8|    -> decltype(c.data()) {
   39|      8|  return c.data();
   40|      8|}
_ZN4absl12lts_2026052613span_internal7GetDataINSt3__16vectorIPNS0_7LogSinkENS3_9allocatorIS6_EEEEEEDTcl11GetDataImplfp_Li0EEERT_:
   50|   612k|    -> decltype(GetDataImpl(c, 0)) {
   51|   612k|  return GetDataImpl(c, 0);
   52|   612k|}
_ZN4absl12lts_2026052613span_internal11GetDataImplINSt3__16vectorIPNS0_7LogSinkENS3_9allocatorIS6_EEEEEEDTcldtfp_4dataEERT_c:
   38|   612k|    -> decltype(c.data()) {
   39|   612k|  return c.data();
   40|   612k|}

_ZNK4absl12lts_2026052612optional_refINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEE9has_valueEv:
  132|  12.6k|  constexpr bool has_value() const { return ptr_ != nullptr; }
_ZNK4absl12lts_2026052612optional_refINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEE8value_orIRKNS2_12basic_stringIcS5_NS2_9allocatorIcEEEEEES6_OT_:
  151|     11|  constexpr T value_or(U&& default_value) const {
  152|       |    // Instantiate std::optional<T>::value_or(U) to trigger its static_asserts.
  153|     11|    if (false) {
  ------------------
  |  Branch (153:9): [Folded, False: 11]
  ------------------
  154|       |      // We use `std::add_const_t` here since just using `const` makes MSVC
  155|       |      // complain about the syntax.
  156|      0|      (void)std::add_const_t<std::optional<T>>{}.value_or(
  157|      0|          std::forward<U>(default_value));
  158|      0|    }
  159|     11|    return ptr_ != nullptr ? *ptr_
  ------------------
  |  Branch (159:12): [True: 0, False: 11]
  ------------------
  160|     11|                           : static_cast<T>(std::forward<U>(default_value));
  161|     11|  }
_ZN4absl12lts_2026052612optional_refINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEEC2ENS2_9nullopt_tE:
   89|  12.6k|      : ptr_(nullptr) {}

_ZNK4absl12lts_2026052614SourceLocation9file_nameEv:
  133|  12.6k|  constexpr const char* absl_nonnull file_name() const noexcept {
  134|  12.6k|    return file_name_;
  135|  12.6k|  }

_ZNK4absl12lts_202605264SpanIKNS0_19str_format_internal13FormatArgImplEE4sizeEv:
  323|  4.91M|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202605264SpanIcE4sizeEv:
  323|  59.2M|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202605264SpanIcE4dataEv:
  318|  23.1M|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202605264SpanIcE7subspanEmm:
  467|  1.93M|  constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
  468|  1.93M|    return (pos <= size()) ? Span(data() + pos, (std::min)(size() - pos, len))
  ------------------
  |  Branch (468:12): [True: 1.93M, False: 0]
  ------------------
  469|  1.93M|                           : (ThrowStdOutOfRange("pos > size()"), Span());
  470|  1.93M|  }
_ZNK4absl12lts_202605264SpanIKcE4dataEv:
  318|  6.98M|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202605264SpanIKcE4sizeEv:
  323|  92.9M|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202605264SpanIjE4dataEv:
  318|  2.52k|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202605264SpanIjE5beginEv:
  375|  1.25k|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202605264SpanIjE4sizeEv:
  323|  1.27k|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202605264SpanIjE3endEv:
  388|  1.25k|  constexpr iterator end() const noexcept { return data() + size(); }
_ZN4absl12lts_202605264SpanIKcEC2INSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEvS9_TnNS5_9enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKSB_:
  269|  1.44M|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202605264SpanIKcEC2EPS2_m:
  230|  7.99M|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202605264SpanIKcEC2Ev:
  227|  2.30M|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZN4absl12lts_202605264SpanIcEC2Ev:
  227|  1.10M|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZN4absl12lts_202605264SpanIcEC2EPcm:
  230|  4.88M|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202605268MakeSpanITpTnRiJENSt3__15arrayIcLm15000EEEEENS3_9enable_ifIXntsr13span_internal6IsViewIT0_EE5valueEDTclsr4abslE8MakeSpanclsr13span_internalE7GetDatafp_Ecldtfp_4sizeEEEE4typeERS7_:
  758|  1.22M|                                                c.size()))> {
  759|  1.22M|  return MakeSpan(span_internal::GetData(c), c.size());
  760|  1.22M|}
_ZN4absl12lts_202605268MakeSpanITpTnRiJEcEENS0_4SpanIT0_EEPS4_m:
  734|  1.22M|                           size_t size) noexcept {
  735|  1.22M|  return Span<T>(ptr, size);
  736|  1.22M|}
_ZN4absl12lts_202605264SpanIKcEC2INS1_IcEEvS5_TnNSt3__19enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKS8_:
  269|   612k|      : Span(span_internal::GetData(v), v.size()) {}
_ZNK4absl12lts_202605264SpanIKcE5emptyEv:
  333|  7.16M|  constexpr bool empty() const noexcept { return size() == 0; }
_ZN4absl12lts_202605268MakeSpanITpTnRiJENS0_13InlinedVectorIPNS0_7LogSinkELm16ENSt3__19allocatorIS5_EEEEEENS6_9enable_ifIXntsr13span_internal6IsViewIT0_EE5valueEDTclsr4abslE8MakeSpanclsr13span_internalE7GetDatafp_Ecldtfp_4sizeEEEE4typeERSB_:
  758|   612k|                                                c.size()))> {
  759|   612k|  return MakeSpan(span_internal::GetData(c), c.size());
  760|   612k|}
_ZN4absl12lts_202605268MakeSpanITpTnRiJEPNS0_7LogSinkEEENS0_4SpanIT0_EEPS6_m:
  734|  1.22M|                           size_t size) noexcept {
  735|  1.22M|  return Span<T>(ptr, size);
  736|  1.22M|}
_ZN4absl12lts_202605264SpanIPNS0_7LogSinkEEC2EPS3_m:
  230|  1.22M|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202605264SpanIcE13remove_prefixEm:
  432|  16.3M|  void remove_prefix(size_type n) noexcept {
  433|  16.3M|    absl::base_internal::HardeningAssertGE(size(), n);
  434|  16.3M|    ptr_ += n;
  435|  16.3M|    len_ -= n;
  436|  16.3M|  }
_ZN4absl12lts_202605264SpanIcEC2INSt3__15arrayIcLm15000EEEvS6_iEERT_:
  246|   612k|      : Span(span_internal::GetData(v), v.size()) {}
_ZN4absl12lts_202605264SpanIcE13remove_suffixEm:
  441|   612k|  void remove_suffix(size_type n) noexcept {
  442|   612k|    absl::base_internal::HardeningAssertGE(size(), n);
  443|   612k|    len_ -= n;
  444|   612k|  }
_ZNK4absl12lts_202605264SpanIcEixEm:
  338|  18.9M|  constexpr reference operator[](size_type i) const noexcept {
  339|  18.9M|    absl::base_internal::HardeningAssertLT(i, size());
  340|  18.9M|    return ptr_[i];
  341|  18.9M|  }
_ZNK4absl12lts_202605264SpanIKcEixEm:
  338|  34.1M|  constexpr reference operator[](size_type i) const noexcept {
  339|  34.1M|    absl::base_internal::HardeningAssertLT(i, size());
  340|  34.1M|    return ptr_[i];
  341|  34.1M|  }
_ZNK4absl12lts_202605264SpanIKcE7subspanEmm:
  467|  2.77M|  constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
  468|  2.77M|    return (pos <= size()) ? Span(data() + pos, (std::min)(size() - pos, len))
  ------------------
  |  Branch (468:12): [True: 2.77M, False: 0]
  ------------------
  469|  2.77M|                           : (ThrowStdOutOfRange("pos > size()"), Span());
  470|  2.77M|  }
_ZN4absl12lts_202605264SpanIKcE13remove_prefixEm:
  432|  13.2M|  void remove_prefix(size_type n) noexcept {
  433|  13.2M|    absl::base_internal::HardeningAssertGE(size(), n);
  434|  13.2M|    ptr_ += n;
  435|  13.2M|    len_ -= n;
  436|  13.2M|  }
_ZN4absl12lts_202605268MakeSpanITpTnRiJEjLm512EEENS0_4SpanIT0_EERAT1__S4_:
  764|      1|    T (&array ABSL_ATTRIBUTE_LIFETIME_BOUND)[N]) noexcept {
  765|      1|  return Span<T>(array, N);
  766|      1|}
_ZNK4absl12lts_202605264SpanIKjE5beginEv:
  375|  1.26k|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202605264SpanIKjE4dataEv:
  318|  2.53k|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202605264SpanIKjE3endEv:
  388|  1.26k|  constexpr iterator end() const noexcept { return data() + size(); }
_ZNK4absl12lts_202605264SpanIKjE4sizeEv:
  323|  1.26k|  constexpr size_type size() const noexcept { return len_; }
_ZN4absl12lts_202605268MakeSpanITpTnRiJEjEENS0_4SpanIT0_EEPS4_m:
  734|      9|                           size_t size) noexcept {
  735|      9|  return Span<T>(ptr, size);
  736|      9|}
_ZN4absl12lts_202605264SpanIKjEC2INS1_IjEEvS5_TnNSt3__19enable_ifIXsr6IsViewIT_EE5valueEiE4typeELi0EEERKS8_:
  269|      8|      : Span(span_internal::GetData(v), v.size()) {}
_ZNK4absl12lts_202605264SpanIjE5emptyEv:
  333|      2|  constexpr bool empty() const noexcept { return size() == 0; }
_ZN4absl12lts_202605264SpanINS0_14SourceLocationEEC2Ev:
  227|     33|  constexpr Span() noexcept : Span(nullptr, 0) {}
_ZN4absl12lts_202605264SpanINS0_14SourceLocationEEC2EPS2_m:
  230|     55|      : ptr_(array), len_(length) {}
_ZNK4absl12lts_202605264SpanINS0_14SourceLocationEE4dataEv:
  318|     33|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202605264SpanINS0_14SourceLocationEE4sizeEv:
  323|     33|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202605264SpanIKNS0_19str_format_internal13FormatArgImplEEixEm:
  338|  2.45M|  constexpr reference operator[](size_type i) const noexcept {
  339|  2.45M|    absl::base_internal::HardeningAssertLT(i, size());
  340|  2.45M|    return ptr_[i];
  341|  2.45M|  }
_ZNK4absl12lts_202605264SpanIPNS0_7LogSinkEE5beginEv:
  375|  1.22M|  constexpr iterator begin() const noexcept { return data(); }
_ZNK4absl12lts_202605264SpanIPNS0_7LogSinkEE4dataEv:
  318|  2.45M|  constexpr pointer data() const noexcept { return ptr_; }
_ZNK4absl12lts_202605264SpanIPNS0_7LogSinkEE3endEv:
  388|  1.22M|  constexpr iterator end() const noexcept { return data() + size(); }
_ZNK4absl12lts_202605264SpanIPNS0_7LogSinkEE4sizeEv:
  323|  1.22M|  constexpr size_type size() const noexcept { return len_; }
_ZN4absl12lts_202605268MakeSpanITpTnRiJENSt3__16vectorIPNS0_7LogSinkENS3_9allocatorIS6_EEEEEENS3_9enable_ifIXntsr13span_internal6IsViewIT0_EE5valueEDTclsr4abslE8MakeSpanclsr13span_internalE7GetDatafp_Ecldtfp_4sizeEEEE4typeERSB_:
  758|   612k|                                                c.size()))> {
  759|   612k|  return MakeSpan(span_internal::GetData(c), c.size());
  760|   612k|}

_ZN4absl12lts_2026052613little_endian8ToHost64Em:
  110|  93.5k|inline uint64_t ToHost64(uint64_t x) { return x; }

_ZN4absl12lts_2026052613base_internal17HardeningAssertLTImEEvT_S3_:
   88|  55.5M|constexpr void HardeningAssertLT(T val1, T val2) {
   89|  55.5M|  ABSL_ASSERT(val1 < val2);
  ------------------
  |  |  127|  55.5M|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|  55.5M|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 55.5M]
  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   90|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
   91|       |  if (!ABSL_PREDICT_TRUE(val1 < val2)) {
   92|       |    base_internal::HardeningAbort();
   93|       |  }
   94|       |#endif
   95|  55.5M|}
_ZN4absl12lts_2026052613base_internal15HardeningAssertEb:
   44|  4.22M|constexpr void HardeningAssert(bool cond) {
   45|  4.22M|  ABSL_ASSERT(cond);
  ------------------
  |  |  127|  4.22M|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|  4.22M|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 4.22M]
  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   46|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
   47|       |  if (ABSL_PREDICT_FALSE(!cond)) {
   48|       |    base_internal::HardeningAbort();
   49|       |  }
   50|       |#endif
   51|  4.22M|}
_ZN4absl12lts_2026052613base_internal17HardeningAssertGEIiEEvT_S3_:
   78|  3.84M|constexpr void HardeningAssertGE(T val1, T val2) {
   79|  3.84M|  ABSL_ASSERT(val1 >= val2);
  ------------------
  |  |  127|  3.84M|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|  3.84M|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 3.84M]
  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
   80|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
   81|       |  if (!ABSL_PREDICT_TRUE(val1 >= val2)) {
   82|       |    base_internal::HardeningAbort();
   83|       |  }
   84|       |#endif
   85|  3.84M|}
_ZN4absl12lts_2026052613base_internal22HardeningAssertNonNullIPNS0_18container_internal10btree_nodeINS3_15set_params_implImJEEEEEEEvT_:
  122|  3.84M|constexpr void HardeningAssertNonNull(T ptr) {
  123|  3.84M|  ABSL_ASSERT(ptr != nullptr);
  ------------------
  |  |  127|  3.84M|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|  3.84M|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 3.84M]
  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  124|       |#if (ABSL_OPTION_HARDENED == 1 || ABSL_OPTION_HARDENED == 2) && defined(NDEBUG)
  125|       |  if (ABSL_PREDICT_FALSE(ptr == nullptr)) {
  126|       |    base_internal::HardeningAbort();
  127|       |  }
  128|       |#endif
  129|  3.84M|}

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

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

_ZN4absl12lts_2026052618container_internal15set_slot_policyImE7destroyINSt3__19allocatorImEEEEvPT_Pm:
  823|  2.16M|  static void destroy(Alloc *alloc, slot_type *slot) {
  824|  2.16M|    std::allocator_traits<Alloc>::destroy(*alloc, slot);
  825|  2.16M|  }
_ZN4absl12lts_202605269btree_setImNSt3__14lessImEENS2_9allocatorImEEEC2Ev:
  164|   293k|  btree_set() {}
_ZN4absl12lts_2026052618container_internal15set_slot_policyImE7elementEPm:
  803|  27.4M|  static value_type &element(slot_type *slot) { return *slot; }
_ZN4absl12lts_2026052618container_internal15set_slot_policyImE9constructINSt3__19allocatorImEEEEvPT_PmSA_:
  813|  63.6k|  static void construct(Alloc *alloc, slot_type *slot, slot_type *other) {
  814|  63.6k|    std::allocator_traits<Alloc>::construct(*alloc, slot, std::move(*other));
  815|  63.6k|  }
_ZN4absl12lts_2026052618container_internal15set_params_implImJEE3keyEPKm:
  863|  38.5M|  static const Key &key(const slot_type *slot) { return *slot; }
_ZN4absl12lts_2026052618container_internal15set_slot_policyImE9constructINSt3__19allocatorImEEJmEEEvPT_PmDpOT0_:
  807|  2.09M|  static void construct(Alloc *alloc, slot_type *slot, Args &&...args) {
  808|  2.09M|    std::allocator_traits<Alloc>::construct(*alloc, slot,
  809|  2.09M|                                            std::forward<Args>(args)...);
  810|  2.09M|  }
_ZN4absl12lts_2026052618container_internal15set_params_implImJEE3keyImEERKT_S7_:
  860|  2.09M|  static const V &key(const V &value) {
  861|  2.09M|    return value;
  862|  2.09M|  }

_ZN4absl12lts_2026052613flat_hash_mapImPN13sentencepiece3bpe7Trainer6SymbolENS0_13hash_internal4HashImEENSt3__18equal_toImEENSA_9allocatorINSA_4pairIKmS6_EEEEEC2Ev:
  196|  1.44k|  flat_hash_map() {}
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE7destroyINSt3__19allocatorINSA_4pairIKmS7_EEEEEEDaPT_PNS1_13map_slot_typeImS7_EE:
  667|  47.5k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  668|  47.5k|    return slot_policy::destroy(alloc, slot);
  669|  47.5k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDilE7destroyINSt3__19allocatorINS5_4pairIKDilEEEEEEDaPT_PNS1_13map_slot_typeIDilEE:
  667|     83|  static auto destroy(Allocator* alloc, slot_type* slot) {
  668|     83|    return slot_policy::destroy(alloc, slot);
  669|     83|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiNSt3__14pairIblEEE7destroyINS3_9allocatorINS4_IKDiS5_EEEEEEDaPT_PNS1_13map_slot_typeIDiS5_EE:
  667|     47|  static auto destroy(Allocator* alloc, slot_type* slot) {
  668|     47|    return slot_policy::destroy(alloc, slot);
  669|     47|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE7destroyINS7_INS3_4pairIKS9_lEEEEEEDaPT_PNS1_13map_slot_typeIS9_lEE:
  667|  2.14M|  static auto destroy(Allocator* alloc, slot_type* slot) {
  668|  2.14M|    return slot_policy::destroy(alloc, slot);
  669|  2.14M|  }
_ZN4absl12lts_2026052613flat_hash_mapIDilNS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS5_9allocatorINS5_4pairIKDilEEEEEC2Ev:
  196|  8.54k|  flat_hash_map() {}
_ZN4absl12lts_2026052613flat_hash_mapIDiNSt3__14pairIblEENS0_13hash_internal4HashIDiEENS2_8equal_toIDiEENS2_9allocatorINS3_IKDiS4_EEEEEC2Ev:
  196|  8.52k|  flat_hash_map() {}
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiNSt3__14pairIblEEE5valueEPNS4_IKDiS5_EE:
  696|  8.59M|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiNSt3__14pairIblEEE7elementEPNS1_13map_slot_typeIDiS5_EE:
  694|  17.7M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiNSt3__14pairIblEEE5applyINS1_12EqualElementIDiNS3_8equal_toIDiEEEEJRNS4_IKDiS5_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSF_DpOSG_:
  680|  8.48M|  apply(F&& f, Args&&... args) {
  681|  8.48M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|  8.48M|                                                   std::forward<Args>(args)...);
  683|  8.48M|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiNSt3__14pairIblEEE8transferINS3_9allocatorINS4_IKDiS5_EEEEEEDaPT_PNS1_13map_slot_typeIDiS5_EESG_:
  673|   403k|                       slot_type* old_slot) {
  674|   403k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  675|   403k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiNSt3__14pairIblEEE5applyINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEEJRNS4_IKDiS5_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSG_DpOSH_:
  680|   328k|  apply(F&& f, Args&&... args) {
  681|   328k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|   328k|                                                   std::forward<Args>(args)...);
  683|   328k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiNSt3__14pairIblEEE9constructINS3_9allocatorINS4_IKDiS5_EEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRS9_EEENSF_IJEEEEEEvPT_PNS1_13map_slot_typeIDiS5_EEDpOT0_:
  661|   300k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|   300k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|   300k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDilE5applyINS1_12raw_hash_setIS3_JEE19EmplaceDecomposableEJRKDiRKlEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSC_DpOSD_:
  680|   272k|  apply(F&& f, Args&&... args) {
  681|   272k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|   272k|                                                   std::forward<Args>(args)...);
  683|   272k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDilE5applyINS1_12EqualElementIDiNSt3__18equal_toIDiEEEEJRNS6_4pairIKDilEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSE_DpOSF_:
  680|  9.84M|  apply(F&& f, Args&&... args) {
  681|  9.84M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|  9.84M|                                                   std::forward<Args>(args)...);
  683|  9.84M|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDilE7elementEPNS1_13map_slot_typeIDilEE:
  694|  11.4M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDilE5applyINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEEJRNSt3__14pairIKDilEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSF_DpOSG_:
  680|   284k|  apply(F&& f, Args&&... args) {
  681|   284k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|   284k|                                                   std::forward<Args>(args)...);
  683|   284k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDilE8transferINSt3__19allocatorINS5_4pairIKDilEEEEEEDaPT_PNS1_13map_slot_typeIDilEESF_:
  673|   282k|                       slot_type* old_slot) {
  674|   282k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  675|   282k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDilE9constructINSt3__19allocatorINS5_4pairIKDilEEEEJRKNS5_21piecewise_construct_tENS5_5tupleIJRS8_EEENSE_IJRKlEEEEEEvPT_PNS1_13map_slot_typeIDilEEDpOT0_:
  661|   272k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|   272k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|   272k|  }
_ZN4absl12lts_2026052613flat_hash_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEElNS0_18container_internal10StringHashENS9_8StringEqENS6_INS2_4pairIKS8_lEEEEEC2Ev:
  196|  18.0k|  flat_hash_map() {}
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE5valueEPNS3_4pairIKS9_lEE:
  696|  13.0M|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE7elementEPNS1_13map_slot_typeIS9_lEE:
  694|  29.4M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE5applyINS1_12EqualElementINS3_17basic_string_viewIcS6_EENS1_8StringEqEEEJRNS3_4pairIKS9_lEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSL_DpOSM_:
  680|   122k|  apply(F&& f, Args&&... args) {
  681|   122k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|   122k|                                                   std::forward<Args>(args)...);
  683|   122k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE8transferINS7_INS3_4pairIKS9_lEEEEEEDaPT_PNS1_13map_slot_typeIS9_lEESK_:
  673|  3.04M|                       slot_type* old_slot) {
  674|  3.04M|    return slot_policy::transfer(alloc, new_slot, old_slot);
  675|  3.04M|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS3_4pairIKS9_lEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  680|  2.90M|  apply(F&& f, Args&&... args) {
  681|  2.90M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|  2.90M|                                                   std::forward<Args>(args)...);
  683|  2.90M|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE9constructINS7_INS3_4pairIKS9_lEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKNS3_17basic_string_viewIcS6_EEEEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_lEEDpOT0_:
  661|   193k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|   193k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|   193k|  }
_ZN4absl12lts_2026052613flat_hash_mapINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEiNS0_18container_internal10StringHashENS7_8StringEqENS2_9allocatorINS2_4pairIKS6_iEEEEEC2Ev:
  196|  11.8k|  flat_hash_map() {}
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE8transferINS7_INS3_4pairIKS9_fEEEEEEDaPT_PNS1_13map_slot_typeIS9_fEESK_:
  673|   285k|                       slot_type* old_slot) {
  674|   285k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  675|   285k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS3_4pairIKS9_fEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  680|   231k|  apply(F&& f, Args&&... args) {
  681|   231k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|   231k|                                                   std::forward<Args>(args)...);
  683|   231k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE7elementEPNS1_13map_slot_typeIS9_fEE:
  694|  1.19M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE5applyINS1_12raw_hash_setISA_JEE19EmplaceDecomposableEJRKNS3_4pairIS9_fEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  680|   233k|  apply(F&& f, Args&&... args) {
  681|   233k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|   233k|                                                   std::forward<Args>(args)...);
  683|   233k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE5applyINS1_12EqualElementIS9_NS1_8StringEqEEEJRNS3_4pairIKS9_fEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  680|   386k|  apply(F&& f, Args&&... args) {
  681|   386k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|   386k|                                                   std::forward<Args>(args)...);
  683|   386k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE9constructINS7_INS3_4pairIKS9_fEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJRKfEEEEEEvPT_PNS1_13map_slot_typeIS9_fEEDpOT0_:
  661|   233k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|   233k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|   233k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE7destroyINS7_INS3_4pairIKS9_fEEEEEEDaPT_PNS1_13map_slot_typeIS9_fEE:
  667|   457k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  668|   457k|    return slot_policy::destroy(alloc, slot);
  669|   457k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE5applyINS1_12EqualElementIS9_NS1_8StringEqEEEJRNS3_4pairIKS9_lEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  680|  11.3M|  apply(F&& f, Args&&... args) {
  681|  11.3M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|  11.3M|                                                   std::forward<Args>(args)...);
  683|  11.3M|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE9constructINS7_INS3_4pairIKS9_lEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOS9_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_lEEDpOT0_:
  661|   170k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|   170k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|   170k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE9constructINS7_INS3_4pairIKS9_lEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_lEEDpOT0_:
  661|  1.77M|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|  1.77M|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|  1.77M|  }
_ZN4absl12lts_2026052613flat_hash_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEfNS0_18container_internal10StringHashENS9_8StringEqENS6_INS2_4pairIKS8_fEEEEEC2Ev:
  196|  5.83k|  flat_hash_map() {}
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE5valueEPNS3_4pairIKS9_fEE:
  696|   356k|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE9constructINS7_INS3_4pairIKS9_fEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_fEEDpOT0_:
  661|   224k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|   224k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|   224k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE7destroyINS7_INS3_4pairIKS9_mEEEEEEDaPT_PNS1_13map_slot_typeIS9_mEE:
  667|  93.3k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  668|  93.3k|    return slot_policy::destroy(alloc, slot);
  669|  93.3k|  }
_ZN4absl12lts_2026052613flat_hash_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEmNS0_18container_internal10StringHashENS9_8StringEqENS6_INS2_4pairIKS8_mEEEEEC2Ev:
  196|    929|  flat_hash_map() {}
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE5valueEPNS3_4pairIKS9_mEE:
  696|   146k|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE7elementEPNS1_13map_slot_typeIS9_mEE:
  694|   525k|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE5applyINS1_12EqualElementINS3_17basic_string_viewIcS6_EENS1_8StringEqEEEJRNS3_4pairIKS9_mEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSL_DpOSM_:
  680|  62.7k|  apply(F&& f, Args&&... args) {
  681|  62.7k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|  62.7k|                                                   std::forward<Args>(args)...);
  683|  62.7k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE8transferINS7_INS3_4pairIKS9_mEEEEEEDaPT_PNS1_13map_slot_typeIS9_mEESK_:
  673|   138k|                       slot_type* old_slot) {
  674|   138k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  675|   138k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS3_4pairIKS9_mEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  680|   130k|  apply(F&& f, Args&&... args) {
  681|   130k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|   130k|                                                   std::forward<Args>(args)...);
  683|   130k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE9constructINS7_INS3_4pairIKS9_mEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKNS3_17basic_string_viewIcS6_EEEEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_mEEDpOT0_:
  661|  93.3k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|  93.3k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|  93.3k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE5applyINS1_12EqualElementImNSt3__18equal_toImEEEEJRNSB_4pairIKmS7_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  680|  4.23M|  apply(F&& f, Args&&... args) {
  681|  4.23M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|  4.23M|                                                   std::forward<Args>(args)...);
  683|  4.23M|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE7elementEPNS1_13map_slot_typeImS7_EE:
  694|  8.66M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE5applyINS1_12raw_hash_setIS8_JEE19EmplaceDecomposableEJRKNSt3__14pairIKmS7_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  680|   293k|  apply(F&& f, Args&&... args) {
  681|   293k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|   293k|                                                   std::forward<Args>(args)...);
  683|   293k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE5applyINS1_11HashElementINS0_13hash_internal4HashImEELb1EEEJRNSt3__14pairIKmS7_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSK_DpOSL_:
  680|   372k|  apply(F&& f, Args&&... args) {
  681|   372k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|   372k|                                                   std::forward<Args>(args)...);
  683|   372k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE8transferINSt3__19allocatorINSA_4pairIKmS7_EEEEEEDaPT_PNS1_13map_slot_typeImS7_EESK_:
  673|   370k|                       slot_type* old_slot) {
  674|   370k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  675|   370k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEE9constructINSt3__19allocatorINSA_4pairIKmS7_EEEEJRKNSA_21piecewise_construct_tENSA_5tupleIJRSD_EEENSJ_IJRKS7_EEEEEEvPT_PNS1_13map_slot_typeImS7_EEDpOT0_:
  661|   293k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|   293k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|   293k|  }
_ZN4absl12lts_2026052613flat_hash_mapIDiN13sentencepiece14unicode_script10ScriptTypeENS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS8_9allocatorINS8_4pairIKDiS4_EEEEEC2Ev:
  196|      1|  flat_hash_map() {}
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEE5valueEPNSt3__14pairIKDiS5_EE:
  696|   128k|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEE7elementEPNS1_13map_slot_typeIDiS5_EE:
  694|  78.6M|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEE5applyINS1_12EqualElementIDiNSt3__18equal_toIDiEEEEJRNS9_4pairIKDiS5_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSH_DpOSI_:
  680|  39.1M|  apply(F&& f, Args&&... args) {
  681|  39.1M|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|  39.1M|                                                   std::forward<Args>(args)...);
  683|  39.1M|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEE5applyINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEEJRNSt3__14pairIKDiS5_EEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSI_DpOSJ_:
  680|   229k|  apply(F&& f, Args&&... args) {
  681|   229k|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  682|   229k|                                                   std::forward<Args>(args)...);
  683|   229k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEE8transferINSt3__19allocatorINS8_4pairIKDiS5_EEEEEEDaPT_PNS1_13map_slot_typeIDiS5_EESI_:
  673|   229k|                       slot_type* old_slot) {
  674|   229k|    return slot_policy::transfer(alloc, new_slot, old_slot);
  675|   229k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEE9constructINSt3__19allocatorINS8_4pairIKDiS5_EEEEJRKNS8_21piecewise_construct_tENS8_5tupleIJRSB_EEENSH_IJEEEEEEvPT_PNS1_13map_slot_typeIDiS5_EEDpOT0_:
  661|   127k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|   127k|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|   127k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEE9constructINSt3__19allocatorINS8_4pairIKDiS5_EEEEJRKNS8_21piecewise_construct_tENS8_5tupleIJODiEEENSH_IJEEEEEEvPT_PNS1_13map_slot_typeIDiS5_EEDpOT0_:
  661|    697|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  662|    697|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  663|    697|  }

_ZN4absl12lts_2026052618container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE7destroyINS7_IS9_EEEEDaPT_PS9_:
  568|   990k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  569|   990k|    std::allocator_traits<Allocator>::destroy(*alloc, slot);
  570|   990k|    return IsDestructionTrivial<Allocator, slot_type>();
  571|   990k|  }
_ZN4absl12lts_2026052613flat_hash_setINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS0_18container_internal10StringHashENS9_8StringEqENS6_IS8_EEEC2Ev:
  192|  18.3k|  flat_hash_set() {}
_ZN4absl12lts_2026052618container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE5applyINS1_12raw_hash_setISA_JEE19EmplaceDecomposableEJRKS9_EEEDTclsr4absl18container_internalE14DecomposeValueclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSH_DpOSI_:
  578|   374k|  apply(F&& f, Args&&... args) {
  579|   374k|    return absl::container_internal::DecomposeValue(
  580|   374k|        std::forward<F>(f), std::forward<Args>(args)...);
  581|   374k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE5applyINS1_12EqualElementIS9_NS1_8StringEqEEEJRS9_EEEDTclsr4absl18container_internalE14DecomposeValueclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSG_DpOSH_:
  578|  38.1k|  apply(F&& f, Args&&... args) {
  579|  38.1k|    return absl::container_internal::DecomposeValue(
  580|  38.1k|        std::forward<F>(f), std::forward<Args>(args)...);
  581|  38.1k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE7elementEPS9_:
  573|  1.07M|  static T& element(slot_type* slot) { return *slot; }
_ZN4absl12lts_2026052618container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE9constructINS7_IS9_EEJS9_EEEvPT_PS9_DpOT0_:
  561|   616k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  562|   616k|    std::allocator_traits<Allocator>::construct(*alloc, slot,
  563|   616k|                                                std::forward<Args>(args)...);
  564|   616k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRS9_EEEDTclsr4absl18container_internalE14DecomposeValueclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSG_DpOSH_:
  578|   468k|  apply(F&& f, Args&&... args) {
  579|   468k|    return absl::container_internal::DecomposeValue(
  580|   468k|        std::forward<F>(f), std::forward<Args>(args)...);
  581|   468k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE9constructINS7_IS9_EEJRKS9_EEEvPT_PS9_DpOT0_:
  561|   374k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  562|   374k|    std::allocator_traits<Allocator>::construct(*alloc, slot,
  563|   374k|                                                std::forward<Args>(args)...);
  564|   374k|  }
_ZN4absl12lts_2026052618container_internal17FlatHashSetPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE5applyINS1_12raw_hash_setISA_JEE19EmplaceDecomposableEJS9_EEEDTclsr4absl18container_internalE14DecomposeValueclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSF_DpOSG_:
  578|  47.5k|  apply(F&& f, Args&&... args) {
  579|  47.5k|    return absl::container_internal::DecomposeValue(
  580|  47.5k|        std::forward<F>(f), std::forward<Args>(args)...);
  581|  47.5k|  }

_ZN4absl12lts_2026052613InlinedVectorIjLm8ENSt3__19allocatorIjEEE5beginEv:
  437|  1.25k|  iterator begin() noexcept ABSL_ATTRIBUTE_LIFETIME_BOUND { return data(); }
_ZN4absl12lts_2026052613InlinedVectorIjLm8ENSt3__19allocatorIjEEE4dataEv:
  348|  2.51k|  pointer data() noexcept ABSL_ATTRIBUTE_LIFETIME_BOUND {
  349|  2.51k|    return storage_.GetIsAllocated() ? storage_.GetAllocatedData()
  ------------------
  |  Branch (349:12): [True: 0, False: 2.51k]
  ------------------
  350|  2.51k|                                     : storage_.GetInlinedData();
  351|  2.51k|  }
_ZN4absl12lts_2026052613InlinedVectorIjLm8ENSt3__19allocatorIjEEE3endEv:
  448|  1.25k|  iterator end() noexcept ABSL_ATTRIBUTE_LIFETIME_BOUND {
  449|  1.25k|    return data() + size();
  450|  1.25k|  }
_ZNK4absl12lts_2026052613InlinedVectorIjLm8ENSt3__19allocatorIjEEE4sizeEv:
  314|  1.25k|  size_type size() const noexcept { return storage_.GetSize(); }
_ZN4absl12lts_2026052613InlinedVectorIjLm8ENSt3__19allocatorIjEEEC2Ev:
  128|  1.25k|  InlinedVector() noexcept(noexcept(allocator_type())) : storage_() {}
_ZN4absl12lts_2026052613InlinedVectorIjLm8ENSt3__19allocatorIjEEE9push_backERKj:
  753|  1.25k|  void push_back(const_reference v) { static_cast<void>(emplace_back(v)); }
_ZN4absl12lts_2026052613InlinedVectorIjLm8ENSt3__19allocatorIjEEE12emplace_backIJRKjEEERjDpOT_:
  746|  1.25k|  reference emplace_back(Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND {
  747|  1.25k|    return storage_.EmplaceBack(std::forward<Args>(args)...);
  748|  1.25k|  }
_ZN4absl12lts_2026052613InlinedVectorIjLm8ENSt3__19allocatorIjEEED2Ev:
  300|  1.25k|  ~InlinedVector() {}

_ZN4absl12lts_2026052618container_internal39btree_iterator_generation_info_disabledC2Ej:
 1094|  5.96M|  explicit btree_iterator_generation_info_disabled(uint32_t) {}
_ZN4absl12lts_2026052618container_internal39btree_iterator_generation_info_disabled17update_generationEPKv:
 1095|  5.66M|  static void update_generation(const void *) {}
_ZN4absl12lts_2026052618container_internal39btree_iterator_generation_info_disabled23assert_valid_generationEPKv:
 1097|  15.4M|  static void assert_valid_generation(const void *) {}
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE5clearEv:
 2681|   293k|void btree<P>::clear() {
 2682|   293k|  if (!empty()) {
  ------------------
  |  Branch (2682:7): [True: 228k, False: 65.0k]
  ------------------
 2683|   228k|    node_type::clear_and_delete(root(), mutable_allocator());
 2684|   228k|  }
 2685|   293k|  mutable_root() = mutable_rightmost() = EmptyNode();
 2686|   293k|  size_ = 0;
 2687|   293k|}
_ZNK4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE5emptyEv:
 1608|  2.64M|  bool empty() const { return size_ == 0; }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE10LeafLayoutEm:
  635|  1.09M|      const size_type slot_count = kNodeSlots) {
  636|  1.09M|    return leaf_layout_type(slot_count, 0);
  637|  1.09M|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8LeafSizeEm:
  639|  1.09M|  constexpr static size_type LeafSize(const size_type slot_count = kNodeSlots) {
  640|  1.09M|    return LeafLayout(slot_count).AllocSize();
  641|  1.09M|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE14InternalLayoutEv:
  638|   122M|  constexpr static auto InternalLayout() { return internal_layout_type(); }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE12InternalSizeEv:
  642|  19.0k|  constexpr static size_type InternalSize() {
  643|  19.0k|    return InternalLayout().AllocSize();
  644|  19.0k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE16clear_and_deleteEPS5_PNSt3__19allocatorImEE:
 2033|   524k|void btree_node<P>::clear_and_delete(btree_node *node, allocator_type *alloc) {
 2034|   524k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2034:7): [True: 516k, False: 8.94k]
  ------------------
 2035|   516k|    node->value_destroy_n(node->start(), node->count(), alloc);
 2036|   516k|    deallocate(LeafSize(node->max_count()), node, alloc);
 2037|   516k|    return;
 2038|   516k|  }
 2039|  8.94k|  if (node->count() == 0) {
  ------------------
  |  Branch (2039:7): [True: 4.87k, False: 4.07k]
  ------------------
 2040|  4.87k|    deallocate(InternalSize(), node, alloc);
 2041|  4.87k|    return;
 2042|  4.87k|  }
 2043|       |
 2044|       |  // The parent of the root of the subtree we are deleting.
 2045|  4.07k|  btree_node *delete_root_parent = node->parent();
 2046|       |
 2047|       |  // Navigate to the leftmost leaf under node, and then delete upwards.
 2048|  8.33k|  while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (2048:10): [True: 4.26k, False: 4.07k]
  ------------------
 2049|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2050|       |  // When generations are enabled, we delete the leftmost leaf last in case it's
 2051|       |  // the parent of the root and we need to check whether it's a leaf before we
 2052|       |  // can update the root's generation.
 2053|       |  // TODO(ezb): if we change btree_node::is_root to check a bool inside the node
 2054|       |  // instead of checking whether the parent is a leaf, we can remove this logic.
 2055|       |  btree_node *leftmost_leaf = node;
 2056|       |#endif
 2057|       |  // Use `size_type` because `pos` needs to be able to hold `kNodeSlots+1`,
 2058|       |  // which isn't guaranteed to be a valid `field_type`.
 2059|  4.07k|  size_type pos = node->position();
 2060|  4.07k|  btree_node *parent = node->parent();
 2061|  4.47k|  for (;;) {
 2062|       |    // In each iteration of the next loop, we delete one leaf node and go right.
 2063|  4.47k|    assert(pos <= parent->finish());
 2064|  29.8k|    do {
 2065|  29.8k|      node = parent->child(static_cast<field_type>(pos));
 2066|  29.8k|      if (node->is_internal()) {
  ------------------
  |  Branch (2066:11): [True: 404, False: 29.4k]
  ------------------
 2067|       |        // Navigate to the leftmost leaf under node.
 2068|    808|        while (node->is_internal()) node = node->start_child();
  ------------------
  |  Branch (2068:16): [True: 404, False: 404]
  ------------------
 2069|    404|        pos = node->position();
 2070|    404|        parent = node->parent();
 2071|    404|      }
 2072|  29.8k|      node->value_destroy_n(node->start(), node->count(), alloc);
 2073|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2074|       |      if (leftmost_leaf != node)
 2075|       |#endif
 2076|  29.8k|        deallocate(LeafSize(node->max_count()), node, alloc);
 2077|  29.8k|      ++pos;
 2078|  29.8k|    } while (pos <= parent->finish());
  ------------------
  |  Branch (2078:14): [True: 25.4k, False: 4.47k]
  ------------------
 2079|       |
 2080|       |    // Once we've deleted all children of parent, delete parent and go up/right.
 2081|  4.47k|    assert(pos > parent->finish());
 2082|  4.66k|    do {
 2083|  4.66k|      node = parent;
 2084|  4.66k|      pos = node->position();
 2085|  4.66k|      parent = node->parent();
 2086|  4.66k|      node->value_destroy_n(node->start(), node->count(), alloc);
 2087|  4.66k|      deallocate(InternalSize(), node, alloc);
 2088|  4.66k|      if (parent == delete_root_parent) {
  ------------------
  |  Branch (2088:11): [True: 4.07k, False: 593]
  ------------------
 2089|       |#ifdef ABSL_BTREE_ENABLE_GENERATIONS
 2090|       |        deallocate(LeafSize(leftmost_leaf->max_count()), leftmost_leaf, alloc);
 2091|       |#endif
 2092|  4.07k|        return;
 2093|  4.07k|      }
 2094|    593|      ++pos;
 2095|    593|    } while (pos > parent->finish());
  ------------------
  |  Branch (2095:14): [True: 189, False: 404]
  ------------------
 2096|  4.47k|  }
 2097|  4.07k|}
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE7is_leafEv:
  681|  17.2M|  bool is_leaf() const { return GetField<2>()[3] != kInternalNodeMaxCount; }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm2EEEPKNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  661|  55.3M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  662|       |    assert(N < 4 || is_internal());
  663|  55.3M|    return InternalLayout().template Pointer<N>(
  664|  55.3M|        reinterpret_cast<const char *>(this));
  665|  55.3M|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE15value_destroy_nEhhPNSt3__19allocatorImEE:
  993|   569k|                       allocator_type *alloc) {
  994|   569k|    next_generation();
  995|  1.93M|    for (slot_type *s = slot(i), *end = slot(i + n); s != end; ++s) {
  ------------------
  |  Branch (995:54): [True: 1.36M, False: 569k]
  ------------------
  996|  1.36M|      params_type::destroy(alloc, s);
  997|  1.36M|      absl::container_internal::SanitizerPoisonObject(s);
  998|  1.36M|    }
  999|   569k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE15next_generationEv:
  745|  4.92M|  void next_generation() {
  746|  4.92M|    if (BtreeGenerationsEnabled()) ++*get_root_generation();
  ------------------
  |  Branch (746:9): [Folded, False: 4.92M]
  ------------------
  747|  4.92M|  }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE7is_rootEv:
  720|   420k|  bool is_root() const { return parent()->is_leaf(); }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE4slotEm:
  668|  14.3M|  slot_type *slot(size_type i) { return &GetField<3>()[i]; }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm3EEEPNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  655|  14.3M|  inline typename layout_type::template ElementType<N> *GetField() {
  656|       |    // We assert that we don't read from values that aren't there.
  657|       |    assert(N < 4 || is_internal());
  658|  14.3M|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  659|  14.3M|  }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE5startEv:
  690|  17.4M|  field_type start() const {
  691|       |    // TODO(ezb): when floating storage is implemented, return GetField<2>()[1];
  692|       |    assert(GetField<2>()[1] == 0);
  693|  17.4M|    return 0;
  694|  17.4M|  }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE5countEv:
  700|  4.63M|  field_type count() const {
  701|       |    assert(finish() >= start());
  702|  4.63M|    return finish() - start();
  703|  4.63M|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE10deallocateEmPS5_PNSt3__19allocatorImEE:
  972|   555k|                         allocator_type *alloc) {
  973|   555k|    absl::container_internal::SanitizerUnpoisonMemoryRegion(node, size);
  974|   555k|    absl::container_internal::Deallocate<Alignment()>(alloc, node, size);
  975|   555k|  }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE9max_countEv:
  704|  2.64M|  field_type max_count() const {
  705|       |    // Internal nodes have max_count==kInternalNodeMaxCount.
  706|       |    // Leaf nodes have max_count in [1, kNodeSlots].
  707|  2.64M|    const field_type max_count = GetField<2>()[3];
  708|  2.64M|    return max_count == field_type{kInternalNodeMaxCount}
  ------------------
  |  Branch (708:12): [True: 0, False: 2.64M]
  ------------------
  709|  2.64M|               ? field_type{kNodeSlots}
  710|  2.64M|               : max_count;
  711|  2.64M|  }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE6parentEv:
  716|  5.08M|  btree_node *parent() const { return *GetField<0>(); }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm0EEEPKNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  661|  5.08M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  662|       |    assert(N < 4 || is_internal());
  663|  5.08M|    return InternalLayout().template Pointer<N>(
  664|  5.08M|        reinterpret_cast<const char *>(this));
  665|  5.08M|  }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE11is_internalEv:
  684|  5.26M|  bool is_internal() const { return !is_leaf(); }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE11start_childEv:
  758|  10.2k|  btree_node *start_child() const { return child(start()); }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8positionEv:
  687|  4.67M|  field_type position() const { return GetField<2>()[0]; }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE5childEh:
  757|  2.06M|  btree_node *child(field_type i) const { return GetField<4>()[i]; }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm4EEEPKNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  661|  2.06M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  662|       |    assert(N < 4 || is_internal());
  663|  2.06M|    return InternalLayout().template Pointer<N>(
  664|  2.06M|        reinterpret_cast<const char *>(this));
  665|  2.06M|  }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE6finishEv:
  697|  30.7M|  field_type finish() const { return GetField<2>()[2]; }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE4rootEv:
 1684|  1.72M|  node_type *root() { return root_; }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE17mutable_allocatorEv:
 1701|  4.57M|  allocator_type *mutable_allocator() noexcept {
 1702|  4.57M|    return &rightmost_.template get<1>();
 1703|  4.57M|  }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE12mutable_rootEv:
 1686|   844k|  node_type *&mutable_root() noexcept { return root_; }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE17mutable_rightmostEv:
 1689|   880k|  node_type *&mutable_rightmost() noexcept {
 1690|   880k|    return rightmost_.template get<2>();
 1691|   880k|  }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE9EmptyNodeEv:
 1365|   916k|  static node_type *EmptyNode() {
 1366|   916k|    alignas(node_type::Alignment()) static constexpr EmptyNodeType empty_node;
 1367|   916k|    return const_cast<EmptyNodeType *>(&empty_node);
 1368|   916k|  }
_ZN4absl12lts_2026052618container_internal19key_compare_adapterINSt3__14lessImEEmE15checked_compareC2ES5_:
  230|   293k|    checked_compare(Compare cmp) : Base(std::move(cmp)) {}  // NOLINT
_ZN4absl12lts_2026052618container_internal20checked_compare_baseINSt3__14lessImEELb1EEC2ES5_:
  177|   293k|  explicit checked_compare_base(Compare c) : Compare(std::move(c)) {}
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEEC2ERKNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareERKNS7_9allocatorImEE:
 1427|   293k|      : root_(EmptyNode()), rightmost_(comp, alloc, EmptyNode()), size_(0) {}
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEED2Ev:
 1450|   293k|  ~btree() {
 1451|       |    // Put static_asserts in destructor to avoid triggering them before the type
 1452|       |    // is complete.
 1453|   293k|    static_assert(static_assert_validation(), "This call must be elided.");
 1454|   293k|    clear();
 1455|   293k|  }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE5beginEv:
 1461|   380k|  iterator begin() { return iterator(leftmost()); }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE8leftmostEv:
 1697|   380k|  node_type *leftmost() { return root()->parent(); }
_ZN4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EC2EPS6_:
 1140|  2.47M|  explicit btree_iterator(Node *n) : btree_iterator(n, n->start()) {}
_ZN4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EC2EPS6_i:
 1142|  5.96M|      : btree_iterator_generation_info(n != nullptr ? n->generation()
  ------------------
  |  Branch (1142:40): [True: 5.96M, False: 0]
  ------------------
 1143|  5.96M|                                                    : ~uint32_t{}),
 1144|  5.96M|        node_(n),
 1145|  5.96M|        position_(p) {}
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE10generationEv:
  736|  6.21M|  uint32_t generation() const {
  737|  6.21M|    return BtreeGenerationsEnabled() ? *get_root_generation() : 0;
  ------------------
  |  Branch (737:12): [Folded, False: 6.21M]
  ------------------
  738|  6.21M|  }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE3endEv:
 1463|  3.34M|  iterator end() { return iterator(rightmost(), rightmost()->finish()); }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE9rightmostEv:
 1687|  6.75M|  node_type *rightmost() { return rightmost_.template get<2>(); }
_ZNK4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EneERKSA_:
 1166|  4.22M|  bool operator!=(const iterator &other) const {
 1167|  4.22M|    return !Equals(other);
 1168|  4.22M|  }
_ZNK4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E6EqualsENS2_IKS6_S8_S9_EE:
 1270|  4.22M|  bool Equals(const const_iterator other) const {
 1271|  4.22M|    absl::base_internal::HardeningAssert(
 1272|  4.22M|        ((node_ == nullptr && other.node_ == nullptr) ||
  ------------------
  |  Branch (1272:11): [True: 0, False: 4.22M]
  |  Branch (1272:31): [True: 0, False: 0]
  ------------------
 1273|  4.22M|         (node_ != nullptr && other.node_ != nullptr)) &&
  ------------------
  |  Branch (1273:11): [True: 4.22M, False: 0]
  |  Branch (1273:31): [True: 4.22M, False: 0]
  ------------------
 1274|  4.22M|        "Comparing default-constructed iterator with "
  ------------------
  |  Branch (1274:9): [True: 4.22M, Folded]
  ------------------
 1275|  4.22M|        "non-default-constructed iterator.");
 1276|       |    // Note: we use assert instead of ABSL_HARDENING_ASSERT here because this
 1277|       |    // changes the complexity of Equals from O(1) to O(log(N) + log(M)) where
 1278|       |    // N/M are sizes of the containers containing node_/other.node_.
 1279|  4.22M|    assert(AreNodesFromSameContainer(node_, other.node_) &&
 1280|  4.22M|           "Comparing iterators from different containers.");
 1281|  4.22M|    assert_valid_generation(node_);
 1282|  4.22M|    other.assert_valid_generation(other.node_);
 1283|  4.22M|    return node_ == other.node_ && position_ == other.position_;
  ------------------
  |  Branch (1283:12): [True: 1.73M, False: 2.48M]
  |  Branch (1283:36): [True: 380k, False: 1.35M]
  ------------------
 1284|  4.22M|  }
_ZN4absl12lts_2026052618container_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_:
 1156|  4.22M|      : btree_iterator_generation_info(other),
 1157|  4.22M|        node_(other.node_),
 1158|  4.22M|        position_(other.position_) {}
_ZNK4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EdeEv:
 1204|  3.84M|  reference operator*() const {
 1205|  3.84M|    absl::base_internal::HardeningAssertNonNull(node_);
 1206|  3.84M|    assert_valid_generation(node_);
 1207|  3.84M|    absl::base_internal::HardeningAssertGE(position_,
 1208|  3.84M|                                           static_cast<int>(node_->start()));
 1209|  3.84M|    if (position_ >= node_->finish()) {
  ------------------
  |  Branch (1209:9): [True: 0, False: 3.84M]
  ------------------
 1210|       |      // If this assertion fails, we have tried to dereference an end()
 1211|       |      // iterator.
 1212|      0|      absl::base_internal::HardeningAssert(!IsEndIterator());
 1213|      0|      absl::base_internal::HardeningAssertLT(position_,
 1214|      0|                                             static_cast<int>(node_->finish()));
 1215|      0|    }
 1216|  3.84M|    return node_->value(static_cast<field_type>(position_));
 1217|  3.84M|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE5valueEm:
  751|  3.84M|  reference value(size_type i) { return params_type::element(slot(i)); }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE5eraseENS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPS9_EE:
 2543|   752k|auto btree<P>::erase(iterator iter) -> iterator {
 2544|   752k|  iter.node_->value_destroy(static_cast<field_type>(iter.position_),
 2545|   752k|                            mutable_allocator());
 2546|   752k|  iter.update_generation();
 2547|       |
 2548|   752k|  const bool internal_delete = iter.node_->is_internal();
 2549|   752k|  if (internal_delete) {
  ------------------
  |  Branch (2549:7): [True: 5.19k, False: 747k]
  ------------------
 2550|       |    // Deletion of a value on an internal node. First, transfer the largest
 2551|       |    // value from our left child here, then erase/rebalance from that position.
 2552|       |    // We can get to the largest value from our left child by decrementing iter.
 2553|  5.19k|    iterator internal_iter(iter);
 2554|  5.19k|    --iter;
 2555|  5.19k|    assert(iter.node_->is_leaf());
 2556|  5.19k|    internal_iter.node_->transfer(
 2557|  5.19k|        static_cast<size_type>(internal_iter.position_),
 2558|  5.19k|        static_cast<size_type>(iter.position_), iter.node_,
 2559|  5.19k|        mutable_allocator());
 2560|   747k|  } else {
 2561|       |    // Shift values after erased position in leaf. In the internal case, we
 2562|       |    // don't need to do this because the leaf position is the end of the node.
 2563|   747k|    const field_type transfer_from =
 2564|   747k|        static_cast<field_type>(iter.position_ + 1);
 2565|   747k|    const field_type num_to_transfer = iter.node_->finish() - transfer_from;
 2566|   747k|    iter.node_->transfer_n(num_to_transfer,
 2567|   747k|                           static_cast<size_type>(iter.position_),
 2568|   747k|                           transfer_from, iter.node_, mutable_allocator());
 2569|   747k|  }
 2570|       |  // Update node finish and container size.
 2571|   752k|  iter.node_->set_finish(iter.node_->finish() - 1);
 2572|   752k|  --size_;
 2573|       |
 2574|       |  // We want to return the next value after the one we just erased. If we
 2575|       |  // erased from an internal node (internal_delete == true), then the next
 2576|       |  // value is ++(++iter). If we erased from a leaf node (internal_delete ==
 2577|       |  // false) then the next value is ++iter. Note that ++iter may point to an
 2578|       |  // internal node and the value in the internal node may move to a leaf node
 2579|       |  // (iter.node_) when rebalancing is performed at the leaf level.
 2580|       |
 2581|   752k|  iterator res = rebalance_after_delete(iter);
 2582|       |
 2583|       |  // If we erased from an internal node, advance the iterator.
 2584|   752k|  if (internal_delete) {
  ------------------
  |  Branch (2584:7): [True: 5.19k, False: 747k]
  ------------------
 2585|  5.19k|    ++res;
 2586|  5.19k|  }
 2587|   752k|  return res;
 2588|   752k|}
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE13value_destroyEhPNSt3__19allocatorImEE:
  987|   797k|  void value_destroy(const field_type i, allocator_type *alloc) {
  988|   797k|    next_generation();
  989|   797k|    params_type::destroy(alloc, slot(i));
  990|   797k|    absl::container_internal::SanitizerPoisonObject(slot(i));
  991|   797k|  }
_ZN4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E17update_generationEv:
 1329|  5.66M|  void update_generation() {
 1330|  5.66M|    btree_iterator_generation_info::update_generation(node_);
 1331|  5.66M|  }
_ZN4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EmmEv:
 1224|  5.19k|  btree_iterator &operator--() {
 1225|  5.19k|    decrement();
 1226|  5.19k|    return *this;
 1227|  5.19k|  }
_ZN4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E9decrementEv:
 1312|  5.19k|  void decrement() {
 1313|  5.19k|    assert_valid_generation(node_);
 1314|  5.19k|    if (node_->is_leaf() && --position_ >= node_->start()) {
  ------------------
  |  Branch (1314:9): [True: 0, False: 5.19k]
  |  Branch (1314:29): [True: 0, False: 0]
  ------------------
 1315|      0|      return;
 1316|      0|    }
 1317|  5.19k|    decrement_slow();
 1318|  5.19k|  }
_ZN4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E14decrement_slowEv:
 2186|  5.19k|void btree_iterator<N, R, P>::decrement_slow() {
 2187|  5.19k|  N* node = node_;
 2188|  5.19k|  int position = position_;
 2189|  5.19k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2189:7): [True: 0, False: 5.19k]
  ------------------
 2190|      0|    assert(position <= -1);
 2191|      0|    while (position < node->start() && !node->is_root()) {
  ------------------
  |  Branch (2191:12): [True: 0, False: 0]
  |  Branch (2191:40): [True: 0, False: 0]
  ------------------
 2192|      0|      assert(node->parent()->child(node->position()) == node);
 2193|      0|      position = node->position() - 1;
 2194|      0|      node = node->parent();
 2195|      0|    }
 2196|       |    // TODO(ezb): assert we aren't decrementing begin() instead of handling.
 2197|      0|    if (position < node->start()) {
  ------------------
  |  Branch (2197:9): [True: 0, False: 0]
  ------------------
 2198|      0|      return;
 2199|      0|    }
 2200|  5.19k|  } else {
 2201|  5.19k|    assert(position >= node->start());
 2202|  5.19k|    node = node->child(static_cast<field_type>(position));
 2203|  5.21k|    while (node->is_internal()) {
  ------------------
  |  Branch (2203:12): [True: 22, False: 5.19k]
  ------------------
 2204|     22|      node = node->child(node->finish());
 2205|     22|    }
 2206|  5.19k|    position = node->finish() - 1;
 2207|  5.19k|  }
 2208|  5.19k|  *this = {node, position};
 2209|  5.19k|}
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8transferEmmPS5_PNSt3__19allocatorImEE:
 1009|   168k|                btree_node *src_node, allocator_type *alloc) {
 1010|   168k|    next_generation();
 1011|   168k|    transfer(slot(dest_i), src_node->slot(src_i), alloc);
 1012|   168k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8transferEPmS6_PNSt3__19allocatorImEE:
 1001|  11.8M|  static void transfer(slot_type *dest, slot_type *src, allocator_type *alloc) {
 1002|  11.8M|    absl::container_internal::SanitizerUnpoisonObject(dest);
 1003|  11.8M|    params_type::transfer(alloc, dest, src);
 1004|  11.8M|    absl::container_internal::SanitizerPoisonObject(src);
 1005|  11.8M|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE10transfer_nEmmmPS5_PNSt3__19allocatorImEE:
 1018|  1.22M|                  allocator_type *alloc) {
 1019|  1.22M|    next_generation();
 1020|  1.22M|    for (slot_type *src = src_node->slot(src_i), *end = src + n,
 1021|  1.22M|                   *dest = slot(dest_i);
 1022|  12.8M|         src != end; ++src, ++dest) {
  ------------------
  |  Branch (1022:10): [True: 11.6M, False: 1.22M]
  ------------------
 1023|  11.6M|      transfer(dest, src, alloc);
 1024|  11.6M|    }
 1025|  1.22M|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE10set_finishEh:
  674|  4.23M|  void set_finish(field_type v) { GetField<2>()[2] = v; }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm2EEEPNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  655|  6.12M|  inline typename layout_type::template ElementType<N> *GetField() {
  656|       |    // We assert that we don't read from values that aren't there.
  657|       |    assert(N < 4 || is_internal());
  658|  6.12M|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  659|  6.12M|  }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE22rebalance_after_deleteENS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPS9_EE:
 2591|   752k|auto btree<P>::rebalance_after_delete(iterator iter) -> iterator {
 2592|       |  // Merge/rebalance as we walk back up the tree.
 2593|   752k|  iterator res(iter);
 2594|   752k|  bool first_iteration = true;
 2595|   771k|  for (;;) {
 2596|   771k|    if (iter.node_ == root()) {
  ------------------
  |  Branch (2596:9): [True: 251k, False: 519k]
  ------------------
 2597|   251k|      try_shrink();
 2598|   251k|      if (empty()) {
  ------------------
  |  Branch (2598:11): [True: 36.1k, False: 215k]
  ------------------
 2599|  36.1k|        return end();
 2600|  36.1k|      }
 2601|   215k|      break;
 2602|   251k|    }
 2603|   519k|    if (iter.node_->count() >= kMinNodeValues) {
  ------------------
  |  Branch (2603:9): [True: 415k, False: 104k]
  ------------------
 2604|   415k|      break;
 2605|   415k|    }
 2606|   104k|    bool merged = try_merge_or_rebalance(&iter);
 2607|       |    // On the first iteration, we should update `res` with `iter` because `res`
 2608|       |    // may have been invalidated.
 2609|   104k|    if (first_iteration) {
  ------------------
  |  Branch (2609:9): [True: 103k, False: 1.18k]
  ------------------
 2610|   103k|      res = iter;
 2611|   103k|      first_iteration = false;
 2612|   103k|    }
 2613|   104k|    if (!merged) {
  ------------------
  |  Branch (2613:9): [True: 85.8k, False: 18.6k]
  ------------------
 2614|  85.8k|      break;
 2615|  85.8k|    }
 2616|  18.6k|    iter.position_ = iter.node_->position();
 2617|  18.6k|    iter.node_ = iter.node_->parent();
 2618|  18.6k|  }
 2619|   716k|  res.update_generation();
 2620|       |
 2621|       |  // Adjust our return value. If we're pointing at the end of a node, advance
 2622|       |  // the iterator.
 2623|   716k|  if (res.position_ == res.node_->finish()) {
  ------------------
  |  Branch (2623:7): [True: 22.4k, False: 694k]
  ------------------
 2624|  22.4k|    res.position_ = res.node_->finish() - 1;
 2625|  22.4k|    ++res;
 2626|  22.4k|  }
 2627|       |
 2628|   716k|  return res;
 2629|   752k|}
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE10try_shrinkEv:
 2887|   251k|void btree<P>::try_shrink() {
 2888|   251k|  node_type *orig_root = root();
 2889|   251k|  if (orig_root->count() > 0) {
  ------------------
  |  Branch (2889:7): [True: 210k, False: 40.8k]
  ------------------
 2890|   210k|    return;
 2891|   210k|  }
 2892|       |  // Deleted the last item on the root node, shrink the height of the tree.
 2893|  40.8k|  if (orig_root->is_leaf()) {
  ------------------
  |  Branch (2893:7): [True: 36.1k, False: 4.66k]
  ------------------
 2894|  36.1k|    assert(size() == 0);
 2895|  36.1k|    mutable_root() = mutable_rightmost() = EmptyNode();
 2896|  36.1k|  } else {
 2897|  4.66k|    node_type *child = orig_root->start_child();
 2898|  4.66k|    child->make_root();
 2899|  4.66k|    mutable_root() = child;
 2900|  4.66k|  }
 2901|  40.8k|  node_type::clear_and_delete(orig_root, mutable_allocator());
 2902|  40.8k|}
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE9make_rootEv:
  721|  4.66k|  void make_root() {
  722|       |    assert(parent()->is_root());
  723|  4.66k|    set_generation(parent()->generation());
  724|  4.66k|    set_parent(parent()->parent());
  725|  4.66k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE14set_generationEj:
  741|   806k|  void set_generation(uint32_t generation) {
  742|   806k|    if (BtreeGenerationsEnabled()) GetField<1>()[0] = generation;
  ------------------
  |  Branch (742:9): [Folded, False: 806k]
  ------------------
  743|   806k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE10set_parentEPS5_:
  666|   585k|  void set_parent(btree_node *p) { *GetField<0>() = p; }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm0EEEPNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  655|   585k|  inline typename layout_type::template ElementType<N> *GetField() {
  656|       |    // We assert that we don't read from values that aren't there.
  657|       |    assert(N < 4 || is_internal());
  658|   585k|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  659|   585k|  }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE22try_merge_or_rebalanceEPNS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPS9_EE:
 2833|   104k|bool btree<P>::try_merge_or_rebalance(iterator *iter) {
 2834|   104k|  node_type *parent = iter->node_->parent();
 2835|   104k|  if (iter->node_->position() > parent->start()) {
  ------------------
  |  Branch (2835:7): [True: 21.0k, False: 83.4k]
  ------------------
 2836|       |    // Try merging with our left sibling.
 2837|  21.0k|    node_type *left = parent->child(iter->node_->position() - 1);
 2838|  21.0k|    assert(left->max_count() == kNodeSlots);
 2839|  21.0k|    if (1U + left->count() + iter->node_->count() <= kNodeSlots) {
  ------------------
  |  Branch (2839:9): [True: 3.04k, False: 17.9k]
  ------------------
 2840|  3.04k|      iter->position_ += 1 + left->count();
 2841|  3.04k|      merge_nodes(left, iter->node_);
 2842|  3.04k|      iter->node_ = left;
 2843|  3.04k|      return true;
 2844|  3.04k|    }
 2845|  21.0k|  }
 2846|   101k|  if (iter->node_->position() < parent->finish()) {
  ------------------
  |  Branch (2846:7): [True: 99.0k, False: 2.39k]
  ------------------
 2847|       |    // Try merging with our right sibling.
 2848|  99.0k|    node_type *right = parent->child(iter->node_->position() + 1);
 2849|  99.0k|    assert(right->max_count() == kNodeSlots);
 2850|  99.0k|    if (1U + iter->node_->count() + right->count() <= kNodeSlots) {
  ------------------
  |  Branch (2850:9): [True: 15.6k, False: 83.4k]
  ------------------
 2851|  15.6k|      merge_nodes(iter->node_, right);
 2852|  15.6k|      return true;
 2853|  15.6k|    }
 2854|       |    // Try rebalancing with our right sibling. We don't perform rebalancing if
 2855|       |    // we deleted the first element from iter->node_ and the node is not
 2856|       |    // empty. This is a small optimization for the common pattern of deleting
 2857|       |    // from the front of the tree.
 2858|  83.4k|    if (right->count() > kMinNodeValues &&
  ------------------
  |  Branch (2858:9): [True: 83.4k, False: 0]
  ------------------
 2859|  83.4k|        (iter->node_->count() == 0 || iter->position_ > iter->node_->start())) {
  ------------------
  |  Branch (2859:10): [True: 2.12k, False: 81.3k]
  |  Branch (2859:39): [True: 40.8k, False: 40.4k]
  ------------------
 2860|  42.9k|      field_type to_move = (right->count() - iter->node_->count()) / 2;
 2861|  42.9k|      to_move =
 2862|  42.9k|          (std::min)(to_move, static_cast<field_type>(right->count() - 1));
 2863|  42.9k|      iter->node_->rebalance_right_to_left(to_move, right, mutable_allocator());
 2864|  42.9k|      return false;
 2865|  42.9k|    }
 2866|  83.4k|  }
 2867|  42.8k|  if (iter->node_->position() > parent->start()) {
  ------------------
  |  Branch (2867:7): [True: 2.77k, False: 40.0k]
  ------------------
 2868|       |    // Try rebalancing with our left sibling. We don't perform rebalancing if
 2869|       |    // we deleted the last element from iter->node_ and the node is not
 2870|       |    // empty. This is a small optimization for the common pattern of deleting
 2871|       |    // from the back of the tree.
 2872|  2.77k|    node_type *left = parent->child(iter->node_->position() - 1);
 2873|  2.77k|    if (left->count() > kMinNodeValues &&
  ------------------
  |  Branch (2873:9): [True: 2.77k, False: 0]
  ------------------
 2874|  2.77k|        (iter->node_->count() == 0 ||
  ------------------
  |  Branch (2874:10): [True: 5, False: 2.76k]
  ------------------
 2875|  2.76k|         iter->position_ < iter->node_->finish())) {
  ------------------
  |  Branch (2875:10): [True: 2.61k, False: 156]
  ------------------
 2876|  2.61k|      field_type to_move = (left->count() - iter->node_->count()) / 2;
 2877|  2.61k|      to_move = (std::min)(to_move, static_cast<field_type>(left->count() - 1));
 2878|  2.61k|      left->rebalance_left_to_right(to_move, iter->node_, mutable_allocator());
 2879|  2.61k|      iter->position_ += to_move;
 2880|  2.61k|      return false;
 2881|  2.61k|    }
 2882|  2.77k|  }
 2883|  40.2k|  return false;
 2884|  42.8k|}
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE11merge_nodesEPNS1_10btree_nodeIS4_EES8_:
 2827|  18.6k|void btree<P>::merge_nodes(node_type *left, node_type *right) {
 2828|  18.6k|  left->merge(right, mutable_allocator());
 2829|  18.6k|  if (rightmost() == right) mutable_rightmost() = left;
  ------------------
  |  Branch (2829:7): [True: 5.30k, False: 13.3k]
  ------------------
 2830|  18.6k|}
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE5mergeEPS5_PNSt3__19allocatorImEE:
 2005|  18.6k|void btree_node<P>::merge(btree_node *src, allocator_type *alloc) {
 2006|  18.6k|  assert(parent() == src->parent());
 2007|  18.6k|  assert(position() + 1 == src->position());
 2008|       |
 2009|       |  // Move the delimiting value to the left node.
 2010|  18.6k|  value_init(finish(), alloc, parent()->slot(position()));
 2011|       |
 2012|       |  // Move the values from the right to the left node.
 2013|  18.6k|  transfer_n(src->count(), finish() + 1, src->start(), src, alloc);
 2014|       |
 2015|  18.6k|  if (is_internal()) {
  ------------------
  |  Branch (2015:7): [True: 204, False: 18.4k]
  ------------------
 2016|       |    // Move the child pointers from the right to the left node.
 2017|  3.06k|    for (field_type i = src->start(), j = finish() + 1; i <= src->finish();
  ------------------
  |  Branch (2017:57): [True: 2.86k, False: 204]
  ------------------
 2018|  2.86k|         ++i, ++j) {
 2019|  2.86k|      init_child(j, src->child(i));
 2020|  2.86k|      src->clear_child(i);
 2021|  2.86k|    }
 2022|    204|  }
 2023|       |
 2024|       |  // Fixup `finish` on the src and dest nodes.
 2025|  18.6k|  set_finish(start() + 1 + count() + src->count());
 2026|  18.6k|  src->set_finish(src->start());
 2027|       |
 2028|       |  // Remove the value on the parent node and delete the src node.
 2029|  18.6k|  parent()->remove_values(position(), /*to_erase=*/1, alloc);
 2030|  18.6k|}
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE10value_initIJPmEEEvhPNSt3__19allocatorImEEDpOT_:
  982|  63.6k|  void value_init(const field_type i, allocator_type *alloc, Args &&...args) {
  983|  63.6k|    next_generation();
  984|  63.6k|    absl::container_internal::SanitizerUnpoisonObject(slot(i));
  985|  63.6k|    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
  986|  63.6k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE10init_childEhPS5_:
  771|  25.3k|  void init_child(field_type i, btree_node *c) {
  772|  25.3k|    set_child(i, c);
  773|  25.3k|    c->set_parent(this);
  774|  25.3k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE9set_childEhPS5_:
  767|   172k|  void set_child(field_type i, btree_node *c) {
  768|   172k|    set_child_noupdate_position(i, c);
  769|   172k|    c->set_position(i);
  770|   172k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE27set_child_noupdate_positionEhPS5_:
  763|   217k|  void set_child_noupdate_position(field_type i, btree_node *c) {
  764|   217k|    absl::container_internal::SanitizerUnpoisonObject(&mutable_child(i));
  765|   217k|    mutable_child(i) = c;
  766|   217k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE13mutable_childEh:
  759|   607k|  btree_node *&mutable_child(field_type i) { return GetField<4>()[i]; }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm4EEEPNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  655|   607k|  inline typename layout_type::template ElementType<N> *GetField() {
  656|       |    // We assert that we don't read from values that aren't there.
  657|       |    assert(N < 4 || is_internal());
  658|   607k|    return InternalLayout().template Pointer<N>(reinterpret_cast<char *>(this));
  659|   607k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE12set_positionEh:
  672|   728k|  void set_position(field_type v) { GetField<2>()[0] = v; }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE11clear_childEh:
  760|   162k|  void clear_child(field_type i) {
  761|   162k|    absl::container_internal::SanitizerPoisonObject(&mutable_child(i));
  762|   162k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE13remove_valuesEhhPNSt3__19allocatorImEE:
 1855|  18.6k|                                         allocator_type *alloc) {
 1856|       |  // Transfer values after the removed range into their new places.
 1857|  18.6k|  value_destroy_n(i, to_erase, alloc);
 1858|  18.6k|  const field_type orig_finish = finish();
 1859|  18.6k|  const field_type src_i = i + to_erase;
 1860|  18.6k|  transfer_n(orig_finish - src_i, i, src_i, this, alloc);
 1861|       |
 1862|  18.6k|  if (is_internal()) {
  ------------------
  |  Branch (1862:7): [True: 18.6k, False: 0]
  ------------------
 1863|       |    // Delete all children between begin and end.
 1864|  37.3k|    for (field_type j = 0; j < to_erase; ++j) {
  ------------------
  |  Branch (1864:28): [True: 18.6k, False: 18.6k]
  ------------------
 1865|  18.6k|      clear_and_delete(child(i + j + 1), alloc);
 1866|  18.6k|    }
 1867|       |    // Rotate children after end into new positions.
 1868|   166k|    for (field_type j = i + to_erase + 1; j <= orig_finish; ++j) {
  ------------------
  |  Branch (1868:43): [True: 147k, False: 18.6k]
  ------------------
 1869|   147k|      set_child(j - to_erase, child(j));
 1870|   147k|      clear_child(j);
 1871|   147k|    }
 1872|  18.6k|  }
 1873|  18.6k|  set_finish(orig_finish - to_erase);
 1874|  18.6k|}
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE23rebalance_right_to_leftEhPS5_PNSt3__19allocatorImEE:
 1879|  79.1k|                                            allocator_type *alloc) {
 1880|  79.1k|  assert(parent() == right->parent());
 1881|  79.1k|  assert(position() + 1 == right->position());
 1882|  79.1k|  assert(right->count() >= count());
 1883|  79.1k|  assert(to_move >= 1);
 1884|  79.1k|  assert(to_move <= right->count());
 1885|       |
 1886|       |  // 1) Move the delimiting value in the parent to the left node.
 1887|  79.1k|  transfer(finish(), position(), parent(), alloc);
 1888|       |
 1889|       |  // 2) Move the (to_move - 1) values from the right node to the left node.
 1890|  79.1k|  transfer_n(to_move - 1, finish() + 1, right->start(), right, alloc);
 1891|       |
 1892|       |  // 3) Move the new delimiting value to the parent from the right node.
 1893|  79.1k|  parent()->transfer(position(), right->start() + to_move - 1, right, alloc);
 1894|       |
 1895|       |  // 4) Shift the values in the right node to their correct positions.
 1896|  79.1k|  right->transfer_n(right->count() - to_move, right->start(),
 1897|  79.1k|                    right->start() + to_move, right, alloc);
 1898|       |
 1899|  79.1k|  if (is_internal()) {
  ------------------
  |  Branch (1899:7): [True: 439, False: 78.6k]
  ------------------
 1900|       |    // Move the child pointers from the right to the left node.
 1901|  1.49k|    for (field_type i = 0; i < to_move; ++i) {
  ------------------
  |  Branch (1901:28): [True: 1.05k, False: 439]
  ------------------
 1902|  1.05k|      init_child(finish() + i + 1, right->child(i));
 1903|  1.05k|    }
 1904|  11.8k|    for (field_type i = right->start(); i <= right->finish() - to_move; ++i) {
  ------------------
  |  Branch (1904:41): [True: 11.4k, False: 439]
  ------------------
 1905|  11.4k|      assert(i + to_move <= right->max_count());
 1906|  11.4k|      right->init_child(i, right->child(i + to_move));
 1907|  11.4k|      right->clear_child(i + to_move);
 1908|  11.4k|    }
 1909|    439|  }
 1910|       |
 1911|       |  // Fixup `finish` on the left and right nodes.
 1912|  79.1k|  set_finish(finish() + to_move);
 1913|  79.1k|  right->set_finish(right->finish() - to_move);
 1914|  79.1k|}
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE23rebalance_left_to_rightEhPS5_PNSt3__19allocatorImEE:
 1919|  2.61k|                                            allocator_type *alloc) {
 1920|  2.61k|  assert(parent() == right->parent());
 1921|  2.61k|  assert(position() + 1 == right->position());
 1922|  2.61k|  assert(count() >= right->count());
 1923|  2.61k|  assert(to_move >= 1);
 1924|  2.61k|  assert(to_move <= count());
 1925|       |
 1926|       |  // Values in the right node are shifted to the right to make room for the
 1927|       |  // new to_move values. Then, the delimiting value in the parent and the
 1928|       |  // other (to_move - 1) values in the left node are moved into the right node.
 1929|       |  // Lastly, a new delimiting value is moved from the left node into the
 1930|       |  // parent, and the remaining empty left node entries are destroyed.
 1931|       |
 1932|       |  // 1) Shift existing values in the right node to their correct positions.
 1933|  2.61k|  right->transfer_n_backward(right->count(), right->start() + to_move,
 1934|  2.61k|                             right->start(), right, alloc);
 1935|       |
 1936|       |  // 2) Move the delimiting value in the parent to the right node.
 1937|  2.61k|  right->transfer(right->start() + to_move - 1, position(), parent(), alloc);
 1938|       |
 1939|       |  // 3) Move the (to_move - 1) values from the left node to the right node.
 1940|  2.61k|  right->transfer_n(to_move - 1, right->start(), finish() - (to_move - 1), this,
 1941|  2.61k|                    alloc);
 1942|       |
 1943|       |  // 4) Move the new delimiting value to the parent from the left node.
 1944|  2.61k|  parent()->transfer(position(), finish() - to_move, this, alloc);
 1945|       |
 1946|  2.61k|  if (is_internal()) {
  ------------------
  |  Branch (1946:7): [True: 27, False: 2.59k]
  ------------------
 1947|       |    // Move the child pointers from the left to the right node.
 1948|    307|    for (field_type i = right->finish() + 1; i > right->start(); --i) {
  ------------------
  |  Branch (1948:46): [True: 280, False: 27]
  ------------------
 1949|    280|      right->init_child(i - 1 + to_move, right->child(i - 1));
 1950|    280|      right->clear_child(i - 1);
 1951|    280|    }
 1952|    193|    for (field_type i = 1; i <= to_move; ++i) {
  ------------------
  |  Branch (1952:28): [True: 166, False: 27]
  ------------------
 1953|    166|      right->init_child(i - 1, child(finish() - to_move + i));
 1954|    166|      clear_child(finish() - to_move + i);
 1955|    166|    }
 1956|     27|  }
 1957|       |
 1958|       |  // Fixup the counts on the left and right nodes.
 1959|  2.61k|  set_finish(finish() - to_move);
 1960|  2.61k|  right->set_finish(right->finish() + to_move);
 1961|  2.61k|}
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE19transfer_n_backwardEmmmPS5_PNSt3__19allocatorImEE:
 1031|  2.61k|                           allocator_type *alloc) {
 1032|  2.61k|    next_generation();
 1033|  2.61k|    for (slot_type *src = src_node->slot(src_i + n), *end = src - n,
 1034|  2.61k|                   *dest = slot(dest_i + n);
 1035|  36.9k|         src != end; --src, --dest) {
  ------------------
  |  Branch (1035:10): [True: 34.3k, False: 2.61k]
  ------------------
 1036|       |      // If we modified the loop index calculations above to avoid the -1s here,
 1037|       |      // it would result in UB in the computation of `end` (and possibly `src`
 1038|       |      // as well, if n == 0), since slot() is effectively an array index and it
 1039|       |      // is UB to compute the address of any out-of-bounds array element except
 1040|       |      // for one-past-the-end.
 1041|  34.3k|      transfer(dest - 1, src - 1, alloc);
 1042|  34.3k|    }
 1043|  2.61k|  }
_ZN4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_EppEv:
 1220|  3.11M|  btree_iterator &operator++() {
 1221|  3.11M|    increment();
 1222|  3.11M|    return *this;
 1223|  3.11M|  }
_ZN4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E9incrementEv:
 1302|  3.11M|  void increment() {
 1303|  3.11M|    assert_valid_generation(node_);
 1304|  3.11M|    if (node_->is_leaf() && ++position_ < node_->finish()) {
  ------------------
  |  Branch (1304:9): [True: 3.05M, False: 67.5k]
  |  Branch (1304:29): [True: 2.64M, False: 405k]
  ------------------
 1305|  2.64M|      return;
 1306|  2.64M|    }
 1307|   472k|    increment_slow();
 1308|   472k|  }
_ZN4absl12lts_2026052618container_internal14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS7_E14increment_slowEv:
 2160|   472k|void btree_iterator<N, R, P>::increment_slow() {
 2161|   472k|  N* node = node_;
 2162|   472k|  int position = position_;
 2163|   472k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2163:7): [True: 405k, False: 67.5k]
  ------------------
 2164|   405k|    assert(position >= node->finish());
 2165|   493k|    while (position == node->finish() && !node->is_root()) {
  ------------------
  |  Branch (2165:12): [True: 420k, False: 72.7k]
  |  Branch (2165:42): [True: 88.1k, False: 332k]
  ------------------
 2166|  88.1k|      assert(node->parent()->child(node->position()) == node);
 2167|  88.1k|      position = node->position();
 2168|  88.1k|      node = node->parent();
 2169|  88.1k|    }
 2170|       |    // TODO(ezb): assert we aren't incrementing end() instead of handling.
 2171|   405k|    if (position == node->finish()) {
  ------------------
  |  Branch (2171:9): [True: 332k, False: 72.7k]
  ------------------
 2172|   332k|      return;
 2173|   332k|    }
 2174|   405k|  } else {
 2175|  67.5k|    assert(position < node->finish());
 2176|  67.5k|    node = node->child(static_cast<field_type>(position + 1));
 2177|  68.3k|    while (node->is_internal()) {
  ------------------
  |  Branch (2177:12): [True: 878, False: 67.5k]
  ------------------
 2178|    878|      node = node->start_child();
 2179|    878|    }
 2180|  67.5k|    position = node->start();
 2181|  67.5k|  }
 2182|   140k|  *this = {node, position};
 2183|   140k|}
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE13insert_uniqueImJmEEENSt3__14pairINS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSC_EEbEERKT_DpOT0_:
 2382|  2.09M|    -> std::pair<iterator, bool> {
 2383|  2.09M|  if (empty()) {
  ------------------
  |  Branch (2383:7): [True: 264k, False: 1.83M]
  ------------------
 2384|   264k|    mutable_root() = mutable_rightmost() = new_leaf_root_node(1);
 2385|   264k|  }
 2386|       |
 2387|  2.09M|  SearchResult<iterator, is_key_compare_to::value> res = internal_locate(key);
 2388|  2.09M|  iterator iter = res.value;
 2389|       |
 2390|  2.09M|  if (res.HasMatch()) {
  ------------------
  |  Branch (2390:7): [Folded, False: 2.09M]
  ------------------
 2391|      0|    if (res.IsEq()) {
  ------------------
  |  Branch (2391:9): [Folded, False: 0]
  ------------------
 2392|       |      // The key already exists in the tree, do nothing.
 2393|      0|      return {iter, false};
 2394|      0|    }
 2395|  2.09M|  } else {
 2396|  2.09M|    iterator last = internal_last(iter);
 2397|  2.09M|    if (last.node_ && !compare_keys(key, last.key())) {
  ------------------
  |  Branch (2397:9): [True: 0, False: 2.09M]
  |  Branch (2397:23): [True: 0, False: 0]
  ------------------
 2398|       |      // The key already exists in the tree, do nothing.
 2399|      0|      return {last, false};
 2400|      0|    }
 2401|  2.09M|  }
 2402|  2.09M|  return {internal_emplace(iter, std::forward<Args>(args)...), true};
 2403|  2.09M|}
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE18new_leaf_root_nodeEh:
 1727|   501k|  node_type *new_leaf_root_node(field_type max_count) {
 1728|   501k|    node_type *n = allocate(node_type::LeafSize(max_count));
 1729|   501k|    n->init_leaf(/*position=*/0, max_count, /*parent=*/n);
 1730|   501k|    return n;
 1731|   501k|  }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE8allocateEm:
 1710|   555k|  node_type *allocate(size_type size) {
 1711|   555k|    return reinterpret_cast<node_type *>(
 1712|   555k|        absl::container_internal::Allocate<node_type::Alignment()>(
 1713|   555k|            mutable_allocator(), size));
 1714|   555k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE9init_leafEhhPS5_:
  952|   555k|                 btree_node *parent) {
  953|   555k|    set_generation(0);
  954|   555k|    set_parent(parent);
  955|   555k|    set_position(position);
  956|   555k|    set_start(0);
  957|   555k|    set_finish(0);
  958|   555k|    set_max_count(max_count);
  959|   555k|    absl::container_internal::SanitizerPoisonMemoryRegion(
  960|   555k|        start_slot(), max_count * sizeof(slot_type));
  961|   555k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE9set_startEh:
  673|   555k|  void set_start(field_type v) { GetField<2>()[1] = v; }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE13set_max_countEh:
  676|   564k|  void set_max_count(field_type v) { GetField<2>()[3] = v; }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE10start_slotEv:
  669|   555k|  slot_type *start_slot() { return slot(start()); }
_ZNK4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE15internal_locateImEENS1_12SearchResultINS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSB_EELb0EEERKT_:
 3002|  2.09M|    -> SearchResult<iterator, is_key_compare_to::value> {
 3003|  2.09M|  iterator iter(const_cast<node_type *>(root()));
 3004|  3.67M|  for (;;) {
 3005|  3.67M|    SearchResult<size_type, is_key_compare_to::value> res =
 3006|  3.67M|        iter.node_->lower_bound(key, key_comp());
 3007|  3.67M|    iter.position_ = static_cast<int>(res.value);
 3008|  3.67M|    if (res.IsEq()) {
  ------------------
  |  Branch (3008:9): [Folded, False: 3.67M]
  ------------------
 3009|      0|      return {iter, MatchKind::kEq};
 3010|      0|    }
 3011|       |    // Note: in the non-key-compare-to case, we don't need to walk all the way
 3012|       |    // down the tree if the keys are equal, but determining equality would
 3013|       |    // require doing an extra comparison on each node on the way down, and we
 3014|       |    // will need to go all the way to the leaf node in the expected case.
 3015|  3.67M|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (3015:9): [True: 2.09M, False: 1.57M]
  ------------------
 3016|  2.09M|      break;
 3017|  2.09M|    }
 3018|  1.57M|    iter.node_ = iter.node_->child(static_cast<field_type>(iter.position_));
 3019|  1.57M|  }
 3020|       |  // Note: in the non-key-compare-to case, the key may actually be equivalent
 3021|       |  // here (and the MatchKind::kNe is ignored).
 3022|  2.09M|  return {iter, MatchKind::kNe};
 3023|  2.09M|}
_ZNK4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE4rootEv:
 1685|  2.09M|  const node_type *root() const { return root_; }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE11lower_boundImEENS1_12SearchResultImLb0EEERKT_RKNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareE:
  779|  3.67M|      const K &k, const key_compare &comp) const {
  780|  3.67M|    return use_linear_search::value ? linear_search(k, comp)
  ------------------
  |  Branch (780:12): [True: 3.67M, Folded]
  ------------------
  781|  3.67M|                                    : binary_search(k, comp);
  782|  3.67M|  }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE13linear_searchImNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareEEENS1_12SearchResultImXsr23btree_is_key_compare_toIT0_mEE5valueEEERKT_RKSE_:
  793|  3.67M|  linear_search(const K &k, const Compare &comp) const {
  794|  3.67M|    return linear_search_impl(k, start(), finish(), comp,
  795|  3.67M|                              btree_is_key_compare_to<Compare, key_type>());
  796|  3.67M|  }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE18linear_search_implImNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareEEENS1_12SearchResultImLb0EEERKT_mmRKT0_NS8_17integral_constantIbLb0EEE:
  810|  3.67M|      std::false_type /* IsCompareTo */) const {
  811|  42.2M|    while (s < e) {
  ------------------
  |  Branch (811:12): [True: 38.5M, False: 3.67M]
  ------------------
  812|  38.5M|      if (!comp(key(s), k)) {
  ------------------
  |  Branch (812:11): [True: 0, False: 38.5M]
  ------------------
  813|      0|        break;
  814|      0|      }
  815|  38.5M|      ++s;
  816|  38.5M|    }
  817|  3.67M|    return SearchResult<size_type, false>{s};
  818|  3.67M|  }
_ZNK4absl12lts_2026052618container_internal19key_compare_adapterINSt3__14lessImEEmE15checked_compareclImmTnNS3_9enable_ifIXsr3std7is_sameIbNS0_20type_traits_internal9result_ofIFKS5_RKT_RKT0_EE4typeEEE5valueEiE4typeELi0EEEbSF_SI_:
  239|  38.5M|    bool operator()(const T &lhs, const U &rhs) const {
  240|       |      // NOTE: if any of these assertions fail, then the comparator does not
  241|       |      // establish a strict-weak-ordering (see
  242|       |      // https://en.cppreference.com/w/cpp/named_req/Compare).
  243|  38.5M|      assert(is_self_equivalent(lhs));
  244|  38.5M|      assert(is_self_equivalent(rhs));
  245|  38.5M|      const bool lhs_comp_rhs = comp()(lhs, rhs);
  246|       |      assert(!lhs_comp_rhs || !comp()(rhs, lhs));
  247|  38.5M|      return lhs_comp_rhs;
  248|  38.5M|    }
_ZNK4absl12lts_2026052618container_internal20checked_compare_baseINSt3__14lessImEELb1EE4compEv:
  178|  38.5M|  const Compare &comp() const { return *this; }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE3keyEm:
  750|  38.5M|  const key_type &key(size_type i) const { return params_type::key(slot(i)); }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE4slotEm:
  671|  38.5M|  const slot_type *slot(size_type i) const { return &GetField<3>()[i]; }
_ZNK4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE8GetFieldILm3EEEPKNSt3__113tuple_elementIXT_ENS7_5tupleIJPS5_jhmSA_EEEE4typeEv:
  661|  38.5M|  inline const typename layout_type::template ElementType<N> *GetField() const {
  662|       |    assert(N < 4 || is_internal());
  663|  38.5M|    return InternalLayout().template Pointer<N>(
  664|  38.5M|        reinterpret_cast<const char *>(this));
  665|  38.5M|  }
_ZN4absl12lts_2026052618container_internal12SearchResultImLb0EEC2Em:
  482|  3.67M|  explicit SearchResult(V v) : value(v) {}
_ZNK4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE8key_compEv:
 1590|  3.67M|  const key_compare &key_comp() const noexcept {
 1591|  3.67M|    return rightmost_.template get<0>();
 1592|  3.67M|  }
_ZN4absl12lts_2026052618container_internal12SearchResultINS1_14btree_iteratorINS1_10btree_nodeINS1_15set_params_implImJEEEEERKmPS8_EELb0EEC2ESB_NS1_9MatchKindE:
  483|  2.09M|  SearchResult(V v, MatchKind /*match*/) : value(v) {}
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE13internal_lastINS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSA_EEEET_SE_:
 2906|  2.09M|inline IterType btree<P>::internal_last(IterType iter) {
 2907|  2.09M|  assert(iter.node_ != nullptr);
 2908|  3.67M|  while (iter.position_ == iter.node_->finish()) {
  ------------------
  |  Branch (2908:10): [True: 3.67M, False: 0]
  ------------------
 2909|  3.67M|    iter.position_ = iter.node_->position();
 2910|  3.67M|    iter.node_ = iter.node_->parent();
 2911|  3.67M|    if (iter.node_->is_leaf()) {
  ------------------
  |  Branch (2911:9): [True: 2.09M, False: 1.57M]
  ------------------
 2912|  2.09M|      iter.node_ = nullptr;
 2913|  2.09M|      break;
 2914|  2.09M|    }
 2915|  3.67M|  }
 2916|  2.09M|  iter.update_generation();
 2917|  2.09M|  return iter;
 2918|  2.09M|}
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE16internal_emplaceIJmEEENS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSA_EESD_DpOT_:
 2923|  2.09M|    -> iterator {
 2924|  2.09M|  if (iter.node_->is_internal()) {
  ------------------
  |  Branch (2924:7): [True: 0, False: 2.09M]
  ------------------
 2925|       |    // We can't insert on an internal node. Instead, we'll insert after the
 2926|       |    // previous value which is guaranteed to be on a leaf node.
 2927|      0|    --iter;
 2928|      0|    ++iter.position_;
 2929|      0|  }
 2930|  2.09M|  const field_type max_count = iter.node_->max_count();
 2931|  2.09M|  allocator_type *alloc = mutable_allocator();
 2932|       |
 2933|  2.09M|  const auto transfer_and_delete = [&](node_type *old_node,
 2934|  2.09M|                                       node_type *new_node) {
 2935|  2.09M|    new_node->transfer_n(old_node->count(), new_node->start(),
 2936|  2.09M|                         old_node->start(), old_node, alloc);
 2937|  2.09M|    new_node->set_finish(old_node->finish());
 2938|  2.09M|    old_node->set_finish(old_node->start());
 2939|  2.09M|    new_node->set_generation(old_node->generation());
 2940|  2.09M|    node_type::clear_and_delete(old_node, alloc);
 2941|  2.09M|  };
 2942|  2.09M|  const auto replace_leaf_root_node = [&](field_type new_node_size) {
 2943|  2.09M|    assert(iter.node_ == root());
 2944|  2.09M|    node_type *old_root = iter.node_;
 2945|  2.09M|    node_type *new_root = iter.node_ = new_leaf_root_node(new_node_size);
 2946|  2.09M|    transfer_and_delete(old_root, new_root);
 2947|  2.09M|    mutable_root() = mutable_rightmost() = new_root;
 2948|  2.09M|  };
 2949|       |
 2950|  2.09M|  bool replaced_node = false;
 2951|  2.09M|  if (iter.node_->count() == max_count) {
  ------------------
  |  Branch (2951:7): [True: 317k, False: 1.78M]
  ------------------
 2952|       |    // Make room in the leaf for the new item.
 2953|   317k|    if (max_count < kNodeSlots) {
  ------------------
  |  Branch (2953:9): [True: 237k, False: 80.1k]
  ------------------
 2954|       |      // Insertion into the root where the root is smaller than the full node
 2955|       |      // size. Simply grow the size of the root node.
 2956|   237k|      replace_leaf_root_node(static_cast<field_type>(
 2957|   237k|          (std::min)(static_cast<int>(kNodeSlots), 2 * max_count)));
 2958|   237k|      replaced_node = true;
 2959|   237k|    } else {
 2960|  80.1k|      rebalance_or_split(&iter);
 2961|  80.1k|    }
 2962|   317k|  }
 2963|  2.09M|  (void)replaced_node;
 2964|       |#if defined(ABSL_HAVE_ADDRESS_SANITIZER) || \
 2965|       |    defined(ABSL_HAVE_HWADDRESS_SANITIZER)
 2966|       |  if (!replaced_node) {
 2967|       |    assert(iter.node_->is_leaf());
 2968|       |    if (iter.node_->is_root()) {
 2969|       |      replace_leaf_root_node(max_count);
 2970|       |    } else {
 2971|       |      node_type *old_node = iter.node_;
 2972|       |      const bool was_rightmost = rightmost() == old_node;
 2973|       |      const bool was_leftmost = leftmost() == old_node;
 2974|       |      node_type *parent = old_node->parent();
 2975|       |      const field_type position = old_node->position();
 2976|       |      node_type *new_node = iter.node_ = new_leaf_node(position, parent);
 2977|       |      parent->set_child_noupdate_position(position, new_node);
 2978|       |      transfer_and_delete(old_node, new_node);
 2979|       |      if (was_rightmost) mutable_rightmost() = new_node;
 2980|       |      // The leftmost node is stored as the parent of the root node.
 2981|       |      if (was_leftmost) root()->set_parent(new_node);
 2982|       |    }
 2983|       |  }
 2984|       |#endif
 2985|  2.09M|  iter.node_->emplace_value(static_cast<field_type>(iter.position_), alloc,
 2986|  2.09M|                            std::forward<Args>(args)...);
 2987|       |  assert(
 2988|  2.09M|      iter.node_->is_ordered_correctly(static_cast<field_type>(iter.position_),
 2989|  2.09M|                                       original_key_compare(key_comp())) &&
 2990|  2.09M|      "If this assert fails, then either (1) the comparator may violate "
 2991|  2.09M|      "transitivity, i.e. comp(a,b) && comp(b,c) -> comp(a,c) (see "
 2992|  2.09M|      "https://en.cppreference.com/w/cpp/named_req/Compare), or (2) a "
 2993|  2.09M|      "key may have been mutated after it was inserted into the tree.");
 2994|  2.09M|  ++size_;
 2995|  2.09M|  iter.update_generation();
 2996|  2.09M|  return iter;
 2997|  2.09M|}
_ZZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE16internal_emplaceIJmEEENS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSA_EESD_DpOT_ENKUlhE_clEh:
 2942|   237k|  const auto replace_leaf_root_node = [&](field_type new_node_size) {
 2943|       |    assert(iter.node_ == root());
 2944|   237k|    node_type *old_root = iter.node_;
 2945|   237k|    node_type *new_root = iter.node_ = new_leaf_root_node(new_node_size);
 2946|   237k|    transfer_and_delete(old_root, new_root);
 2947|   237k|    mutable_root() = mutable_rightmost() = new_root;
 2948|   237k|  };
_ZZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE16internal_emplaceIJmEEENS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPSA_EESD_DpOT_ENKUlPS9_SH_E_clESH_SH_:
 2934|   237k|                                       node_type *new_node) {
 2935|   237k|    new_node->transfer_n(old_node->count(), new_node->start(),
 2936|   237k|                         old_node->start(), old_node, alloc);
 2937|   237k|    new_node->set_finish(old_node->finish());
 2938|   237k|    old_node->set_finish(old_node->start());
 2939|   237k|    new_node->set_generation(old_node->generation());
 2940|   237k|    node_type::clear_and_delete(old_node, alloc);
 2941|   237k|  };
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE18rebalance_or_splitEPNS1_14btree_iteratorINS1_10btree_nodeIS4_EERKmPS9_EE:
 2719|  81.0k|void btree<P>::rebalance_or_split(iterator *iter) {
 2720|  81.0k|  node_type *&node = iter->node_;
 2721|  81.0k|  int &insert_position = iter->position_;
 2722|  81.0k|  assert(node->count() == node->max_count());
 2723|  81.0k|  assert(kNodeSlots == node->max_count());
 2724|       |
 2725|       |  // First try to make room on the node by rebalancing.
 2726|  81.0k|  node_type *parent = node->parent();
 2727|  81.0k|  if (node != root()) {
  ------------------
  |  Branch (2727:7): [True: 72.1k, False: 8.92k]
  ------------------
 2728|  72.1k|    if (node->position() > parent->start()) {
  ------------------
  |  Branch (2728:9): [True: 72.1k, False: 0]
  ------------------
 2729|       |      // Try rebalancing with our left sibling.
 2730|  72.1k|      node_type *left = parent->child(node->position() - 1);
 2731|  72.1k|      assert(left->max_count() == kNodeSlots);
 2732|  72.1k|      if (left->count() < kNodeSlots) {
  ------------------
  |  Branch (2732:11): [True: 36.1k, False: 35.9k]
  ------------------
 2733|       |        // We bias rebalancing based on the position being inserted. If we're
 2734|       |        // inserting at the end of the right node then we bias rebalancing to
 2735|       |        // fill up the left node.
 2736|  36.1k|        field_type to_move =
 2737|  36.1k|            (kNodeSlots - left->count()) /
 2738|  36.1k|            (1 + (static_cast<field_type>(insert_position) < kNodeSlots));
 2739|  36.1k|        to_move = (std::max)(field_type{1}, to_move);
 2740|       |
 2741|  36.1k|        if (static_cast<field_type>(insert_position) - to_move >=
  ------------------
  |  Branch (2741:13): [True: 36.1k, False: 0]
  ------------------
 2742|  36.1k|                node->start() ||
 2743|  36.1k|            left->count() + to_move < kNodeSlots) {
  ------------------
  |  Branch (2743:13): [True: 0, False: 0]
  ------------------
 2744|  36.1k|          left->rebalance_right_to_left(to_move, node, mutable_allocator());
 2745|       |
 2746|  36.1k|          assert(node->max_count() - node->count() == to_move);
 2747|  36.1k|          insert_position = static_cast<int>(
 2748|  36.1k|              static_cast<field_type>(insert_position) - to_move);
 2749|  36.1k|          if (insert_position < node->start()) {
  ------------------
  |  Branch (2749:15): [True: 0, False: 36.1k]
  ------------------
 2750|      0|            insert_position = insert_position + left->count() + 1;
 2751|      0|            node = left;
 2752|      0|          }
 2753|       |
 2754|  36.1k|          assert(node->count() < node->max_count());
 2755|  36.1k|          return;
 2756|  36.1k|        }
 2757|  36.1k|      }
 2758|  72.1k|    }
 2759|       |
 2760|  35.9k|    if (node->position() < parent->finish()) {
  ------------------
  |  Branch (2760:9): [True: 0, False: 35.9k]
  ------------------
 2761|       |      // Try rebalancing with our right sibling.
 2762|      0|      node_type *right = parent->child(node->position() + 1);
 2763|      0|      assert(right->max_count() == kNodeSlots);
 2764|      0|      if (right->count() < kNodeSlots) {
  ------------------
  |  Branch (2764:11): [True: 0, False: 0]
  ------------------
 2765|       |        // We bias rebalancing based on the position being inserted. If we're
 2766|       |        // inserting at the beginning of the left node then we bias rebalancing
 2767|       |        // to fill up the right node.
 2768|      0|        field_type to_move = (kNodeSlots - right->count()) /
 2769|      0|                             (1 + (insert_position > node->start()));
 2770|      0|        to_move = (std::max)(field_type{1}, to_move);
 2771|       |
 2772|      0|        if (static_cast<field_type>(insert_position) <=
  ------------------
  |  Branch (2772:13): [True: 0, False: 0]
  ------------------
 2773|      0|                node->finish() - to_move ||
 2774|      0|            right->count() + to_move < kNodeSlots) {
  ------------------
  |  Branch (2774:13): [True: 0, False: 0]
  ------------------
 2775|      0|          node->rebalance_left_to_right(to_move, right, mutable_allocator());
 2776|       |
 2777|      0|          if (insert_position > node->finish()) {
  ------------------
  |  Branch (2777:15): [True: 0, False: 0]
  ------------------
 2778|      0|            insert_position = insert_position - node->count() - 1;
 2779|      0|            node = right;
 2780|      0|          }
 2781|       |
 2782|      0|          assert(node->count() < node->max_count());
 2783|      0|          return;
 2784|      0|        }
 2785|      0|      }
 2786|      0|    }
 2787|       |
 2788|       |    // Rebalancing failed, make sure there is room on the parent node for a new
 2789|       |    // value.
 2790|  35.9k|    assert(parent->max_count() == kNodeSlots);
 2791|  35.9k|    if (parent->count() == kNodeSlots) {
  ------------------
  |  Branch (2791:9): [True: 902, False: 35.0k]
  ------------------
 2792|    902|      iterator parent_iter(parent, node->position());
 2793|    902|      rebalance_or_split(&parent_iter);
 2794|    902|      parent = node->parent();
 2795|    902|    }
 2796|  35.9k|  } else {
 2797|       |    // Rebalancing not possible because this is the root node.
 2798|       |    // Create a new root node and set the current root node as the child of the
 2799|       |    // new root.
 2800|  8.92k|    parent = new_internal_node(/*position=*/0, parent);
 2801|  8.92k|    parent->set_generation(root()->generation());
 2802|  8.92k|    parent->init_child(parent->start(), node);
 2803|  8.92k|    mutable_root() = parent;
 2804|       |    // If the former root was a leaf node, then it's now the rightmost node.
 2805|  8.92k|    assert(parent->start_child()->is_internal() ||
 2806|  8.92k|           parent->start_child() == rightmost());
 2807|  8.92k|  }
 2808|       |
 2809|       |  // Split the node.
 2810|  44.9k|  node_type *split_node;
 2811|  44.9k|  if (node->is_leaf()) {
  ------------------
  |  Branch (2811:7): [True: 44.3k, False: 608]
  ------------------
 2812|  44.3k|    split_node = new_leaf_node(node->position() + 1, parent);
 2813|  44.3k|    node->split(insert_position, split_node, mutable_allocator());
 2814|  44.3k|    if (rightmost() == node) mutable_rightmost() = split_node;
  ------------------
  |  Branch (2814:9): [True: 44.3k, False: 0]
  ------------------
 2815|  44.3k|  } else {
 2816|    608|    split_node = new_internal_node(node->position() + 1, parent);
 2817|    608|    node->split(insert_position, split_node, mutable_allocator());
 2818|    608|  }
 2819|       |
 2820|  44.9k|  if (insert_position > node->finish()) {
  ------------------
  |  Branch (2820:7): [True: 44.9k, False: 0]
  ------------------
 2821|  44.9k|    insert_position = insert_position - node->count() - 1;
 2822|  44.9k|    node = split_node;
 2823|  44.9k|  }
 2824|  44.9k|}
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE17new_internal_nodeEhPNS1_10btree_nodeIS4_EE:
 1717|  9.53k|  node_type *new_internal_node(field_type position, node_type *parent) {
 1718|  9.53k|    node_type *n = allocate(node_type::InternalSize());
 1719|  9.53k|    n->init_internal(position, parent);
 1720|  9.53k|    return n;
 1721|  9.53k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE13init_internalEhPS5_:
  962|  9.53k|  void init_internal(field_type position, btree_node *parent) {
  963|  9.53k|    init_leaf(position, kNodeSlots, parent);
  964|       |    // Set `max_count` to a sentinel value to indicate that this node is
  965|       |    // internal.
  966|  9.53k|    set_max_count(kInternalNodeMaxCount);
  967|  9.53k|    absl::container_internal::SanitizerPoisonMemoryRegion(
  968|  9.53k|        &mutable_child(start()), (kNodeSlots + 1) * sizeof(btree_node *));
  969|  9.53k|  }
_ZN4absl12lts_2026052618container_internal5btreeINS1_15set_params_implImJEEEE13new_leaf_nodeEhPNS1_10btree_nodeIS4_EE:
 1722|  44.3k|  node_type *new_leaf_node(field_type position, node_type *parent) {
 1723|  44.3k|    node_type *n = allocate(node_type::LeafSize());
 1724|  44.3k|    n->init_leaf(position, kNodeSlots, parent);
 1725|  44.3k|    return n;
 1726|  44.3k|  }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE5splitEiPS5_PNSt3__19allocatorImEE:
 1965|  44.9k|                          allocator_type *alloc) {
 1966|  44.9k|  assert(dest->count() == 0);
 1967|  44.9k|  assert(max_count() == kNodeSlots);
 1968|  44.9k|  assert(position() + 1 == dest->position());
 1969|  44.9k|  assert(parent() == dest->parent());
 1970|       |
 1971|       |  // We bias the split based on the position being inserted. If we're
 1972|       |  // inserting at the beginning of the left node then bias the split to put
 1973|       |  // more values on the right node. If we're inserting at the end of the
 1974|       |  // right node then bias the split to put more values on the left node.
 1975|  44.9k|  if (insert_position == start()) {
  ------------------
  |  Branch (1975:7): [True: 0, False: 44.9k]
  ------------------
 1976|      0|    dest->set_finish(dest->start() + finish() - 1);
 1977|  44.9k|  } else if (insert_position == kNodeSlots) {
  ------------------
  |  Branch (1977:14): [True: 44.9k, False: 0]
  ------------------
 1978|  44.9k|    dest->set_finish(dest->start());
 1979|  44.9k|  } else {
 1980|      0|    dest->set_finish(dest->start() + count() / 2);
 1981|      0|  }
 1982|  44.9k|  set_finish(finish() - dest->count());
 1983|  44.9k|  assert(count() >= 1);
 1984|       |
 1985|       |  // Move values from the left sibling to the right sibling.
 1986|  44.9k|  dest->transfer_n(dest->count(), dest->start(), finish(), this, alloc);
 1987|       |
 1988|       |  // The split key is the largest value in the left sibling.
 1989|  44.9k|  --mutable_finish();
 1990|  44.9k|  parent()->emplace_value(position(), alloc, finish_slot());
 1991|  44.9k|  value_destroy(finish(), alloc);
 1992|  44.9k|  parent()->set_child_noupdate_position(position() + 1, dest);
 1993|       |
 1994|  44.9k|  if (is_internal()) {
  ------------------
  |  Branch (1994:7): [True: 608, False: 44.3k]
  ------------------
 1995|  1.21k|    for (field_type i = dest->start(), j = finish() + 1; i <= dest->finish();
  ------------------
  |  Branch (1995:58): [True: 608, False: 608]
  ------------------
 1996|    608|         ++i, ++j) {
 1997|       |      assert(child(j) != nullptr);
 1998|    608|      dest->init_child(i, child(j));
 1999|    608|      clear_child(j);
 2000|    608|    }
 2001|    608|  }
 2002|  44.9k|}
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE14mutable_finishEv:
  667|  44.9k|  field_type &mutable_finish() { return GetField<2>()[2]; }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE13emplace_valueIJPmEEEvhPNSt3__19allocatorImEEDpOT_:
 1832|  44.9k|                                         Args &&...args) {
 1833|  44.9k|  assert(i >= start());
 1834|  44.9k|  assert(i <= finish());
 1835|       |  // Shift old values to create space for new value and then construct it in
 1836|       |  // place.
 1837|  44.9k|  if (i < finish()) {
  ------------------
  |  Branch (1837:7): [True: 0, False: 44.9k]
  ------------------
 1838|      0|    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
 1839|      0|                        alloc);
 1840|      0|  }
 1841|  44.9k|  value_init(static_cast<field_type>(i), alloc, std::forward<Args>(args)...);
 1842|  44.9k|  set_finish(finish() + 1);
 1843|       |
 1844|  44.9k|  if (is_internal() && finish() > i + 1) {
  ------------------
  |  Branch (1844:7): [True: 44.9k, False: 0]
  |  Branch (1844:24): [True: 0, False: 44.9k]
  ------------------
 1845|      0|    for (field_type j = finish(); j > i + 1; --j) {
  ------------------
  |  Branch (1845:35): [True: 0, False: 0]
  ------------------
 1846|      0|      set_child(j, child(j - 1));
 1847|      0|    }
 1848|      0|    clear_child(i + 1);
 1849|      0|  }
 1850|  44.9k|}
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE11finish_slotEv:
  670|  44.9k|  slot_type *finish_slot() { return slot(finish()); }
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE13emplace_valueIJmEEEvhPNSt3__19allocatorImEEDpOT_:
 1832|  2.09M|                                         Args &&...args) {
 1833|  2.09M|  assert(i >= start());
 1834|  2.09M|  assert(i <= finish());
 1835|       |  // Shift old values to create space for new value and then construct it in
 1836|       |  // place.
 1837|  2.09M|  if (i < finish()) {
  ------------------
  |  Branch (1837:7): [True: 0, False: 2.09M]
  ------------------
 1838|      0|    transfer_n_backward(finish() - i, /*dest_i=*/i + 1, /*src_i=*/i, this,
 1839|      0|                        alloc);
 1840|      0|  }
 1841|  2.09M|  value_init(static_cast<field_type>(i), alloc, std::forward<Args>(args)...);
 1842|  2.09M|  set_finish(finish() + 1);
 1843|       |
 1844|  2.09M|  if (is_internal() && finish() > i + 1) {
  ------------------
  |  Branch (1844:7): [True: 0, False: 2.09M]
  |  Branch (1844:24): [True: 0, False: 0]
  ------------------
 1845|      0|    for (field_type j = finish(); j > i + 1; --j) {
  ------------------
  |  Branch (1845:35): [True: 0, False: 0]
  ------------------
 1846|      0|      set_child(j, child(j - 1));
 1847|      0|    }
 1848|      0|    clear_child(i + 1);
 1849|      0|  }
 1850|  2.09M|}
_ZN4absl12lts_2026052618container_internal10btree_nodeINS1_15set_params_implImJEEEE10value_initIJmEEEvhPNSt3__19allocatorImEEDpOT_:
  982|  2.09M|  void value_init(const field_type i, allocator_type *alloc, Args &&...args) {
  983|  2.09M|    next_generation();
  984|  2.09M|    absl::container_internal::SanitizerUnpoisonObject(slot(i));
  985|  2.09M|    params_type::construct(alloc, slot(i), std::forward<Args>(args)...);
  986|  2.09M|  }

_ZN4absl12lts_2026052618container_internal19btree_set_containerINS1_5btreeINS1_15set_params_implImJEEEEEEC2Ev:
  307|   293k|  btree_set_container() {}
_ZN4absl12lts_2026052618container_internal15btree_containerINS1_5btreeINS1_15set_params_implImJEEEEEEC2Ev:
   77|   293k|  btree_container() : tree_(key_compare(), allocator_type()) {}
_ZN4absl12lts_2026052618container_internal15btree_containerINS1_5btreeINS1_15set_params_implImJEEEEEE5beginEv:
  101|   380k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND { return tree_.begin(); }
_ZN4absl12lts_2026052618container_internal15btree_containerINS1_5btreeINS1_15set_params_implImJEEEEEE3endEv:
  108|  3.30M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND { return tree_.end(); }
_ZN4absl12lts_2026052618container_internal15btree_containerINS1_5btreeINS1_15set_params_implImJEEEEEE5eraseENS1_14btree_iteratorINS1_10btree_nodeIS5_EERKmPSB_EE:
  189|   752k|  iterator erase(iterator iter) ABSL_ATTRIBUTE_LIFETIME_BOUND {
  190|   752k|    return tree_.erase(iter);
  191|   752k|  }
_ZN4absl12lts_2026052618container_internal19btree_set_containerINS1_5btreeINS1_15set_params_implImJEEEEEE6insertEOm:
  337|  2.09M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  338|  2.09M|    return this->tree_.insert_unique(params_type::key(v), std::move(v));
  339|  2.09M|  }

_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE7destroyINSt3__19allocatorINSC_4pairIKmS8_EEEEEEDaPT_PNS1_13map_slot_typeImS8_EE:
   59|  47.5k|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|  47.5k|    return Policy::destroy(alloc, slot);
   61|  47.5k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE7destroyINSt3__19allocatorImEEEEDaPT_Pm:
   59|  2.16M|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|  2.16M|    return Policy::destroy(alloc, slot);
   61|  2.16M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDilEEvE7destroyINSt3__19allocatorINS7_4pairIKDilEEEEEEDaPT_PNS1_13map_slot_typeIDilEE:
   59|     83|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|     83|    return Policy::destroy(alloc, slot);
   61|     83|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEvE7destroyINS4_9allocatorINS5_IKDiS6_EEEEEEDaPT_PNS1_13map_slot_typeIDiS6_EE:
   59|     47|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|     47|    return Policy::destroy(alloc, slot);
   61|     47|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE7destroyINS8_INS4_4pairIKSA_lEEEEEEDaPT_PNS1_13map_slot_typeISA_lEE:
   59|  2.14M|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|  2.14M|    return Policy::destroy(alloc, slot);
   61|  2.14M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE7destroyINS8_ISA_EEEEDaPT_PSA_:
   59|   990k|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|   990k|    return Policy::destroy(alloc, slot);
   61|   990k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEvE7elementIS7_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIDiS6_EE:
   85|  17.7M|      -> decltype(P::element(slot)) {
   86|  17.7M|    return P::element(slot);
   87|  17.7M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEvE8transferINS4_9allocatorINS5_IKDiS6_EEEEEEvPT_PNS1_13map_slot_typeIDiS6_EESI_:
   75|   403k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   403k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   403k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEvE13transfer_implINS4_9allocatorINS5_IKDiS6_EEEES7_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeIDiS6_EESK_NS8_5Rank2E:
  119|   403k|                                                           old_slot)) {
  120|   403k|    return P::transfer(alloc, new_slot, old_slot);
  121|   403k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEvE9constructINS4_9allocatorINS5_IKDiS6_EEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRSB_EEENSH_IJEEEEEEvPT_PNS1_13map_slot_typeIDiS6_EEDpOT0_:
   51|   300k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   300k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   300k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDilEEvE7elementIS4_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIDilEE:
   85|  11.4M|      -> decltype(P::element(slot)) {
   86|  11.4M|    return P::element(slot);
   87|  11.4M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDilEEvE8transferINSt3__19allocatorINS7_4pairIKDilEEEEEEvPT_PNS1_13map_slot_typeIDilEESH_:
   75|   282k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   282k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   282k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDilEEvE13transfer_implINSt3__19allocatorINS7_4pairIKDilEEEES4_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeIDilEESJ_NS5_5Rank2E:
  119|   282k|                                                           old_slot)) {
  120|   282k|    return P::transfer(alloc, new_slot, old_slot);
  121|   282k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDilEEvE9constructINSt3__19allocatorINS7_4pairIKDilEEEEJRKNS7_21piecewise_construct_tENS7_5tupleIJRSA_EEENSG_IJRKlEEEEEEvPT_PNS1_13map_slot_typeIDilEEDpOT0_:
   51|   272k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   272k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   272k|  }
_ZN4absl12lts_2026052618container_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_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE8transferINS8_INS4_4pairIKSA_lEEEEEEvPT_PNS1_13map_slot_typeISA_lEESM_:
   75|  3.04M|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|  3.04M|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|  3.04M|  }
_ZN4absl12lts_2026052618container_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.04M|                                                           old_slot)) {
  120|  3.04M|    return P::transfer(alloc, new_slot, old_slot);
  121|  3.04M|  }
_ZN4absl12lts_2026052618container_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|   193k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   193k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   193k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE7elementISB_EEDTclsrT_7elementfp_EEPSA_:
   85|  1.07M|      -> decltype(P::element(slot)) {
   86|  1.07M|    return P::element(slot);
   87|  1.07M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE8transferINS8_ISA_EEEEvPT_PSA_SH_:
   75|   568k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   568k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   568k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE13transfer_implINS8_ISA_EEEEvPT_PSA_SH_NSC_5Rank0E:
  141|   568k|                            slot_type* old_slot, Rank0) {
  142|   568k|    construct(alloc, new_slot, std::move(element(old_slot)));
  143|   568k|    destroy(alloc, old_slot);
  144|   568k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE9constructINS8_ISA_EEJSA_EEEvPT_PSA_DpOT0_:
   51|   616k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   616k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   616k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE9constructINS8_ISA_EEJRKSA_EEEvPT_PSA_DpOT0_:
   51|   374k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   374k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   374k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE8transferINS8_INS4_4pairIKSA_fEEEEEEvPT_PNS1_13map_slot_typeISA_fEESM_:
   75|   285k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   285k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   285k|  }
_ZN4absl12lts_2026052618container_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|   285k|                                                           old_slot)) {
  120|   285k|    return P::transfer(alloc, new_slot, old_slot);
  121|   285k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeISA_fEE:
   85|  1.19M|      -> decltype(P::element(slot)) {
   86|  1.19M|    return P::element(slot);
   87|  1.19M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE9constructINS8_INS4_4pairIKSA_fEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRSF_EEENSL_IJRKfEEEEEEvPT_PNS1_13map_slot_typeISA_fEEDpOT0_:
   51|   233k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   233k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   233k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE7destroyINS8_INS4_4pairIKSA_fEEEEEEDaPT_PNS1_13map_slot_typeISA_fEE:
   59|   457k|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|   457k|    return Policy::destroy(alloc, slot);
   61|   457k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE9constructINS8_INS4_4pairIKSA_lEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSL_IJEEEEEEvPT_PNS1_13map_slot_typeISA_lEEDpOT0_:
   51|   170k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   170k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   170k|  }
_ZN4absl12lts_2026052618container_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.77M|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|  1.77M|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|  1.77M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE9constructINS8_INS4_4pairIKSA_fEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRSF_EEENSL_IJEEEEEEvPT_PNS1_13map_slot_typeISA_fEEDpOT0_:
   51|   224k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   224k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   224k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEvE7destroyINS8_INS4_4pairIKSA_mEEEEEEDaPT_PNS1_13map_slot_typeISA_mEE:
   59|  93.3k|  static auto destroy(Alloc* alloc, slot_type* slot) {
   60|  93.3k|    return Policy::destroy(alloc, slot);
   61|  93.3k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeISA_mEE:
   85|   525k|      -> decltype(P::element(slot)) {
   86|   525k|    return P::element(slot);
   87|   525k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEvE8transferINS8_INS4_4pairIKSA_mEEEEEEvPT_PNS1_13map_slot_typeISA_mEESM_:
   75|   138k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   138k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   138k|  }
_ZN4absl12lts_2026052618container_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|   138k|                                                           old_slot)) {
  120|   138k|    return P::transfer(alloc, new_slot, old_slot);
  121|   138k|  }
_ZN4absl12lts_2026052618container_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|  93.3k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|  93.3k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|  93.3k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE7elementIS9_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeImS8_EE:
   85|  8.66M|      -> decltype(P::element(slot)) {
   86|  8.66M|    return P::element(slot);
   87|  8.66M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE8transferINSt3__19allocatorINSC_4pairIKmS8_EEEEEEvPT_PNS1_13map_slot_typeImS8_EESM_:
   75|   370k|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|   370k|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|   370k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE13transfer_implINSt3__19allocatorINSC_4pairIKmS8_EEEES9_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeImS8_EESO_NSA_5Rank2E:
  119|   370k|                                                           old_slot)) {
  120|   370k|    return P::transfer(alloc, new_slot, old_slot);
  121|   370k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE9constructINSt3__19allocatorINSC_4pairIKmS8_EEEEJRKNSC_21piecewise_construct_tENSC_5tupleIJRSF_EEENSL_IJRKS8_EEEEEEvPT_PNS1_13map_slot_typeImS8_EEDpOT0_:
   51|   293k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|   293k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|   293k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE7elementIS4_EEDTclsrT_7elementfp_EEPm:
   85|  27.4M|      -> decltype(P::element(slot)) {
   86|  27.4M|    return P::element(slot);
   87|  27.4M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE8transferINSt3__19allocatorImEEEEvPT_PmSC_:
   75|  11.8M|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|  11.8M|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|  11.8M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE13transfer_implINSt3__19allocatorImEEvEENS7_17integral_constantIbLb1EEEPT_PmSE_NS5_5Rank1E:
  129|  11.8M|                                      slot_type* old_slot, Rank1) {
  130|       |    // TODO(b/247130232): remove casts after fixing warnings.
  131|       |    // TODO(b/251814870): remove casts after fixing warnings.
  132|  11.8M|    std::memcpy(
  133|  11.8M|        static_cast<void*>(std::launder(
  134|  11.8M|            const_cast<std::remove_const_t<value_type>*>(&element(new_slot)))),
  135|  11.8M|        static_cast<const void*>(&element(old_slot)), sizeof(value_type));
  136|  11.8M|    return {};
  137|  11.8M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE9constructINSt3__19allocatorImEEJPmEEEvPT_SA_DpOT0_:
   51|  63.6k|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|  63.6k|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|  63.6k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_15set_slot_policyImEEvE9constructINSt3__19allocatorImEEJmEEEvPT_PmDpOT0_:
   51|  2.09M|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|  2.09M|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|  2.09M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEvE7elementIS7_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIDiS6_EE:
   85|  78.6M|      -> decltype(P::element(slot)) {
   86|  78.6M|    return P::element(slot);
   87|  78.6M|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEvE8transferINSt3__19allocatorINSA_4pairIKDiS6_EEEEEEvPT_PNS1_13map_slot_typeIDiS6_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_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEvE13transfer_implINSt3__19allocatorINSA_4pairIKDiS6_EEEES7_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeIDiS6_EESM_NS8_5Rank2E:
  119|   229k|                                                           old_slot)) {
  120|   229k|    return P::transfer(alloc, new_slot, old_slot);
  121|   229k|  }
_ZN4absl12lts_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEvE9constructINSt3__19allocatorINSA_4pairIKDiS6_EEEEJRKNSA_21piecewise_construct_tENSA_5tupleIJRSD_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIDiS6_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_2026052618container_internal20common_policy_traitsINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEvE9constructINSt3__19allocatorINSA_4pairIKDiS6_EEEEJRKNSA_21piecewise_construct_tENSA_5tupleIJODiEEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIDiS6_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_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIjEEmEEELb0EE3getEv:
   91|  7.54k|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorIjEEmEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS6_XT_EE4typeEv:
  249|  7.54k|  constexpr const ElemT<I>& get() const& {
  250|  7.54k|    return StorageT<I>::get();
  251|  7.54k|  }
_ZN4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEEC2IS3_JS6_S9_SB_ETnNS7_9enable_ifIXsr3std11conjunctionINS7_8negationINS7_7is_sameIFvSC_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleISC_JSI_DpT0_EEEEE5valueEbE4typeELb1EEEOSI_DpOSP_:
  239|  1.44k|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|  1.44k|                                             std::forward<First>(first),
  241|  1.44k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS9_9allocatorIcEEEEENS9_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S8_SB_SD_EEENS9_10in_place_tEDpOT_:
  126|  5.76k|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|  5.76k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashImEENSt3__18equal_toImEENS9_9allocatorIcEEEEELb0EEC2IS4_EENS9_10in_place_tEOT_:
   90|  1.44k|      : value(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashImEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toImEENS9_9allocatorIcEEEEELb1EEC2IS6_EENS9_10in_place_tEOT_:
  102|  1.44k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__18equal_toImEELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashImEES6_NS4_9allocatorIcEEEEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  1.44k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENS4_8equal_toImEES6_EEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  1.44k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashImEENSt3__18equal_toImEENS9_9allocatorIcEEEEELb0EE3getEv:
   91|  37.8M|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|  37.8M|  constexpr const ElemT<I>& get() const& {
  250|  37.8M|    return StorageT<I>::get();
  251|  37.8M|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashImEENSt3__18equal_toImEENS9_9allocatorIcEEEEELb0EE3getEv:
   92|  15.3M|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|  15.3M|  constexpr ElemT<I>& get() & {
  245|  15.3M|    return StorageT<I>::get();
  246|  15.3M|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENS4_8equal_toImEES6_EEELb1EE3getEv:
  105|   713k|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|   713k|  constexpr ElemT<I>& get() & {
  245|   713k|    return StorageT<I>::get();
  246|   713k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorImEELm1ENS2_10StorageTagIJNS1_19key_compare_adapterINS4_4lessImEEmE15checked_compareES6_PNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEELb1EE3getEv:
  105|  4.57M|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENS4_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISG_XT_EE4typeEv:
  244|  4.57M|  constexpr ElemT<I>& get() & {
  245|  4.57M|    return StorageT<I>::get();
  246|  4.57M|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_15set_params_implImJEEEEELm2ENS2_10StorageTagIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENSB_9allocatorImEES8_EEELb0EE3getEv:
   92|  7.63M|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENS4_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEE3getILi2EEERNS1_25internal_compressed_tuple4ElemISG_XT_EE4typeEv:
  244|  7.63M|  constexpr ElemT<I>& get() & {
  245|  7.63M|    return StorageT<I>::get();
  246|  7.63M|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   91|   133M|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|   133M|  constexpr const ElemT<I>& get() const& {
  250|   133M|    return StorageT<I>::get();
  251|   133M|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   92|  48.2M|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|  48.2M|  constexpr ElemT<I>& get() & {
  245|  48.2M|    return StorageT<I>::get();
  246|  48.2M|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EE3getEv:
  105|  10.3M|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|  10.3M|  constexpr ElemT<I>& get() & {
  245|  10.3M|    return StorageT<I>::get();
  246|  10.3M|  }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS7_9allocatorIcEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|   471M|  constexpr const ElemT<I>& get() const& {
  250|   471M|    return StorageT<I>::get();
  251|   471M|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS9_9allocatorIcEEEEELb0EE3getEv:
   91|   471M|  constexpr const T& get() const& { return value; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS7_9allocatorIcEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|   171M|  constexpr ElemT<I>& get() & {
  245|   171M|    return StorageT<I>::get();
  246|   171M|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS9_9allocatorIcEEEEELb0EE3getEv:
   92|   171M|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS7_9allocatorIcEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|  1.63M|  constexpr ElemT<I>& get() & {
  245|  1.63M|    return StorageT<I>::get();
  246|  1.63M|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEENS4_8equal_toIDiEES6_EEELb1EE3getEv:
  105|  1.63M|  constexpr T& get() & { return *this; }
_ZN4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorIjEEmEEC2IS5_JjETnNS3_9enable_ifIXsr3std11conjunctionINS3_8negationINS3_7is_sameIFvS6_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS6_JSC_DpT0_EEEEE5valueEbE4typeELb1EEEOSC_DpOSJ_:
  239|  1.25k|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|  1.25k|                                             std::forward<First>(first),
  241|  1.25k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNSt3__19allocatorIjEEmEEENS5_16integer_sequenceImJLm0ELm1EEEELb1EEC2IJS7_jEEENS5_10in_place_tEDpOT_:
  126|  2.51k|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|  2.51k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIjEELm0ENS2_10StorageTagIJS6_mEEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  1.25k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIjEEmEEELb0EEC2IjEENS5_10in_place_tEOT_:
   90|  1.25k|      : value(std::forward<V>(v)) {}
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorIjEEmEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS6_XT_EE4typeEv:
  244|  1.25k|  constexpr ElemT<I>& get() & {
  245|  1.25k|    return StorageT<I>::get();
  246|  1.25k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIjEELm0ENS2_10StorageTagIJS6_mEEELb1EE3getEv:
  105|  1.25k|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNSt3__19allocatorIjEEmEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS6_XT_EE4typeEv:
  244|  2.51k|  constexpr ElemT<I>& get() & {
  245|  2.51k|    return StorageT<I>::get();
  246|  2.51k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageImLm1ENS2_10StorageTagIJNSt3__19allocatorIjEEmEEELb0EE3getEv:
   92|  2.51k|  constexpr T& get() & { return value; }
_ZN4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS7_9allocatorIcEEEEC2IS3_JS6_S9_SB_ETnNS7_9enable_ifIXsr3std11conjunctionINS7_8negationINS7_7is_sameIFvSC_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleISC_JSI_DpT0_EEEEE5valueEbE4typeELb1EEEOSI_DpOSP_:
  239|  17.0k|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|  17.0k|                                             std::forward<First>(first),
  241|  17.0k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS9_9allocatorIcEEEEENS9_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S8_SB_SD_EEENS9_10in_place_tEDpOT_:
  126|  68.3k|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|  68.3k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS9_9allocatorIcEEEEELb0EEC2IS4_EENS9_10in_place_tEOT_:
   90|  17.0k|      : value(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashIDiEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toIDiEENS9_9allocatorIcEEEEELb1EEC2IS6_EENS9_10in_place_tEOT_:
  102|  17.0k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__18equal_toIDiEELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEES6_NS4_9allocatorIcEEEEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  17.0k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEENS4_8equal_toIDiEES6_EEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  17.0k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS7_9allocatorIcEEEE3getILi2EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|  57.4M|  constexpr const ElemT<I>& get() const& {
  250|  57.4M|    return StorageT<I>::get();
  251|  57.4M|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__18equal_toIDiEELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEES6_NS4_9allocatorIcEEEEELb1EE3getEv:
  104|  57.4M|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS7_9allocatorIcEEEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|  60.2M|  constexpr const ElemT<I>& get() const& {
  250|  60.2M|    return StorageT<I>::get();
  251|  60.2M|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashIDiEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toIDiEENS9_9allocatorIcEEEEELb1EE3getEv:
  104|  60.2M|  constexpr const T& get() const& { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashIDiEENSt3__18equal_toIDiEENS7_9allocatorIcEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|  25.3k|  constexpr ElemT<I>& get() & {
  245|  25.3k|    return StorageT<I>::get();
  246|  25.3k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashIDiEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toIDiEENS9_9allocatorIcEEEEELb1EE3getEv:
  105|  25.3k|  constexpr T& get() & { return *this; }
_ZN4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEC2IS3_JS4_S5_S8_ETnNS6_9enable_ifIXsr3std11conjunctionINS6_8negationINS6_7is_sameIFvS9_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS9_JSF_DpT0_EEEEE5valueEbE4typeELb1EEEOSF_DpOSM_:
  239|  54.9k|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|  54.9k|                                             std::forward<First>(first),
  241|  54.9k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S6_S7_SA_EEENS8_10in_place_tEDpOT_:
  126|   219k|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|   219k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EEC2IS4_EENS8_10in_place_tEOT_:
   90|  60.8k|      : value(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EEC2IS4_EENS8_10in_place_tEOT_:
  102|  54.9k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EEC2IS4_EENS8_10in_place_tEOT_:
  102|  54.9k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|  54.9k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026052618container_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_2026052618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EE3getEv:
  104|  11.9M|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|  19.9M|  constexpr const ElemT<I>& get() const& {
  250|  19.9M|    return StorageT<I>::get();
  251|  19.9M|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  104|  19.9M|  constexpr const T& get() const& { return *this; }
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|  66.1k|  constexpr ElemT<I>& get() & {
  245|  66.1k|    return StorageT<I>::get();
  246|  66.1k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  105|  66.1k|  constexpr T& get() & { return *this; }
_ZN4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEC2IS3_JRKS4_RKS5_RKNS7_INS6_4pairIKNS6_12basic_stringIcNS6_11char_traitsIcEES8_EEfEEEEETnNS6_9enable_ifIXsr3std11conjunctionINS6_8negationINS6_7is_sameIFvS9_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS9_JST_DpT0_EEEEE5valueEbE4typeELb1EEEOST_DpOS10_:
  239|  5.83k|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|  5.83k|                                             std::forward<First>(first),
  241|  5.83k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_RKS6_RKS7_RKNS9_INS8_4pairIKNS8_12basic_stringIcNS8_11char_traitsIcEESA_EEfEEEEEEENS8_10in_place_tEDpOT_:
  126|  23.3k|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|  23.3k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EEC2IRKS4_EENS8_10in_place_tEOT_:
  102|  5.83k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EEC2IRKS4_EENS8_10in_place_tEOT_:
  102|  5.83k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EEC2IRKNS5_INS4_4pairIKNS4_12basic_stringIcNS4_11char_traitsIcEES6_EEfEEEEEENS4_10in_place_tEOT_:
  102|  5.83k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi2EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|  4.23M|  constexpr const ElemT<I>& get() const& {
  250|  4.23M|    return StorageT<I>::get();
  251|  4.23M|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__18equal_toImEELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS0_13hash_internal4HashImEES6_NS4_9allocatorIcEEEEELb1EE3getEv:
  104|  4.23M|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  249|  5.22M|  constexpr const ElemT<I>& get() const& {
  250|  5.22M|    return StorageT<I>::get();
  251|  5.22M|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashImEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toImEENS9_9allocatorIcEEEEELb1EE3getEv:
  104|  5.22M|  constexpr const T& get() const& { return *this; }
_ZN4absl12lts_2026052618container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENS4_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEC2IRKS8_JRKSA_SF_ETnNS4_9enable_ifIXsr3std11conjunctionINS4_8negationINS4_7is_sameIFvSG_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleISG_JSQ_DpT0_EEEEE5valueEbE4typeELb1EEEOSQ_DpOSX_:
  239|   293k|      : CompressedTuple::CompressedTupleImpl(std::in_place,
  240|   293k|                                             std::forward<First>(first),
  241|   293k|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENS6_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEENS6_16integer_sequenceImJLm0ELm1ELm2EEEELb1EEC2IJRKSA_RKSC_SH_EEENS6_10in_place_tEDpOT_:
  126|   880k|      : Storage<Ts, I, StorageTag<Ts...>>(std::in_place,
  127|   880k|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareELm0ENS2_10StorageTagIJS9_NS5_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEELb1EEC2IRKS9_EENS5_10in_place_tEOT_:
  102|   293k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINSt3__19allocatorImEELm1ENS2_10StorageTagIJNS1_19key_compare_adapterINS4_4lessImEEmE15checked_compareES6_PNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEELb1EEC2IRKS6_EENS4_10in_place_tEOT_:
  102|   293k|  explicit constexpr Storage(std::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageIPNS1_10btree_nodeINS1_15set_params_implImJEEEEELm2ENS2_10StorageTagIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENSB_9allocatorImEES8_EEELb0EEC2IS8_EENSB_10in_place_tEOT_:
   90|   293k|      : value(std::forward<V>(v)) {}
_ZNR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_12CommonFieldsENS0_13hash_internal4HashImEENSt3__18equal_toImEENS7_9allocatorIcEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemISC_XT_EE4typeEv:
  244|  1.42k|  constexpr ElemT<I>& get() & {
  245|  1.42k|    return StorageT<I>::get();
  246|  1.42k|  }
_ZNR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS0_13hash_internal4HashImEELm1ENS2_10StorageTagIJNS1_12CommonFieldsES6_NSt3__18equal_toImEENS9_9allocatorIcEEEEELb1EE3getEv:
  105|  1.42k|  constexpr T& get() & { return *this; }
_ZNKR4absl12lts_2026052618container_internal15CompressedTupleIJNS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareENS4_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemISG_XT_EE4typeEv:
  249|  3.67M|  constexpr const ElemT<I>& get() const& {
  250|  3.67M|    return StorageT<I>::get();
  251|  3.67M|  }
_ZNKR4absl12lts_2026052618container_internal25internal_compressed_tuple7StorageINS1_19key_compare_adapterINSt3__14lessImEEmE15checked_compareELm0ENS2_10StorageTagIJS9_NS5_9allocatorImEEPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEELb1EE3getEv:
  104|  3.67M|  constexpr const T& get() const& { return *this; }

_ZN4absl12lts_2026052618container_internal27SanitizerPoisonMemoryRegionEPKvm:
  240|  19.9M|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|  19.9M|  (void)m;
  248|  19.9M|  (void)s;
  249|  19.9M|}
_ZN4absl12lts_2026052618container_internal29SanitizerUnpoisonMemoryRegionEPKvm:
  251|  24.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|  24.2M|  (void)m;
  259|  24.2M|  (void)s;
  260|  24.2M|}
_ZN4absl12lts_2026052618container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKmPN13sentencepiece3bpe7Trainer6SymbolEEEEESC_EEDav:
   81|  47.5k|constexpr auto IsDestructionTrivial() {
   82|  47.5k|  constexpr bool result =
   83|  47.5k|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [True: 0, Folded]
  ------------------
   84|      0|      std::is_same<typename std::allocator_traits<
  ------------------
  |  Branch (84:7): [True: 0, Folded]
  ------------------
   85|      0|                       Allocator>::template rebind_alloc<char>,
   86|      0|                   std::allocator<char>>::value;
   87|  47.5k|  return std::integral_constant<bool, result>();
   88|  47.5k|}
_ZN4absl12lts_2026052618container_internal15map_slot_policyImPN13sentencepiece3bpe7Trainer6SymbolEE7destroyINSt3__19allocatorINSA_4pairIKmS7_EEEEEEDaPT_PNS1_13map_slot_typeImS7_EE:
  431|  47.5k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|  47.5k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 47.5k, Folded]
  ------------------
  433|  47.5k|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|  47.5k|    } else {
  435|      0|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|  47.5k|    return IsDestructionTrivial<Allocator, value_type>();
  438|  47.5k|  }
_ZN4absl12lts_2026052618container_internal21SanitizerPoisonObjectImEEvPKT_:
  263|  13.9M|inline void SanitizerPoisonObject(const T* object) {
  264|  13.9M|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  265|  13.9M|}
_ZN4absl12lts_2026052618container_internal10DeallocateILm8ENSt3__19allocatorImEEEEvPT0_Pvm:
   93|   555k|void Deallocate(Alloc* alloc, void* p, size_t n) {
   94|   555k|  static_assert(Alignment > 0, "");
   95|   555k|  assert(n && "n must be positive");
   96|   555k|  using M = AlignedType<Alignment>;
   97|   555k|  using A = typename std::allocator_traits<Alloc>::template rebind_alloc<M>;
   98|   555k|  using AT = typename std::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|   555k|  A my_mem_alloc(*alloc);
  103|   555k|  AT::deallocate(my_mem_alloc, static_cast<M*>(p),
  104|   555k|                 (n + sizeof(M) - 1) / sizeof(M));
  105|   555k|}
_ZN4absl12lts_2026052618container_internal15map_slot_policyIDilE7destroyINSt3__19allocatorINS5_4pairIKDilEEEEEEDaPT_PNS1_13map_slot_typeIDilEE:
  431|     83|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|     83|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 83, Folded]
  ------------------
  433|     83|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|     83|    } else {
  435|      0|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|     83|    return IsDestructionTrivial<Allocator, value_type>();
  438|     83|  }
_ZN4absl12lts_2026052618container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKDilEEEES7_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 std::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_2026052618container_internal15map_slot_policyIDiNSt3__14pairIblEEE7destroyINS3_9allocatorINS4_IKDiS5_EEEEEEDaPT_PNS1_13map_slot_typeIDiS5_EE:
  431|   403k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|   403k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 403k, Folded]
  ------------------
  433|   403k|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|   403k|    } else {
  435|      0|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|   403k|    return IsDestructionTrivial<Allocator, value_type>();
  438|   403k|  }
_ZN4absl12lts_2026052618container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKDiNS5_IblEEEEEES8_EEDav:
   81|   403k|constexpr auto IsDestructionTrivial() {
   82|   403k|  constexpr bool result =
   83|   403k|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [True: 0, Folded]
  ------------------
   84|      0|      std::is_same<typename std::allocator_traits<
  ------------------
  |  Branch (84:7): [True: 0, Folded]
  ------------------
   85|      0|                       Allocator>::template rebind_alloc<char>,
   86|      0|                   std::allocator<char>>::value;
   87|   403k|  return std::integral_constant<bool, result>();
   88|   403k|}
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE7destroyINS7_INS3_4pairIKS9_lEEEEEEDaPT_PNS1_13map_slot_typeIS9_lEE:
  431|  5.18M|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|  5.18M|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 5.18M, Folded]
  ------------------
  433|  5.18M|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|  5.18M|    } else {
  435|      0|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|  5.18M|    return IsDestructionTrivial<Allocator, value_type>();
  438|  5.18M|  }
_ZN4absl12lts_2026052618container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKNS3_12basic_stringIcNS3_11char_traitsIcEENS4_IcEEEElEEEESC_EEDav:
   81|  5.18M|constexpr auto IsDestructionTrivial() {
   82|  5.18M|  constexpr bool result =
   83|  5.18M|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [Folded, False: 5.18M]
  ------------------
   84|      0|      std::is_same<typename std::allocator_traits<
  ------------------
  |  Branch (84:7): [True: 0, Folded]
  ------------------
   85|      0|                       Allocator>::template rebind_alloc<char>,
   86|      0|                   std::allocator<char>>::value;
   87|  5.18M|  return std::integral_constant<bool, result>();
   88|  5.18M|}
_ZN4absl12lts_2026052618container_internal20IsDestructionTrivialINSt3__19allocatorINS3_12basic_stringIcNS3_11char_traitsIcEENS4_IcEEEEEES9_EEDav:
   81|   990k|constexpr auto IsDestructionTrivial() {
   82|   990k|  constexpr bool result =
   83|   990k|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [Folded, False: 990k]
  ------------------
   84|      0|      std::is_same<typename std::allocator_traits<
  ------------------
  |  Branch (84:7): [True: 0, Folded]
  ------------------
   85|      0|                       Allocator>::template rebind_alloc<char>,
   86|      0|                   std::allocator<char>>::value;
   87|   990k|  return std::integral_constant<bool, result>();
   88|   990k|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12EqualElementIDiNSt3__18equal_toIDiEEEEJRNS4_4pairIKDiNS8_IblEEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSD_DpOSE_:
  226|  8.48M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  8.48M|  return memory_internal::DecomposePairImpl(
  228|  8.48M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  8.48M|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_12EqualElementIDiNSt3__18equal_toIDiEEEERKDiNS5_5tupleIJRKNS5_4pairIblEEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSB_IJSI_EEEEEclsr3stdE7declvalIT1_EEEEOSH_NSC_ISL_SM_EE:
  158|  8.48M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  8.48M|  const auto& key = std::get<0>(p.first);
  160|  8.48M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  8.48M|                            std::move(p.second));
  162|  8.48M|}
_ZNK4absl12lts_2026052618container_internal12EqualElementIDiNSt3__18equal_toIDiEEEclIDiJRKNS3_21piecewise_construct_tENS3_5tupleIJRKDiEEENSB_IJRKNS3_4pairIblEEEEEEEEbRKT_DpOT0_:
  529|  8.48M|  bool operator()(const K2& lhs, Args&&...) const {
  530|  8.48M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  8.48M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  8.48M|  }
_ZN4absl12lts_2026052618container_internal8PairArgsIKDiNSt3__14pairIblEEEENS5_INS4_5tupleIJRKT_EEENS7_IJRKT0_EEEEERKNS5_IS8_SC_EE:
  207|  8.81M|    const std::pair<F, S>& p) {
  208|  8.81M|  return PairArgs(p.first, p.second);
  209|  8.81M|}
_ZN4absl12lts_2026052618container_internal8PairArgsIRKDiRKNSt3__14pairIblEEEENS6_INS5_5tupleIJOT_EEENSA_IJOT0_EEEEESC_SF_:
  201|  8.81M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  8.81M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  8.81M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  8.81M|}
_ZN4absl12lts_2026052618container_internal23TypeErasedApplyToSlotFnINS0_13hash_internal4HashIDiEEDiLb1EEEmPKvPvm:
  542|  16.8k|size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
  543|  16.8k|  const auto* f = static_cast<const Fn*>(fn);
  544|  16.8k|  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
  545|  16.8k|}
_ZN4absl12lts_2026052618container_internal11HashElementINS0_13hash_internal4HashIDiEELb1EEC2ERKS5_m:
  495|  60.2M|  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
_ZNK4absl12lts_2026052618container_internal11HashElementINS0_13hash_internal4HashIDiEELb1EEclIDiJEEEmRKT_DpOT0_:
  498|  59.4M|  size_t operator()(const K& key, Args&&...) const {
  499|  59.4M|    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|  59.4M|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|  59.4M|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|  59.4M|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyIDiNSt3__14pairIblEEE8transferINS3_9allocatorINS4_IKDiS5_EEEEEEDaPT_PNS1_13map_slot_typeIDiS5_EESG_:
  442|   403k|                       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|   403k|    auto is_relocatable = typename std::conjunction<
  449|   403k|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|   403k|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|   403k|        type();
  452|       |
  453|   403k|    emplace(new_slot);
  454|   403k|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [Folded, False: 403k]
  ------------------
  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|   403k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 403k, Folded]
  ------------------
  463|   403k|      std::allocator_traits<Allocator>::construct(
  464|   403k|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|   403k|    } else {
  466|      0|      std::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                  std::move(old_slot->value));
  468|      0|    }
  469|   403k|    destroy(alloc, old_slot);
  470|   403k|    return is_relocatable;
  471|   403k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyIDiNSt3__14pairIblEEE7emplaceEPNS1_13map_slot_typeIDiS5_EE:
  368|   703k|  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|   703k|    new (slot) slot_type;
  372|   703k|  }
_ZN4absl12lts_2026052618container_internal13map_slot_typeIDiNSt3__14pairIblEEEC2Ev:
  349|   703k|  map_slot_type() {}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEEJRNSt3__14pairIKDiNS9_IblEEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSE_DpOSF_:
  226|   328k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   328k|  return memory_internal::DecomposePairImpl(
  228|   328k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   328k|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEERKDiNSt3__15tupleIJRKNSB_4pairIblEEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSB_19piecewise_constructEEclsr3stdE7declvalINSC_IJSJ_EEEEEclsr3stdE7declvalIT1_EEEEOSI_NSD_ISM_SN_EE:
  158|   328k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   328k|  const auto& key = std::get<0>(p.first);
  160|   328k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   328k|                            std::move(p.second));
  162|   328k|}
_ZNK4absl12lts_2026052618container_internal11HashElementINS0_13hash_internal4HashIDiEELb1EEclIDiJRKNSt3__121piecewise_construct_tENS8_5tupleIJRKDiEEENSC_IJRKNS8_4pairIblEEEEEEEEmRKT_DpOT0_:
  498|   328k|  size_t operator()(const K& key, Args&&...) const {
  499|   328k|    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|   328k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   328k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   328k|  }
_ZN4absl12lts_2026052618container_internal7HashKeyINS0_13hash_internal4HashIDiEEDiLb1EEC2ERKS5_RKDi:
  515|  25.3k|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026052618container_internal7HashKeyINS0_13hash_internal4HashIDiEEDiLb1EEclEm:
  517|  16.8k|  size_t operator()(size_t seed) const {
  518|  16.8k|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|  16.8k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyIDiNSt3__14pairIblEEE9constructINS3_9allocatorINS4_IKDiS5_EEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRS9_EEENSF_IJEEEEEEvPT_PNS1_13map_slot_typeIDiS5_EEDpOT0_:
  397|   300k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   300k|    emplace(slot);
  399|   300k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 300k, Folded]
  ------------------
  400|   300k|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   300k|                                                  std::forward<Args>(args)...);
  402|   300k|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|   300k|  }
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE19EmplaceDecomposableEJRKDiRKlEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSC_DpOSD_:
  226|   272k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   272k|  return memory_internal::DecomposePairImpl(
  228|   272k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   272k|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE19EmplaceDecomposableERKDiNSt3__15tupleIJRKlEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSB_19piecewise_constructEEclsr3stdE7declvalINSC_IJSH_EEEEEclsr3stdE7declvalIT1_EEEEOSG_NSB_4pairISK_SL_EE:
  158|   272k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   272k|  const auto& key = std::get<0>(p.first);
  160|   272k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   272k|                            std::move(p.second));
  162|   272k|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12EqualElementIDiNSt3__18equal_toIDiEEEEJRNS4_4pairIKDilEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSC_DpOSD_:
  226|  9.84M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  9.84M|  return memory_internal::DecomposePairImpl(
  228|  9.84M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  9.84M|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_12EqualElementIDiNSt3__18equal_toIDiEEEERKDiNS5_5tupleIJRKlEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSB_IJSG_EEEEEclsr3stdE7declvalIT1_EEEEOSF_NS5_4pairISJ_SK_EE:
  158|  9.84M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  9.84M|  const auto& key = std::get<0>(p.first);
  160|  9.84M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  9.84M|                            std::move(p.second));
  162|  9.84M|}
_ZNK4absl12lts_2026052618container_internal12EqualElementIDiNSt3__18equal_toIDiEEEclIDiJRKNS3_21piecewise_construct_tENS3_5tupleIJRKDiEEENSB_IJRKlEEEEEEbRKT_DpOT0_:
  529|  9.84M|  bool operator()(const K2& lhs, Args&&...) const {
  530|  9.84M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  9.84M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  9.84M|  }
_ZN4absl12lts_2026052618container_internal8PairArgsIKDilEENSt3__14pairINS4_5tupleIJRKT_EEENS6_IJRKT0_EEEEERKNS5_IS7_SB_EE:
  207|  10.1M|    const std::pair<F, S>& p) {
  208|  10.1M|  return PairArgs(p.first, p.second);
  209|  10.1M|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEEJRNSt3__14pairIKDilEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSD_DpOSE_:
  226|   284k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   284k|  return memory_internal::DecomposePairImpl(
  228|   284k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   284k|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEERKDiNSt3__15tupleIJRKlEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSB_19piecewise_constructEEclsr3stdE7declvalINSC_IJSH_EEEEEclsr3stdE7declvalIT1_EEEEOSG_NSB_4pairISK_SL_EE:
  158|   284k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   284k|  const auto& key = std::get<0>(p.first);
  160|   284k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   284k|                            std::move(p.second));
  162|   284k|}
_ZNK4absl12lts_2026052618container_internal11HashElementINS0_13hash_internal4HashIDiEELb1EEclIDiJRKNSt3__121piecewise_construct_tENS8_5tupleIJRKDiEEENSC_IJRKlEEEEEEmRKT_DpOT0_:
  498|   284k|  size_t operator()(const K& key, Args&&...) const {
  499|   284k|    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|   284k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   284k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   284k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyIDilE8transferINSt3__19allocatorINS5_4pairIKDilEEEEEEDaPT_PNS1_13map_slot_typeIDilEESF_:
  442|   282k|                       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|   282k|    auto is_relocatable = typename std::conjunction<
  449|   282k|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|   282k|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|   282k|        type();
  452|       |
  453|   282k|    emplace(new_slot);
  454|   282k|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [True: 282k, Folded]
  ------------------
  455|       |      // TODO(b/247130232,b/251814870): remove casts after fixing warnings.
  456|   282k|      std::memcpy(static_cast<void*>(std::launder(&new_slot->value)),
  457|   282k|                  static_cast<const void*>(&old_slot->value),
  458|   282k|                  sizeof(value_type));
  459|   282k|      return is_relocatable;
  460|   282k|    }
  461|       |
  462|      0|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 0, Folded]
  ------------------
  463|      0|      std::allocator_traits<Allocator>::construct(
  464|      0|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|      0|    } else {
  466|      0|      std::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|   282k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyIDilE7emplaceEPNS1_13map_slot_typeIDilEE:
  368|   554k|  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|   554k|    new (slot) slot_type;
  372|   554k|  }
_ZN4absl12lts_2026052618container_internal13map_slot_typeIDilEC2Ev:
  349|   554k|  map_slot_type() {}
_ZN4absl12lts_2026052618container_internal15map_slot_policyIDilE9constructINSt3__19allocatorINS5_4pairIKDilEEEEJRKNS5_21piecewise_construct_tENS5_5tupleIJRS8_EEENSE_IJRKlEEEEEEvPT_PNS1_13map_slot_typeIDilEEDpOT0_:
  397|   272k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   272k|    emplace(slot);
  399|   272k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 272k, Folded]
  ------------------
  400|   272k|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   272k|                                                  std::forward<Args>(args)...);
  402|   272k|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|   272k|  }
_ZN4absl12lts_2026052618container_internal8PairArgsIRKDiRKlEENSt3__14pairINS7_5tupleIJOT_EEENS9_IJOT0_EEEEESB_SE_:
  201|  10.3M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  10.3M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  10.3M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  10.3M|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12EqualElementINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS1_8StringEqEEEJRNS4_4pairIKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEElEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  226|   122k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   122k|  return memory_internal::DecomposePairImpl(
  228|   122k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   122k|}
_ZN4absl12lts_2026052618container_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|   122k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   122k|  const auto& key = std::get<0>(p.first);
  160|   122k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   122k|                            std::move(p.second));
  162|   122k|}
_ZNK4absl12lts_2026052618container_internal12EqualElementINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_8StringEqEEclINS3_12basic_stringIcS6_NS3_9allocatorIcEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKSE_EEENSI_IJRKlEEEEEEbRKT_DpOT0_:
  529|   122k|  bool operator()(const K2& lhs, Args&&...) const {
  530|   122k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|   122k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|   122k|  }
_ZN4absl12lts_2026052618container_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_2026052618container_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_2026052618container_internal23TypeErasedApplyToSlotFnINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEEmPKvPvm:
  542|  31.9k|size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
  543|  31.9k|  const auto* f = static_cast<const Fn*>(fn);
  544|  31.9k|  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
  545|  31.9k|}
_ZN4absl12lts_2026052618container_internal11HashElementINS1_10StringHashELb1EEC2ERKS3_m:
  495|  19.9M|  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
_ZNK4absl12lts_2026052618container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJEEEmRKT_DpOT0_:
  498|  15.8M|  size_t operator()(const K& key, Args&&...) const {
  499|  15.8M|    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.8M|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|  15.8M|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|  15.8M|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE8transferINS7_INS3_4pairIKS9_lEEEEEEDaPT_PNS1_13map_slot_typeIS9_lEESK_:
  442|  3.04M|                       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.04M|    auto is_relocatable = typename std::conjunction<
  449|  3.04M|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|  3.04M|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|  3.04M|        type();
  452|       |
  453|  3.04M|    emplace(new_slot);
  454|  3.04M|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [Folded, False: 3.04M]
  ------------------
  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.04M|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 3.04M, Folded]
  ------------------
  463|  3.04M|      std::allocator_traits<Allocator>::construct(
  464|  3.04M|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|  3.04M|    } else {
  466|      0|      std::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                  std::move(old_slot->value));
  468|      0|    }
  469|  3.04M|    destroy(alloc, old_slot);
  470|  3.04M|    return is_relocatable;
  471|  3.04M|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE7emplaceEPNS1_13map_slot_typeIS9_lEE:
  368|  5.18M|  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.18M|    new (slot) slot_type;
  372|  5.18M|  }
_ZN4absl12lts_2026052618container_internal13map_slot_typeINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElEC2Ev:
  349|  5.18M|  map_slot_type() {}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_11HashElementINS1_10StringHashELb1EEEJRNSt3__14pairIKNS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|  2.90M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  2.90M|  return memory_internal::DecomposePairImpl(
  228|  2.90M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  2.90M|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS1_10StringHashELb1EEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENS7_5tupleIJRKlEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS7_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS7_4pairISO_SP_EE:
  158|  2.90M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  2.90M|  const auto& key = std::get<0>(p.first);
  160|  2.90M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  2.90M|                            std::move(p.second));
  162|  2.90M|}
_ZNK4absl12lts_2026052618container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSG_IJRKlEEEEEEmRKT_DpOT0_:
  498|  2.90M|  size_t operator()(const K& key, Args&&...) const {
  499|  2.90M|    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.90M|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|  2.90M|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|  2.90M|  }
_ZN4absl12lts_2026052618container_internal7HashKeyINS1_10StringHashENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEELb1EEC2ERKS3_RKS8_:
  515|  12.7k|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026052618container_internal7HashKeyINS1_10StringHashENSt3__117basic_string_viewIcNS4_11char_traitsIcEEEELb1EEclEm:
  517|  5.50k|  size_t operator()(size_t seed) const {
  518|  5.50k|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|  5.50k|  }
_ZNK4absl12lts_2026052618container_internal11HashElementINS1_10StringHashELb1EEclINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEEmRKT_DpOT0_:
  498|   433k|  size_t operator()(const K& key, Args&&...) const {
  499|   433k|    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|   433k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   433k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   433k|  }
_ZN4absl12lts_2026052618container_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|   193k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   193k|    emplace(slot);
  399|   193k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 193k, Folded]
  ------------------
  400|   193k|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   193k|                                                  std::forward<Args>(args)...);
  402|   193k|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|   193k|  }
_ZN4absl12lts_2026052618container_internal14DecomposeValueINS1_12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEJEE19EmplaceDecomposableERKSB_EEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEclsr3stdE7declvalISI_EEEEOSH_OSI_:
  234|   374k|DecomposeValue(F&& f, Arg&& arg) {
  235|   374k|  const auto& key = arg;
  236|   374k|  return std::forward<F>(f)(key, std::forward<Arg>(arg));
  237|   374k|}
_ZN4absl12lts_2026052618container_internal14DecomposeValueINS1_12EqualElementINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_8StringEqEEERSA_EEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEclsr3stdE7declvalISF_EEEEOSE_OSF_:
  234|  38.1k|DecomposeValue(F&& f, Arg&& arg) {
  235|  38.1k|  const auto& key = arg;
  236|  38.1k|  return std::forward<F>(f)(key, std::forward<Arg>(arg));
  237|  38.1k|}
_ZNK4absl12lts_2026052618container_internal12EqualElementINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS1_8StringEqEEclIS9_JRS9_EEEbRKT_DpOT0_:
  529|  38.1k|  bool operator()(const K2& lhs, Args&&...) const {
  530|  38.1k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  38.1k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  38.1k|  }
_ZN4absl12lts_2026052618container_internal14DecomposeValueINS1_11HashElementINS1_10StringHashELb1EEERNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEclsr3stdE7declvalISF_EEEEOSE_OSF_:
  234|   468k|DecomposeValue(F&& f, Arg&& arg) {
  235|   468k|  const auto& key = arg;
  236|   468k|  return std::forward<F>(f)(key, std::forward<Arg>(arg));
  237|   468k|}
_ZNK4absl12lts_2026052618container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJRSC_EEEmRKT_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_2026052618container_internal7HashKeyINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEC2ERKS3_RKSA_:
  515|  53.3k|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026052618container_internal7HashKeyINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEclEm:
  517|  26.4k|  size_t operator()(size_t seed) const {
  518|  26.4k|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|  26.4k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE8transferINS7_INS3_4pairIKS9_fEEEEEEDaPT_PNS1_13map_slot_typeIS9_fEESK_:
  442|   285k|                       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|   285k|    auto is_relocatable = typename std::conjunction<
  449|   285k|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|   285k|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|   285k|        type();
  452|       |
  453|   285k|    emplace(new_slot);
  454|   285k|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [Folded, False: 285k]
  ------------------
  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|   285k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 285k, Folded]
  ------------------
  463|   285k|      std::allocator_traits<Allocator>::construct(
  464|   285k|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|   285k|    } else {
  466|      0|      std::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                  std::move(old_slot->value));
  468|      0|    }
  469|   285k|    destroy(alloc, old_slot);
  470|   285k|    return is_relocatable;
  471|   285k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE7emplaceEPNS1_13map_slot_typeIS9_fEE:
  368|   743k|  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|   743k|    new (slot) slot_type;
  372|   743k|  }
_ZN4absl12lts_2026052618container_internal13map_slot_typeINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEC2Ev:
  349|   743k|  map_slot_type() {}
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE7destroyINS7_INS3_4pairIKS9_fEEEEEEDaPT_PNS1_13map_slot_typeIS9_fEE:
  431|   743k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|   743k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 743k, Folded]
  ------------------
  433|   743k|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|   743k|    } else {
  435|      0|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|   743k|    return IsDestructionTrivial<Allocator, value_type>();
  438|   743k|  }
_ZN4absl12lts_2026052618container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKNS3_12basic_stringIcNS3_11char_traitsIcEENS4_IcEEEEfEEEESC_EEDav:
   81|   743k|constexpr auto IsDestructionTrivial() {
   82|   743k|  constexpr bool result =
   83|   743k|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [Folded, False: 743k]
  ------------------
   84|      0|      std::is_same<typename std::allocator_traits<
  ------------------
  |  Branch (84:7): [True: 0, Folded]
  ------------------
   85|      0|                       Allocator>::template rebind_alloc<char>,
   86|      0|                   std::allocator<char>>::value;
   87|   743k|  return std::integral_constant<bool, result>();
   88|   743k|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_11HashElementINS1_10StringHashELb1EEEJRNSt3__14pairIKNS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|   231k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   231k|  return memory_internal::DecomposePairImpl(
  228|   231k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   231k|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS1_10StringHashELb1EEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENS7_5tupleIJRKfEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS7_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS7_4pairISO_SP_EE:
  158|   231k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   231k|  const auto& key = std::get<0>(p.first);
  160|   231k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   231k|                            std::move(p.second));
  162|   231k|}
_ZNK4absl12lts_2026052618container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSG_IJRKfEEEEEEmRKT_DpOT0_:
  498|   231k|  size_t operator()(const K& key, Args&&...) const {
  499|   231k|    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|   231k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   231k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   231k|  }
_ZN4absl12lts_2026052618container_internal8PairArgsIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE:
  207|   618k|    const std::pair<F, S>& p) {
  208|   618k|  return PairArgs(p.first, p.second);
  209|   618k|}
_ZN4absl12lts_2026052618container_internal8PairArgsIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKfEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_:
  201|   852k|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|   852k|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|   852k|          std::forward_as_tuple(std::forward<S>(s))};
  204|   852k|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEfEEJEE19EmplaceDecomposableEJRKNS5_4pairISB_fEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  226|   233k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   233k|  return memory_internal::DecomposePairImpl(
  228|   233k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   233k|}
_ZN4absl12lts_2026052618container_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|   233k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   233k|  const auto& key = std::get<0>(p.first);
  160|   233k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   233k|                            std::move(p.second));
  162|   233k|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12EqualElementINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_8StringEqEEEJRNS4_4pairIKSA_fEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|   386k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   386k|  return memory_internal::DecomposePairImpl(
  228|   386k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   386k|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS1_8StringEqEEERKSB_NS5_5tupleIJRKfEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS5_4pairISO_SP_EE:
  158|   386k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   386k|  const auto& key = std::get<0>(p.first);
  160|   386k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   386k|                            std::move(p.second));
  162|   386k|}
_ZNK4absl12lts_2026052618container_internal12EqualElementINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS1_8StringEqEEclIS9_JRKNS3_21piecewise_construct_tENS3_5tupleIJRKS9_EEENSG_IJRKfEEEEEEbRKT_DpOT0_:
  529|   386k|  bool operator()(const K2& lhs, Args&&...) const {
  530|   386k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|   386k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|   386k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE9constructINS7_INS3_4pairIKS9_fEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJRKfEEEEEEvPT_PNS1_13map_slot_typeIS9_fEEDpOT0_:
  397|   233k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   233k|    emplace(slot);
  399|   233k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 233k, Folded]
  ------------------
  400|   233k|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   233k|                                                  std::forward<Args>(args)...);
  402|   233k|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|   233k|  }
_ZN4absl12lts_2026052618container_internal8PairArgsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEENS3_4pairINS3_5tupleIJRKT_EEENSB_IJRKT0_EEEEERKNSA_ISC_SG_EE:
  207|   233k|    const std::pair<F, S>& p) {
  208|   233k|  return PairArgs(p.first, p.second);
  209|   233k|}
_ZN4absl12lts_2026052618container_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_2026052618container_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_2026052618container_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_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE9constructINS7_INS3_4pairIKS9_lEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOS9_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_lEEDpOT0_:
  397|   170k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   170k|    emplace(slot);
  399|   170k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 170k, Folded]
  ------------------
  400|   170k|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   170k|                                                  std::forward<Args>(args)...);
  402|   170k|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|   170k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEElE9constructINS7_INS3_4pairIKS9_lEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_lEEDpOT0_:
  397|  1.77M|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|  1.77M|    emplace(slot);
  399|  1.77M|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 1.77M, Folded]
  ------------------
  400|  1.77M|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|  1.77M|                                                  std::forward<Args>(args)...);
  402|  1.77M|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|  1.77M|  }
_ZN4absl12lts_2026052618container_internal21SanitizerPoisonObjectINS1_13map_slot_typeINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEEEvPKT_:
  263|    241|inline void SanitizerPoisonObject(const T* object) {
  264|    241|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  265|    241|}
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfE9constructINS7_INS3_4pairIKS9_fEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSD_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_fEEDpOT0_:
  397|   224k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   224k|    emplace(slot);
  399|   224k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 224k, Folded]
  ------------------
  400|   224k|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   224k|                                                  std::forward<Args>(args)...);
  402|   224k|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|   224k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE7destroyINS7_INS3_4pairIKS9_mEEEEEEDaPT_PNS1_13map_slot_typeIS9_mEE:
  431|   231k|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|   231k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 231k, Folded]
  ------------------
  433|   231k|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|   231k|    } else {
  435|      0|      std::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|   231k|    return IsDestructionTrivial<Allocator, value_type>();
  438|   231k|  }
_ZN4absl12lts_2026052618container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKNS3_12basic_stringIcNS3_11char_traitsIcEENS4_IcEEEEmEEEESC_EEDav:
   81|   231k|constexpr auto IsDestructionTrivial() {
   82|   231k|  constexpr bool result =
   83|   231k|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [Folded, False: 231k]
  ------------------
   84|      0|      std::is_same<typename std::allocator_traits<
  ------------------
  |  Branch (84:7): [True: 0, Folded]
  ------------------
   85|      0|                       Allocator>::template rebind_alloc<char>,
   86|      0|                   std::allocator<char>>::value;
   87|   231k|  return std::integral_constant<bool, result>();
   88|   231k|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12EqualElementINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS1_8StringEqEEEJRNS4_4pairIKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEmEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  226|  62.7k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  62.7k|  return memory_internal::DecomposePairImpl(
  228|  62.7k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  62.7k|}
_ZN4absl12lts_2026052618container_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|  62.7k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  62.7k|  const auto& key = std::get<0>(p.first);
  160|  62.7k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  62.7k|                            std::move(p.second));
  162|  62.7k|}
_ZNK4absl12lts_2026052618container_internal12EqualElementINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_8StringEqEEclINS3_12basic_stringIcS6_NS3_9allocatorIcEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKSE_EEENSI_IJRKmEEEEEEbRKT_DpOT0_:
  529|  62.7k|  bool operator()(const K2& lhs, Args&&...) const {
  530|  62.7k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  62.7k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  62.7k|  }
_ZN4absl12lts_2026052618container_internal8PairArgsIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE:
  207|   193k|    const std::pair<F, S>& p) {
  208|   193k|  return PairArgs(p.first, p.second);
  209|   193k|}
_ZN4absl12lts_2026052618container_internal8PairArgsIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKmEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_:
  201|   193k|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|   193k|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|   193k|          std::forward_as_tuple(std::forward<S>(s))};
  204|   193k|}
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE8transferINS7_INS3_4pairIKS9_mEEEEEEDaPT_PNS1_13map_slot_typeIS9_mEESK_:
  442|   138k|                       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|   138k|    auto is_relocatable = typename std::conjunction<
  449|   138k|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|   138k|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|   138k|        type();
  452|       |
  453|   138k|    emplace(new_slot);
  454|   138k|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [Folded, False: 138k]
  ------------------
  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|   138k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 138k, Folded]
  ------------------
  463|   138k|      std::allocator_traits<Allocator>::construct(
  464|   138k|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|   138k|    } else {
  466|      0|      std::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                  std::move(old_slot->value));
  468|      0|    }
  469|   138k|    destroy(alloc, old_slot);
  470|   138k|    return is_relocatable;
  471|   138k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmE7emplaceEPNS1_13map_slot_typeIS9_mEE:
  368|   231k|  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|   231k|    new (slot) slot_type;
  372|   231k|  }
_ZN4absl12lts_2026052618container_internal13map_slot_typeINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmEC2Ev:
  349|   231k|  map_slot_type() {}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_11HashElementINS1_10StringHashELb1EEEJRNSt3__14pairIKNS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEmEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|   130k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   130k|  return memory_internal::DecomposePairImpl(
  228|   130k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   130k|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS1_10StringHashELb1EEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENS7_5tupleIJRKmEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS7_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS7_4pairISO_SP_EE:
  158|   130k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   130k|  const auto& key = std::get<0>(p.first);
  160|   130k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   130k|                            std::move(p.second));
  162|   130k|}
_ZNK4absl12lts_2026052618container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSG_IJRKmEEEEEEmRKT_DpOT0_:
  498|   130k|  size_t operator()(const K& key, Args&&...) const {
  499|   130k|    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|   130k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   130k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   130k|  }
_ZN4absl12lts_2026052618container_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|  93.3k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|  93.3k|    emplace(slot);
  399|  93.3k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 93.3k, Folded]
  ------------------
  400|  93.3k|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|  93.3k|                                                  std::forward<Args>(args)...);
  402|  93.3k|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|  93.3k|  }
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12EqualElementImNSt3__18equal_toImEEEEJRNS4_4pairIKmPN13sentencepiece3bpe7Trainer6SymbolEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|  4.23M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  4.23M|  return memory_internal::DecomposePairImpl(
  228|  4.23M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  4.23M|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_12EqualElementImNSt3__18equal_toImEEEERKmNS5_5tupleIJRKPN13sentencepiece3bpe7Trainer6SymbolEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSB_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS5_4pairISO_SP_EE:
  158|  4.23M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  4.23M|  const auto& key = std::get<0>(p.first);
  160|  4.23M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  4.23M|                            std::move(p.second));
  162|  4.23M|}
_ZNK4absl12lts_2026052618container_internal12EqualElementImNSt3__18equal_toImEEEclImJRKNS3_21piecewise_construct_tENS3_5tupleIJRKmEEENSB_IJRKPN13sentencepiece3bpe7Trainer6SymbolEEEEEEEbRKT_DpOT0_:
  529|  4.23M|  bool operator()(const K2& lhs, Args&&...) const {
  530|  4.23M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  4.23M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  4.23M|  }
_ZN4absl12lts_2026052618container_internal8PairArgsIKmPN13sentencepiece3bpe7Trainer6SymbolEEENSt3__14pairINS9_5tupleIJRKT_EEENSB_IJRKT0_EEEEERKNSA_ISC_SG_EE:
  207|  4.90M|    const std::pair<F, S>& p) {
  208|  4.90M|  return PairArgs(p.first, p.second);
  209|  4.90M|}
_ZN4absl12lts_2026052618container_internal8PairArgsIRKmRKPN13sentencepiece3bpe7Trainer6SymbolEEENSt3__14pairINSC_5tupleIJOT_EEENSE_IJOT0_EEEEESG_SJ_:
  201|  4.90M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  4.90M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  4.90M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  4.90M|}
_ZN4absl12lts_2026052618container_internal11HashElementINS0_13hash_internal4HashImEELb1EEC2ERKS5_m:
  495|  5.23M|  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
_ZNK4absl12lts_2026052618container_internal11HashElementINS0_13hash_internal4HashImEELb1EEclImJEEEmRKT_DpOT0_:
  498|  4.85M|  size_t operator()(const K& key, Args&&...) const {
  499|  4.85M|    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|  4.85M|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|  4.85M|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|  4.85M|  }
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE19EmplaceDecomposableEJRKNSt3__14pairIKmS9_EEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  226|   293k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   293k|  return memory_internal::DecomposePairImpl(
  228|   293k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   293k|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE19EmplaceDecomposableERKmNSt3__15tupleIJRKSA_EEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSG_19piecewise_constructEEclsr3stdE7declvalINSH_IJSM_EEEEEclsr3stdE7declvalIT1_EEEEOSL_NSG_4pairISP_SQ_EE:
  158|   293k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   293k|  const auto& key = std::get<0>(p.first);
  160|   293k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   293k|                            std::move(p.second));
  162|   293k|}
_ZN4absl12lts_2026052618container_internal23TypeErasedApplyToSlotFnINS0_13hash_internal4HashImEEmLb1EEEmPKvPvm:
  542|  2.02k|size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
  543|  2.02k|  const auto* f = static_cast<const Fn*>(fn);
  544|  2.02k|  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
  545|  2.02k|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_11HashElementINS0_13hash_internal4HashImEELb1EEEJRNSt3__14pairIKmPN13sentencepiece3bpe7Trainer6SymbolEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSI_DpOSJ_:
  226|   372k|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|   372k|  return memory_internal::DecomposePairImpl(
  228|   372k|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|   372k|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS0_13hash_internal4HashImEELb1EEERKmNSt3__15tupleIJRKPN13sentencepiece3bpe7Trainer6SymbolEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNSB_19piecewise_constructEEclsr3stdE7declvalINSC_IJSM_EEEEEclsr3stdE7declvalIT1_EEEEOSL_NSB_4pairISP_SQ_EE:
  158|   372k|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|   372k|  const auto& key = std::get<0>(p.first);
  160|   372k|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|   372k|                            std::move(p.second));
  162|   372k|}
_ZNK4absl12lts_2026052618container_internal11HashElementINS0_13hash_internal4HashImEELb1EEclImJRKNSt3__121piecewise_construct_tENS8_5tupleIJRKmEEENSC_IJRKPN13sentencepiece3bpe7Trainer6SymbolEEEEEEEmRKT_DpOT0_:
  498|   372k|  size_t operator()(const K& key, Args&&...) const {
  499|   372k|    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|   372k|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|   372k|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|   372k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyImPN13sentencepiece3bpe7Trainer6SymbolEE8transferINSt3__19allocatorINSA_4pairIKmS7_EEEEEEDaPT_PNS1_13map_slot_typeImS7_EESK_:
  442|   370k|                       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|   370k|    auto is_relocatable = typename std::conjunction<
  449|   370k|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|   370k|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|   370k|        type();
  452|       |
  453|   370k|    emplace(new_slot);
  454|   370k|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [True: 370k, Folded]
  ------------------
  455|       |      // TODO(b/247130232,b/251814870): remove casts after fixing warnings.
  456|   370k|      std::memcpy(static_cast<void*>(std::launder(&new_slot->value)),
  457|   370k|                  static_cast<const void*>(&old_slot->value),
  458|   370k|                  sizeof(value_type));
  459|   370k|      return is_relocatable;
  460|   370k|    }
  461|       |
  462|      0|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 0, Folded]
  ------------------
  463|      0|      std::allocator_traits<Allocator>::construct(
  464|      0|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|      0|    } else {
  466|      0|      std::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|   370k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyImPN13sentencepiece3bpe7Trainer6SymbolEE7emplaceEPNS1_13map_slot_typeImS7_EE:
  368|   663k|  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|   663k|    new (slot) slot_type;
  372|   663k|  }
_ZN4absl12lts_2026052618container_internal13map_slot_typeImPN13sentencepiece3bpe7Trainer6SymbolEEC2Ev:
  349|   663k|  map_slot_type() {}
_ZN4absl12lts_2026052618container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEC2ERKS5_RKm:
  515|  1.42k|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026052618container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEclEm:
  517|  1.42k|  size_t operator()(size_t seed) const {
  518|  1.42k|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|  1.42k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyImPN13sentencepiece3bpe7Trainer6SymbolEE9constructINSt3__19allocatorINSA_4pairIKmS7_EEEEJRKNSA_21piecewise_construct_tENSA_5tupleIJRSD_EEENSJ_IJRKS7_EEEEEEvPT_PNS1_13map_slot_typeImS7_EEDpOT0_:
  397|   293k|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|   293k|    emplace(slot);
  399|   293k|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 293k, Folded]
  ------------------
  400|   293k|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   293k|                                                  std::forward<Args>(args)...);
  402|   293k|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|   293k|  }
_ZN4absl12lts_2026052618container_internal23SanitizerUnpoisonObjectImEEvPKT_:
  268|  13.9M|inline void SanitizerUnpoisonObject(const T* object) {
  269|  13.9M|  SanitizerUnpoisonMemoryRegion(object, sizeof(T));
  270|  13.9M|}
_ZN4absl12lts_2026052618container_internal23SanitizerUnpoisonObjectIPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEvPKT_:
  268|   217k|inline void SanitizerUnpoisonObject(const T* object) {
  269|   217k|  SanitizerUnpoisonMemoryRegion(object, sizeof(T));
  270|   217k|}
_ZN4absl12lts_2026052618container_internal21SanitizerPoisonObjectIPNS1_10btree_nodeINS1_15set_params_implImJEEEEEEEvPKT_:
  263|   162k|inline void SanitizerPoisonObject(const T* object) {
  264|   162k|  SanitizerPoisonMemoryRegion(object, sizeof(T));
  265|   162k|}
_ZN4absl12lts_2026052618container_internal8AllocateILm8ENSt3__19allocatorImEEEEPvPT0_m:
   62|   555k|void* Allocate(Alloc* alloc, size_t n) {
   63|   555k|  static_assert(Alignment > 0, "");
   64|   555k|  assert(n && "n must be positive");
   65|   555k|  using M = AlignedType<Alignment>;
   66|   555k|  using A = typename std::allocator_traits<Alloc>::template rebind_alloc<M>;
   67|   555k|  using AT = typename std::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|   555k|  A my_mem_alloc(*alloc);
   72|   555k|  void* p = AT::allocate(my_mem_alloc, (n + sizeof(M) - 1) / sizeof(M));
   73|       |  assert(reinterpret_cast<uintptr_t>(p) % Alignment == 0 &&
   74|   555k|         "allocator does not respect alignment");
   75|   555k|  return p;
   76|   555k|}
_ZN4absl12lts_2026052618container_internal14DecomposeValueINS1_12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEEJEE19EmplaceDecomposableESB_EEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEclsr3stdE7declvalISG_EEEEOSF_OSG_:
  234|  47.5k|DecomposeValue(F&& f, Arg&& arg) {
  235|  47.5k|  const auto& key = arg;
  236|  47.5k|  return std::forward<F>(f)(key, std::forward<Arg>(arg));
  237|  47.5k|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_12EqualElementIDiNSt3__18equal_toIDiEEEEJRNS4_4pairIKDiN13sentencepiece14unicode_script10ScriptTypeEEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSF_DpOSG_:
  226|  39.1M|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|  39.1M|  return memory_internal::DecomposePairImpl(
  228|  39.1M|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|  39.1M|}
_ZN4absl12lts_2026052618container_internal15memory_internal17DecomposePairImplINS1_12EqualElementIDiNSt3__18equal_toIDiEEEERKDiNS5_5tupleIJRKN13sentencepiece14unicode_script10ScriptTypeEEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSB_IJSJ_EEEEEclsr3stdE7declvalIT1_EEEEOSI_NS5_4pairISM_SN_EE:
  158|  39.1M|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|  39.1M|  const auto& key = std::get<0>(p.first);
  160|  39.1M|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|  39.1M|                            std::move(p.second));
  162|  39.1M|}
_ZNK4absl12lts_2026052618container_internal12EqualElementIDiNSt3__18equal_toIDiEEEclIDiJRKNS3_21piecewise_construct_tENS3_5tupleIJRKDiEEENSB_IJRKN13sentencepiece14unicode_script10ScriptTypeEEEEEEEbRKT_DpOT0_:
  529|  39.1M|  bool operator()(const K2& lhs, Args&&...) const {
  530|  39.1M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|  39.1M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|  39.1M|  }
_ZN4absl12lts_2026052618container_internal8PairArgsIKDiN13sentencepiece14unicode_script10ScriptTypeEEENSt3__14pairINS7_5tupleIJRKT_EEENS9_IJRKT0_EEEEERKNS8_ISA_SE_EE:
  207|  39.3M|    const std::pair<F, S>& p) {
  208|  39.3M|  return PairArgs(p.first, p.second);
  209|  39.3M|}
_ZN4absl12lts_2026052618container_internal8PairArgsIRKDiRKN13sentencepiece14unicode_script10ScriptTypeEEENSt3__14pairINSA_5tupleIJOT_EEENSC_IJOT0_EEEEESE_SH_:
  201|  39.3M|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|  39.3M|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|  39.3M|          std::forward_as_tuple(std::forward<S>(s))};
  204|  39.3M|}
_ZN4absl12lts_2026052618container_internal13DecomposePairINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEEJRNSt3__14pairIKDiN13sentencepiece14unicode_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_2026052618container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEERKDiNSt3__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_2026052618container_internal11HashElementINS0_13hash_internal4HashIDiEELb1EEclIDiJRKNSt3__121piecewise_construct_tENS8_5tupleIJRKDiEEENSC_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_2026052618container_internal15map_slot_policyIDiN13sentencepiece14unicode_script10ScriptTypeEE8transferINSt3__19allocatorINS8_4pairIKDiS5_EEEEEEDaPT_PNS1_13map_slot_typeIDiS5_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|      std::allocator_traits<Allocator>::construct(
  464|      0|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|      0|    } else {
  466|      0|      std::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_2026052618container_internal15map_slot_policyIDiN13sentencepiece14unicode_script10ScriptTypeEE7emplaceEPNS1_13map_slot_typeIDiS5_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_2026052618container_internal13map_slot_typeIDiN13sentencepiece14unicode_script10ScriptTypeEEC2Ev:
  349|   357k|  map_slot_type() {}
_ZN4absl12lts_2026052618container_internal15map_slot_policyIDiN13sentencepiece14unicode_script10ScriptTypeEE9constructINSt3__19allocatorINS8_4pairIKDiS5_EEEEJRKNS8_21piecewise_construct_tENS8_5tupleIJRSB_EEENSH_IJEEEEEEvPT_PNS1_13map_slot_typeIDiS5_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|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|   127k|                                                  std::forward<Args>(args)...);
  402|   127k|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|   127k|  }
_ZN4absl12lts_2026052618container_internal15map_slot_policyIDiN13sentencepiece14unicode_script10ScriptTypeEE9constructINSt3__19allocatorINS8_4pairIKDiS5_EEEEJRKNS8_21piecewise_construct_tENS8_5tupleIJODiEEENSH_IJEEEEEEvPT_PNS1_13map_slot_typeIDiS5_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|      std::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|    697|                                                  std::forward<Args>(args)...);
  402|    697|    } else {
  403|      0|      std::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                  std::forward<Args>(args)...);
  405|      0|    }
  406|    697|  }

_ZNK4absl12lts_2026052618container_internal10StringHash14hash_with_seedENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEm:
   86|  19.9M|  size_t hash_with_seed(absl::string_view v, size_t seed) const {
   87|  19.9M|    return absl::hash_internal::HashWithSeed().hash(
   88|  19.9M|        absl::Hash<absl::string_view>{}, v, seed);
   89|  19.9M|  }
_ZNK4absl12lts_2026052618container_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_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEvE5applyINS1_12EqualElementIDiNS4_8equal_toIDiEEEEJRNS5_IKDiS6_EEES7_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSI_DpOSJ_:
  130|  8.48M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  8.48M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  8.48M|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEvE5applyINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEEJRNS5_IKDiS6_EEES7_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSJ_DpOSK_:
  130|   328k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   328k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   328k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIDilEEvE5applyINS1_12raw_hash_setIS4_JEE19EmplaceDecomposableEJRKDiRKlES4_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSF_DpOSG_:
  130|   272k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   272k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   272k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIDilEEvE5applyINS1_12EqualElementIDiNSt3__18equal_toIDiEEEEJRNS8_4pairIKDilEEES4_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSH_DpOSI_:
  130|  9.84M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  9.84M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  9.84M|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIDilEEvE5applyINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEEJRNSt3__14pairIKDilEEES4_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSI_DpOSJ_:
  130|   284k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   284k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   284k|  }
_ZN4absl12lts_2026052618container_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|   122k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   122k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   122k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS4_4pairIKSA_lEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|  2.90M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  2.90M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  2.90M|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE5applyINS1_12raw_hash_setISB_JEE19EmplaceDecomposableEJRKSA_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSK_DpOSL_:
  130|   374k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   374k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   374k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE5applyINS1_12EqualElementISA_NS1_8StringEqEEEJRSA_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSJ_DpOSK_:
  130|  38.1k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  38.1k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  38.1k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRSA_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSJ_DpOSK_:
  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_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS4_4pairIKSA_fEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|   231k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   231k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   231k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE5applyINS1_12raw_hash_setISB_JEE19EmplaceDecomposableEJRKNS4_4pairISA_fEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|   233k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   233k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   233k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEvE5applyINS1_12EqualElementISA_NS1_8StringEqEEEJRNS4_4pairIKSA_fEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|   386k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   386k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   386k|  }
_ZN4absl12lts_2026052618container_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_2026052618container_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|  62.7k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  62.7k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  62.7k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS4_4pairIKSA_mEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|   130k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   130k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   130k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE5applyINS1_12EqualElementImNSt3__18equal_toImEEEEJRNSD_4pairIKmS8_EEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|  4.23M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  4.23M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  4.23M|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE5applyINS1_12raw_hash_setIS9_JEE19EmplaceDecomposableEJRKNSt3__14pairIKmS8_EEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|   293k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   293k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   293k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEvE5applyINS1_11HashElementINS0_13hash_internal4HashImEELb1EEEJRNSt3__14pairIKmS8_EEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSN_DpOSO_:
  130|   372k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|   372k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|   372k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvE5applyINS1_12raw_hash_setISB_JEE19EmplaceDecomposableEJSA_ESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSI_DpOSJ_:
  130|  47.5k|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  47.5k|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  47.5k|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEvE5applyINS1_12EqualElementIDiNSt3__18equal_toIDiEEEEJRNSB_4pairIKDiS6_EEES7_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSK_DpOSL_:
  130|  39.1M|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|  39.1M|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|  39.1M|  }
_ZN4absl12lts_2026052618container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEvE5applyINS1_11HashElementINS0_13hash_internal4HashIDiEELb1EEEJRNSt3__14pairIKDiS6_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_2026052618container_internal13GroupSse2ImplC2EPKNS1_6ctrl_tE:
  284|  81.9M|  explicit GroupSse2Impl(const ctrl_t* pos) {
  285|  81.9M|    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
  286|  81.9M|  }
_ZNK4absl12lts_2026052618container_internal13GroupSse2Impl5MatchEh:
  289|  80.9M|  BitMaskType Match(h2_t hash) const {
  290|  80.9M|    auto match = _mm_set1_epi8(static_cast<char>(hash));
  291|  80.9M|    return BitMaskType(MoveMask(_mm_cmpeq_epi8(match, ctrl)));
  292|  80.9M|  }
_ZNK4absl12lts_2026052618container_internal13GroupSse2Impl9MaskEmptyEv:
  295|  8.66M|  NonIterableBitMaskType MaskEmpty() const {
  296|       |#ifdef ABSL_INTERNAL_HAVE_SSSE3
  297|       |    // This only works because ctrl_t::kEmpty is -128.
  298|       |    return NonIterableBitMaskType(MoveMask(_mm_sign_epi8(ctrl, ctrl)));
  299|       |#else
  300|  8.66M|    auto match = _mm_set1_epi8(static_cast<char>(ctrl_t::kEmpty));
  301|  8.66M|    return NonIterableBitMaskType(MoveMask(_mm_cmpeq_epi8(match, ctrl)));
  302|  8.66M|#endif
  303|  8.66M|  }
_ZNK4absl12lts_2026052618container_internal13GroupSse2Impl8MaskFullEv:
  308|   667k|  BitMaskType MaskFull() const { return BitMaskType(MoveMask(ctrl) ^ 0xffff); }
_ZNK4absl12lts_2026052618container_internal13GroupSse2Impl11MaskNonFullEv:
  313|   135k|  auto MaskNonFull() const { return BitMaskType(MoveMask(ctrl)); }
_ZN4absl12lts_2026052618container_internal13GroupSse2Impl8MoveMaskEDv2_x:
  344|  90.5M|  static MaskInt MoveMask(__m128i xmm) {
  345|  90.5M|    auto mask = static_cast<MaskInt>(_mm_movemask_epi8(xmm));
  346|  90.5M|#ifdef __clang__
  347|       |    // TODO(b/472522597): Without the inline asm, clang ends up generating an
  348|       |    // unnecessary movzx to zero the upper bits of the output, but those bits
  349|       |    // are already zero. See https://godbolt.org/z/G6xW1Ecbx.
  350|  90.5M|    asm("" : "+r"(mask));  // NOLINT
  351|  90.5M|#endif
  352|  90.5M|    return mask;
  353|  90.5M|  }
_ZN4absl12lts_2026052618container_internal16IsEmptyOrDeletedENS1_6ctrl_tE:
  228|  7.21M|inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
_ZN4absl12lts_2026052618container_internal13TrailingZerosImEEjT_:
   63|   378k|uint32_t TrailingZeros(T x) {
   64|   378k|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  271|   378k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
   65|   378k|  return static_cast<uint32_t>(countr_zero(x));
   66|   378k|}
_ZN4absl12lts_2026052618container_internal7BitMaskIjLi16ELi0ELb0EEC2Ej:
  133|   163M|  explicit BitMask(T mask) : Base(mask) {
  134|   163M|    if (Shift == 3 && !NullifyBitsOnIteration) {
  ------------------
  |  Branch (134:9): [Folded, False: 163M]
  |  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|   163M|  }
_ZN4absl12lts_2026052618container_internal18NonIterableBitMaskIjLi16ELi0EEC2Ej:
   85|   172M|  explicit NonIterableBitMask(T mask) : mask_(mask) {}
_ZNK4absl12lts_2026052618container_internal7BitMaskIjLi16ELi0ELb0EE5beginEv:
  153|  81.5M|  BitMask begin() const { return *this; }
_ZNK4absl12lts_2026052618container_internal7BitMaskIjLi16ELi0ELb0EE3endEv:
  154|  81.5M|  BitMask end() const { return BitMask(0); }
_ZN4absl12lts_2026052618container_internalneERKNS1_7BitMaskIjLi16ELi0ELb0EEES5_:
  160|  90.7M|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  161|  90.7M|    return a.mask_ != b.mask_;
  162|  90.7M|  }
_ZNK4absl12lts_2026052618container_internal7BitMaskIjLi16ELi0ELb0EEdeEv:
  151|  81.5M|  uint32_t operator*() const { return Base::LowestBitSet(); }
_ZNK4absl12lts_2026052618container_internal18NonIterableBitMaskIjLi16ELi0EE12LowestBitSetEv:
   90|  85.5M|  uint32_t LowestBitSet() const {
   91|  85.5M|    return container_internal::TrailingZeros(mask_) >> Shift;
   92|  85.5M|  }
_ZN4absl12lts_2026052618container_internal13TrailingZerosIjEEjT_:
   63|  85.6M|uint32_t TrailingZeros(T x) {
   64|  85.6M|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  271|  85.6M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
   65|  85.6M|  return static_cast<uint32_t>(countr_zero(x));
   66|  85.6M|}
_ZNK4absl12lts_2026052618container_internal18NonIterableBitMaskIjLi16ELi0EEcvbEv:
   87|  8.91M|  explicit operator bool() const { return mask_ != 0; }
_ZN4absl12lts_2026052618container_internal7BitMaskIjLi16ELi0ELb0EEppEv:
  143|  9.19M|  BitMask& operator++() {
  144|  9.19M|    if (Shift == 3 && NullifyBitsOnIteration) {
  ------------------
  |  Branch (144:9): [Folded, False: 9.19M]
  |  Branch (144:23): [Folded, False: 0]
  ------------------
  145|      0|      this->mask_ &= kMsbs8Bytes;
  146|      0|    }
  147|  9.19M|    this->mask_ &= (this->mask_ - 1);
  148|  9.19M|    return *this;
  149|  9.19M|  }

_ZN4absl12lts_2026052618container_internal20HashtablezInfoHandle10UnregisterEv:
  203|  58.2k|  inline void Unregister() {}
_ZN4absl12lts_2026052618container_internal21ShouldSampleNextTableEv:
  226|  58.3k|inline bool ShouldSampleNextTable() {
  227|       |#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
  228|       |  if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0)) {
  229|       |    return false;
  230|       |  }
  231|       |  return true;
  232|       |#else
  233|  58.3k|  return false;
  234|  58.3k|#endif  // ABSL_INTERNAL_HASHTABLEZ_SAMPLE
  235|  58.3k|}

_ZNK4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE14GetIsAllocatedEv:
  373|  5.03k|  bool GetIsAllocated() const { return GetSizeAndIsAllocated() & 1; }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE21GetSizeAndIsAllocatedEv:
  367|  7.54k|  const SizeType<A>& GetSizeAndIsAllocated() const {
  368|  7.54k|    return metadata_.template get<1>();
  369|  7.54k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE14GetInlinedDataEv:
  397|  3.77k|  ABSL_ATTRIBUTE_NO_SANITIZE_CFI Pointer<A> GetInlinedData() {
  398|  3.77k|    return reinterpret_cast<Pointer<A>>(data_.inlined.inlined_data);
  399|  3.77k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE7GetSizeEv:
  371|  2.51k|  SizeType<A> GetSize() const { return GetSizeAndIsAllocated() >> 1; }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEEC2Ev:
  338|  1.25k|  Storage() : metadata_(A(), /* size and is_allocated */ 0u) {}
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE11EmplaceBackIJRKjEEERjDpOT_:
  817|  1.25k|auto Storage<T, N, A>::EmplaceBack(Args&&... args) -> Reference<A> {
  818|  1.25k|  StorageView<A> storage_view = MakeStorageView();
  819|  1.25k|  const SizeType<A> n = storage_view.size;
  820|  1.25k|  if (ABSL_PREDICT_TRUE(n != storage_view.capacity)) {
  ------------------
  |  |  191|  1.25k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1.25k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 1.25k]
  |  |  |  Branch (191:57): [True: 1.25k, False: 0]
  |  |  ------------------
  ------------------
  821|       |    // Fast path; new element fits.
  822|  1.25k|    Pointer<A> last_ptr = storage_view.data + n;
  823|  1.25k|    AllocatorTraits<A>::construct(GetAllocator(), last_ptr,
  824|  1.25k|                                  std::forward<Args>(args)...);
  825|  1.25k|    AddSize(1);
  826|  1.25k|    return *last_ptr;
  827|  1.25k|  }
  828|       |  // TODO(b/173712035): Annotate with musttail attribute to prevent regression.
  829|      0|  return EmplaceBackSlow(std::forward<Args>(args)...);
  830|  1.25k|}
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE15MakeStorageViewEv:
  413|  1.25k|  StorageView<A> MakeStorageView() {
  414|  1.25k|    return GetIsAllocated() ? StorageView<A>{GetAllocatedData(), GetSize(),
  ------------------
  |  Branch (414:12): [True: 0, False: 1.25k]
  ------------------
  415|      0|                                             GetAllocatedCapacity()}
  416|  1.25k|                            : StorageView<A>{GetInlinedData(), GetSize(),
  417|  1.25k|                                             GetInlinedCapacity()};
  418|  1.25k|  }
_ZNK4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE18GetInlinedCapacityEv:
  409|  1.25k|  SizeType<A> GetInlinedCapacity() const {
  410|  1.25k|    return static_cast<SizeType<A>>(kOptimalInlinedSize);
  411|  1.25k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE12GetAllocatorEv:
  420|  1.25k|  A& GetAllocator() { return metadata_.template get<0>(); }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE7AddSizeEm:
  475|  1.25k|  void AddSize(SizeType<A> count) {
  476|  1.25k|    GetSizeAndIsAllocated() += count << static_cast<SizeType<A>>(1);
  477|  1.25k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE21GetSizeAndIsAllocatedEv:
  365|  2.51k|  SizeType<A>& GetSizeAndIsAllocated() { return metadata_.template get<1>(); }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEE21DeallocateIfAllocatedEv:
  521|  1.25k|  void DeallocateIfAllocated() {
  522|  1.25k|    if (GetIsAllocated()) {
  ------------------
  |  Branch (522:9): [True: 0, False: 1.25k]
  ------------------
  523|      0|      MallocAdapter<A>::Deallocate(GetAllocator(), GetAllocatedData(),
  524|      0|                                   GetAllocatedCapacity());
  525|      0|    }
  526|  1.25k|  }
_ZN4absl12lts_2026052623inlined_vector_internal7StorageIjLm8ENSt3__19allocatorIjEEED2Ev:
  343|  1.25k|  ~Storage() {
  344|       |    // Fast path: if we are empty and not allocated, there's nothing to do.
  345|  1.25k|    if (GetSizeAndIsAllocated() == 0) {
  ------------------
  |  Branch (345:9): [True: 0, False: 1.25k]
  ------------------
  346|      0|      return;
  347|      0|    }
  348|       |
  349|       |    // Fast path: if no destructors need to be run and we know the allocator
  350|       |    // doesn't do anything fancy, then all we need to do is deallocate (and
  351|       |    // maybe not even that).
  352|  1.25k|    if (std::is_trivially_destructible<ValueType<A>>::value &&
  ------------------
  |  Branch (352:9): [True: 0, Folded]
  ------------------
  353|  1.25k|        std::is_same<A, std::allocator<ValueType<A>>>::value) {
  ------------------
  |  Branch (353:9): [True: 0, Folded]
  ------------------
  354|  1.25k|      DeallocateIfAllocated();
  355|  1.25k|      return;
  356|  1.25k|    }
  357|       |
  358|      0|    DestroyContents();
  359|      0|  }

_ZN4absl12lts_2026052618container_internal15internal_layout11adl_barrier5AlignEmm:
  294|   296M|constexpr size_t Align(size_t n, size_t m) { return (n + m - 1) & ~(m - 1); }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm0EEEmv:
  418|  1.09M|  constexpr size_t Offset() const {
  419|  1.09M|    if constexpr (N == 0) {
  420|  1.09M|      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.09M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm0EEEmv:
  456|  1.09M|  constexpr size_t Size() const {
  457|  1.09M|    if constexpr (N < NumStaticSizes) {
  458|  1.09M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  1.09M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm1EEEmv:
  418|  1.09M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  1.09M|    } else {
  422|  1.09M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  1.09M|      return adl_barrier::Align(
  424|  1.09M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  1.09M|          ElementAlignment<N>::value);
  426|  1.09M|    }
  427|  1.09M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm1EEEmv:
  456|  1.09M|  constexpr size_t Size() const {
  457|  1.09M|    if constexpr (N < NumStaticSizes) {
  458|  1.09M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  1.09M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm2EEEmv:
  418|  1.09M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  1.09M|    } else {
  422|  1.09M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  1.09M|      return adl_barrier::Align(
  424|  1.09M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  1.09M|          ElementAlignment<N>::value);
  426|  1.09M|    }
  427|  1.09M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm2EEEmv:
  456|  1.09M|  constexpr size_t Size() const {
  457|  1.09M|    if constexpr (N < NumStaticSizes) {
  458|  1.09M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  1.09M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm3EEEmv:
  418|  1.09M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  1.09M|    } else {
  422|  1.09M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  1.09M|      return adl_barrier::Align(
  424|  1.09M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  1.09M|          ElementAlignment<N>::value);
  426|  1.09M|    }
  427|  1.09M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm3EEEmv:
  456|  1.09M|  constexpr size_t Size() const {
  457|       |    if constexpr (N < NumStaticSizes) {
  458|       |      return kStaticSizes[N];
  459|  1.09M|    } else {
  460|  1.09M|      static_assert(N < NumSizes, "Index out of bounds");
  461|  1.09M|      return size_[N - NumStaticSizes];
  462|  1.09M|    }
  463|  1.09M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm4EEEmv:
  418|  1.09M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  1.09M|    } else {
  422|  1.09M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  1.09M|      return adl_barrier::Align(
  424|  1.09M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  1.09M|          ElementAlignment<N>::value);
  426|  1.09M|    }
  427|  1.09M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm4EEEmv:
  456|  1.09M|  constexpr size_t Size() const {
  457|       |    if constexpr (N < NumStaticSizes) {
  458|       |      return kStaticSizes[N];
  459|  1.09M|    } else {
  460|  1.09M|      static_assert(N < NumSizes, "Index out of bounds");
  461|  1.09M|      return size_[N - NumStaticSizes];
  462|  1.09M|    }
  463|  1.09M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E9AllocSizeEv:
  608|  1.09M|  constexpr size_t AllocSize() const {
  609|  1.09M|    static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
  610|  1.09M|    return Offset<NumTypes - 1>() +
  611|  1.09M|           SizeOf<ElementType<NumTypes - 1>>::value * Size<NumTypes - 1>();
  612|  1.09M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm0EEEmv:
  418|   122M|  constexpr size_t Offset() const {
  419|   122M|    if constexpr (N == 0) {
  420|   122M|      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|   122M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm0EEEmv:
  456|   117M|  constexpr size_t Size() const {
  457|   117M|    if constexpr (N < NumStaticSizes) {
  458|   117M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|   117M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm1EEEmv:
  418|   117M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|   117M|    } else {
  422|   117M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|   117M|      return adl_barrier::Align(
  424|   117M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|   117M|          ElementAlignment<N>::value);
  426|   117M|    }
  427|   117M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm1EEEmv:
  456|   117M|  constexpr size_t Size() const {
  457|   117M|    if constexpr (N < NumStaticSizes) {
  458|   117M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|   117M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm2EEEmv:
  418|   117M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|   117M|    } else {
  422|   117M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|   117M|      return adl_barrier::Align(
  424|   117M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|   117M|          ElementAlignment<N>::value);
  426|   117M|    }
  427|   117M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm2EEEmv:
  456|  55.5M|  constexpr size_t Size() const {
  457|  55.5M|    if constexpr (N < NumStaticSizes) {
  458|  55.5M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  55.5M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm3EEEmv:
  418|  55.5M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  55.5M|    } else {
  422|  55.5M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  55.5M|      return adl_barrier::Align(
  424|  55.5M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  55.5M|          ElementAlignment<N>::value);
  426|  55.5M|    }
  427|  55.5M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm3EEEmv:
  456|  2.69M|  constexpr size_t Size() const {
  457|  2.69M|    if constexpr (N < NumStaticSizes) {
  458|  2.69M|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  2.69M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E6OffsetILm4EEEmv:
  418|  2.69M|  constexpr size_t Offset() const {
  419|       |    if constexpr (N == 0) {
  420|       |      return 0;
  421|  2.69M|    } else {
  422|  2.69M|      static_assert(N < NumOffsets, "Index out of bounds");
  423|  2.69M|      return adl_barrier::Align(
  424|  2.69M|          Offset<N - 1>() + SizeOf<ElementType<N - 1>>::value * Size<N - 1>(),
  425|  2.69M|          ElementAlignment<N>::value);
  426|  2.69M|    }
  427|  2.69M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E4SizeILm4EEEmv:
  456|  19.0k|  constexpr size_t Size() const {
  457|  19.0k|    if constexpr (N < NumStaticSizes) {
  458|  19.0k|      return kStaticSizes[N];
  459|       |    } else {
  460|       |      static_assert(N < NumSizes, "Index out of bounds");
  461|       |      return size_[N - NumStaticSizes];
  462|       |    }
  463|  19.0k|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E9AllocSizeEv:
  608|  19.0k|  constexpr size_t AllocSize() const {
  609|  19.0k|    static_assert(NumTypes == NumSizes, "You must specify sizes of all fields");
  610|  19.0k|    return Offset<NumTypes - 1>() +
  611|  19.0k|           SizeOf<ElementType<NumTypes - 1>>::value * Size<NumTypes - 1>();
  612|  19.0k|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm2EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESN_E4typeEPSK_:
  496|  55.3M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  55.3M|    using C = typename std::remove_const<Char>::type;
  498|  55.3M|    static_assert(
  499|  55.3M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  55.3M|            std::is_same<C, signed char>(),
  501|  55.3M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  55.3M|    constexpr size_t alignment = Alignment();
  503|  55.3M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  55.3M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  55.3M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm3EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESM_E4typeEPSJ_:
  496|  14.3M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  14.3M|    using C = typename std::remove_const<Char>::type;
  498|  14.3M|    static_assert(
  499|  14.3M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  14.3M|            std::is_same<C, signed char>(),
  501|  14.3M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  14.3M|    constexpr size_t alignment = Alignment();
  503|  14.3M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  14.3M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  14.3M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm0EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESN_E4typeEPSK_:
  496|  5.08M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  5.08M|    using C = typename std::remove_const<Char>::type;
  498|  5.08M|    static_assert(
  499|  5.08M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  5.08M|            std::is_same<C, signed char>(),
  501|  5.08M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  5.08M|    constexpr size_t alignment = Alignment();
  503|  5.08M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  5.08M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  5.08M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm4EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESN_E4typeEPSK_:
  496|  2.06M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  2.06M|    using C = typename std::remove_const<Char>::type;
  498|  2.06M|    static_assert(
  499|  2.06M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  2.06M|            std::is_same<C, signed char>(),
  501|  2.06M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  2.06M|    constexpr size_t alignment = Alignment();
  503|  2.06M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  2.06M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  2.06M|  }
_ZN4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_EC2Ev:
  401|   122M|      : size_{sizes...} {}
_ZN4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4EEEENSC_ImJLm0ELm1EEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_EC2Emm:
  401|  1.09M|      : size_{sizes...} {}
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm2EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESM_E4typeEPSJ_:
  496|  6.12M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  6.12M|    using C = typename std::remove_const<Char>::type;
  498|  6.12M|    static_assert(
  499|  6.12M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  6.12M|            std::is_same<C, signed char>(),
  501|  6.12M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  6.12M|    constexpr size_t alignment = Alignment();
  503|  6.12M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  6.12M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  6.12M|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm0EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESM_E4typeEPSJ_:
  496|   585k|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|   585k|    using C = typename std::remove_const<Char>::type;
  498|   585k|    static_assert(
  499|   585k|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|   585k|            std::is_same<C, signed char>(),
  501|   585k|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|   585k|    constexpr size_t alignment = Alignment();
  503|   585k|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|   585k|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|   585k|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm4EcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESM_E4typeEPSJ_:
  496|   607k|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|   607k|    using C = typename std::remove_const<Char>::type;
  498|   607k|    static_assert(
  499|   607k|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|   607k|            std::is_same<C, signed char>(),
  501|   607k|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|   607k|    constexpr size_t alignment = Alignment();
  503|   607k|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|   607k|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|   607k|  }
_ZNK4absl12lts_2026052618container_internal15internal_layout10LayoutImplINSt3__15tupleIJPNS1_10btree_nodeINS1_15set_params_implImJEEEEEjhmSA_EEENS4_16integer_sequenceImJLm1ELm0ELm4ELm30ELm31EEEENSC_ImJEEENSC_ImJLm0ELm1ELm2ELm3ELm4EEEESF_E7PointerILm3EKcEEPNS4_11conditionalIXsr3std8is_constIT0_EE5valueEKNS4_13tuple_elementIXT_ESB_E4typeESN_E4typeEPSK_:
  496|  38.5M|  CopyConst<Char, ElementType<N>>* Pointer(Char* p) const {
  497|  38.5M|    using C = typename std::remove_const<Char>::type;
  498|  38.5M|    static_assert(
  499|  38.5M|        std::is_same<C, char>() || std::is_same<C, unsigned char>() ||
  500|  38.5M|            std::is_same<C, signed char>(),
  501|  38.5M|        "The argument must be a pointer to [const] [signed|unsigned] char");
  502|  38.5M|    constexpr size_t alignment = Alignment();
  503|  38.5M|    (void)alignment;
  504|       |    assert(reinterpret_cast<uintptr_t>(p) % alignment == 0);
  505|  38.5M|    return reinterpret_cast<CopyConst<Char, ElementType<N>>*>(p + Offset<N>());
  506|  38.5M|  }

_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEEC2Ev:
  107|  1.44k|  raw_hash_map() {}
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDilEEJEEC2Ev:
  107|  8.54k|  raw_hash_map() {}
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEEC2Ev:
  107|  8.52k|  raw_hash_map() {}
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEEixIDiS7_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS5_IKDiS6_EEEEPT_RSE_EclL_ZNS4_7declvalB8ne220000IRSD_EEDTclsr3stdE9__declvalISE_ELi0EEEvEEEEERSC_:
  329|  8.59M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  330|       |    // It is safe to use unchecked_deref here because try_emplace
  331|       |    // will always return an iterator pointing to a valid item in the table,
  332|       |    // since it inserts if nothing is found for the given key.
  333|  8.59M|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  334|  8.59M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE11try_emplaceIDiLi0EJETnNS4_9enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setIS7_JEE14const_iteratorEEE5valueEiE4typeELi0EEENS5_INSD_8iteratorEbEERKDiDpOT1_:
  244|  8.59M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|  8.59M|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|  8.59M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE16try_emplace_implIRKDiJEEENS5_INS1_12raw_hash_setIS7_JEE8iteratorEbEEOT_DpOT0_:
  365|  8.59M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  366|  8.59M|    auto res = this->find_or_prepare_insert(k);
  367|  8.59M|    if (res.second) {
  ------------------
  |  Branch (367:9): [True: 300k, False: 8.29M]
  ------------------
  368|   300k|      this->emplace_at(res.first, std::piecewise_construct,
  369|   300k|                       std::forward_as_tuple(std::forward<K>(k)),
  370|   300k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  371|   300k|    }
  372|  8.59M|    return res;
  373|  8.59M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEEC2Ev:
  107|  18.0k|  raw_hash_map() {}
_ZN4absl12lts_2026052618container_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_:
  329|   295k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  330|       |    // It is safe to use unchecked_deref here because try_emplace
  331|       |    // will always return an iterator pointing to a valid item in the table,
  332|       |    // since it inserts if nothing is found for the given key.
  333|   295k|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  334|   295k|  }
_ZN4absl12lts_2026052618container_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|   295k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|   295k|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|   295k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE16try_emplace_implIRKNS4_17basic_string_viewIcS7_EEJEEENS4_4pairINS1_12raw_hash_setISB_JEE8iteratorEbEEOT_DpOT0_:
  365|   295k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  366|   295k|    auto res = this->find_or_prepare_insert(k);
  367|   295k|    if (res.second) {
  ------------------
  |  Branch (367:9): [True: 193k, False: 101k]
  ------------------
  368|   193k|      this->emplace_at(res.first, std::piecewise_construct,
  369|   193k|                       std::forward_as_tuple(std::forward<K>(k)),
  370|   193k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  371|   193k|    }
  372|   295k|    return res;
  373|   295k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEEC2Ev:
  107|  11.8k|  raw_hash_map() {}
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEEixISA_SB_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS4_4pairIKSA_lEEEEPT_RSJ_EclL_ZNS4_7declvalB8ne220000IRSI_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEEEEEOSJ_:
  311|  5.82M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  312|       |    // It is safe to use unchecked_deref here because try_emplace
  313|       |    // will always return an iterator pointing to a valid item in the table,
  314|       |    // since it inserts if nothing is found for the given key.
  315|  5.82M|    return Policy::value(&this->unchecked_deref(
  316|  5.82M|        try_emplace(std::forward<key_arg<K>>(key)).first));
  317|  5.82M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE11try_emplaceISA_Li0EJETnNS4_9enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setISB_JEE14const_iteratorEEE5valueEiE4typeELi0EEENS4_4pairINSH_8iteratorEbEEOSF_DpOT1_:
  223|  5.82M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  224|  5.82M|    return try_emplace_impl(std::forward<key_arg<K>>(k),
  225|  5.82M|                            std::forward<Args>(args)...);
  226|  5.82M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE16try_emplace_implISA_JEEENS4_4pairINS1_12raw_hash_setISB_JEE8iteratorEbEEOT_DpOT0_:
  365|  5.82M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  366|  5.82M|    auto res = this->find_or_prepare_insert(k);
  367|  5.82M|    if (res.second) {
  ------------------
  |  Branch (367:9): [True: 170k, False: 5.65M]
  ------------------
  368|   170k|      this->emplace_at(res.first, std::piecewise_construct,
  369|   170k|                       std::forward_as_tuple(std::forward<K>(k)),
  370|   170k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  371|   170k|    }
  372|  5.82M|    return res;
  373|  5.82M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEEixISA_SB_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS4_4pairIKSA_lEEEEPT_RSJ_EclL_ZNS4_7declvalB8ne220000IRSI_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEEEEERKSJ_:
  329|  6.89M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  330|       |    // It is safe to use unchecked_deref here because try_emplace
  331|       |    // will always return an iterator pointing to a valid item in the table,
  332|       |    // since it inserts if nothing is found for the given key.
  333|  6.89M|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  334|  6.89M|  }
_ZN4absl12lts_2026052618container_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.89M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|  6.89M|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|  6.89M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE16try_emplace_implIRKSA_JEEENS4_4pairINS1_12raw_hash_setISB_JEE8iteratorEbEEOT_DpOT0_:
  365|  6.89M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  366|  6.89M|    auto res = this->find_or_prepare_insert(k);
  367|  6.89M|    if (res.second) {
  ------------------
  |  Branch (367:9): [True: 1.77M, False: 5.11M]
  ------------------
  368|  1.77M|      this->emplace_at(res.first, std::piecewise_construct,
  369|  1.77M|                       std::forward_as_tuple(std::forward<K>(k)),
  370|  1.77M|                       std::forward_as_tuple(std::forward<Args>(args)...));
  371|  1.77M|    }
  372|  6.89M|    return res;
  373|  6.89M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEEC2Ev:
  107|  5.83k|  raw_hash_map() {}
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEEixISA_SB_Li0EEEDTclsrT0_5valueclL_ZNS4_9addressofB8ne220000INS4_4pairIKSA_fEEEEPT_RSJ_EclL_ZNS4_7declvalB8ne220000IRSI_EEDTclsr3stdE9__declvalISJ_ELi0EEEvEEEEERKSJ_:
  329|   356k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  330|       |    // It is safe to use unchecked_deref here because try_emplace
  331|       |    // will always return an iterator pointing to a valid item in the table,
  332|       |    // since it inserts if nothing is found for the given key.
  333|   356k|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  334|   356k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE11try_emplaceISA_Li0EJETnNS4_9enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setISB_JEE14const_iteratorEEE5valueEiE4typeELi0EEENS4_4pairINSH_8iteratorEbEERKSF_DpOT1_:
  244|   356k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|   356k|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|   356k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE16try_emplace_implIRKSA_JEEENS4_4pairINS1_12raw_hash_setISB_JEE8iteratorEbEEOT_DpOT0_:
  365|   356k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  366|   356k|    auto res = this->find_or_prepare_insert(k);
  367|   356k|    if (res.second) {
  ------------------
  |  Branch (367:9): [True: 224k, False: 132k]
  ------------------
  368|   224k|      this->emplace_at(res.first, std::piecewise_construct,
  369|   224k|                       std::forward_as_tuple(std::forward<K>(k)),
  370|   224k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  371|   224k|    }
  372|   356k|    return res;
  373|   356k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEEC2Ev:
  107|    929|  raw_hash_map() {}
_ZN4absl12lts_2026052618container_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_:
  329|   146k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  330|       |    // It is safe to use unchecked_deref here because try_emplace
  331|       |    // will always return an iterator pointing to a valid item in the table,
  332|       |    // since it inserts if nothing is found for the given key.
  333|   146k|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  334|   146k|  }
_ZN4absl12lts_2026052618container_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|   146k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|   146k|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|   146k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE16try_emplace_implIRKNS4_17basic_string_viewIcS7_EEJEEENS4_4pairINS1_12raw_hash_setISB_JEE8iteratorEbEEOT_DpOT0_:
  365|   146k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  366|   146k|    auto res = this->find_or_prepare_insert(k);
  367|   146k|    if (res.second) {
  ------------------
  |  Branch (367:9): [True: 93.3k, False: 53.3k]
  ------------------
  368|  93.3k|      this->emplace_at(res.first, std::piecewise_construct,
  369|  93.3k|                       std::forward_as_tuple(std::forward<K>(k)),
  370|  93.3k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  371|  93.3k|    }
  372|   146k|    return res;
  373|   146k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEEC2Ev:
  107|      1|  raw_hash_map() {}
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEEixIDiS7_Li0EEEDTclsrT0_5valueclL_ZNSt3__19addressofB8ne220000INSB_4pairIKDiS6_EEEEPT_RSG_EclL_ZNSB_7declvalB8ne220000IRSF_EEDTclsr3stdE9__declvalISG_ELi0EEEvEEEEERSE_:
  329|   127k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  330|       |    // It is safe to use unchecked_deref here because try_emplace
  331|       |    // will always return an iterator pointing to a valid item in the table,
  332|       |    // since it inserts if nothing is found for the given key.
  333|   127k|    return Policy::value(&this->unchecked_deref(try_emplace(key).first));
  334|   127k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE11try_emplaceIDiLi0EJETnNSt3__19enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setIS7_JEE14const_iteratorEEE5valueEiE4typeELi0EEENSA_4pairINSE_8iteratorEbEERKDiDpOT1_:
  244|   127k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  245|   127k|    return try_emplace_impl(k, std::forward<Args>(args)...);
  246|   127k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE16try_emplace_implIRKDiJEEENSt3__14pairINS1_12raw_hash_setIS7_JEE8iteratorEbEEOT_DpOT0_:
  365|   127k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  366|   127k|    auto res = this->find_or_prepare_insert(k);
  367|   127k|    if (res.second) {
  ------------------
  |  Branch (367:9): [True: 127k, False: 0]
  ------------------
  368|   127k|      this->emplace_at(res.first, std::piecewise_construct,
  369|   127k|                       std::forward_as_tuple(std::forward<K>(k)),
  370|   127k|                       std::forward_as_tuple(std::forward<Args>(args)...));
  371|   127k|    }
  372|   127k|    return res;
  373|   127k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEEixIDiS7_Li0EEEDTclsrT0_5valueclL_ZNSt3__19addressofB8ne220000INSB_4pairIKDiS6_EEEEPT_RSG_EclL_ZNSB_7declvalB8ne220000IRSF_EEDTclsr3stdE9__declvalISG_ELi0EEEvEEEEEODi:
  311|    697|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  312|       |    // It is safe to use unchecked_deref here because try_emplace
  313|       |    // will always return an iterator pointing to a valid item in the table,
  314|       |    // since it inserts if nothing is found for the given key.
  315|    697|    return Policy::value(&this->unchecked_deref(
  316|    697|        try_emplace(std::forward<key_arg<K>>(key)).first));
  317|    697|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE11try_emplaceIDiLi0EJETnNSt3__19enable_ifIXntsr3std14is_convertibleIT_NS1_12raw_hash_setIS7_JEE14const_iteratorEEE5valueEiE4typeELi0EEENSA_4pairINSE_8iteratorEbEEODiDpOT1_:
  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_2026052618container_internal12raw_hash_mapINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE16try_emplace_implIDiJEEENSt3__14pairINS1_12raw_hash_setIS7_JEE8iteratorEbEEOT_DpOT0_:
  365|    697|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
  366|    697|    auto res = this->find_or_prepare_insert(k);
  367|    697|    if (res.second) {
  ------------------
  |  Branch (367:9): [True: 697, False: 0]
  ------------------
  368|    697|      this->emplace_at(res.first, std::piecewise_construct,
  369|    697|                       std::forward_as_tuple(std::forward<K>(k)),
  370|    697|                       std::forward_as_tuple(std::forward<Args>(args)...));
  371|    697|    }
  372|    697|    return res;
  373|    697|  }

_ZN4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled19set_reserved_growthEm:
  842|  55.8k|  void set_reserved_growth(size_t) {}
_ZN4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled20set_reservation_sizeEm:
  844|  55.8k|  void set_reservation_size(size_t) {}
_ZNK4absl12lts_2026052618container_internal34CommonFieldsGenerationInfoDisabled14generation_ptrEv:
  847|   137M|  GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2026052618container_internal37HashSetIteratorGenerationInfoDisabledC2EPKh:
  871|   137M|  explicit HashSetIteratorGenerationInfoDisabled(const GenerationType*) {}
_ZNK4absl12lts_2026052618container_internal37HashSetIteratorGenerationInfoDisabled10generationEv:
  873|   219M|  GenerationType generation() const { return 0; }
_ZNK4absl12lts_2026052618container_internal37HashSetIteratorGenerationInfoDisabled14generation_ptrEv:
  875|   342M|  const GenerationType* generation_ptr() const { return nullptr; }
_ZNK4absl12lts_2026052618container_internal9HeapOrSoo7controlEv:
 1091|   250M|  MaybeInitializedPtr<ctrl_t> control() const {
 1092|   250M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.control);
  ------------------
  |  |  488|   250M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1093|   250M|  }
_ZNK4absl12lts_2026052618container_internal9HeapOrSoo10slot_arrayEv:
 1097|   235M|  MaybeInitializedPtr<void> slot_array() const {
 1098|   235M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.slot_array);
  ------------------
  |  |  488|   235M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1099|   235M|  }
_ZN4absl12lts_2026052618container_internal9HeapOrSoo12get_soo_dataEv:
 1100|  99.4k|  void* get_soo_data() {
 1101|  99.4k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(soo_data);
  ------------------
  |  |  488|  99.4k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1102|  99.4k|  }
_ZN4absl12lts_2026052618container_internal12CommonFieldsC2ENS1_9soo_tag_tE:
 1126|  10.3k|      : inline_data_(HashtableCapacity(SooCapacity()), no_seed_empty_tag_t{}) {}
_ZN4absl12lts_2026052618container_internal12CommonFieldsC2ENS1_13non_soo_tag_tE:
 1131|  71.3k|      : inline_data_(HashtableCapacity(0), no_seed_empty_tag_t{}) {}
_ZN4absl12lts_2026052618container_internal12CommonFields8soo_dataEv:
 1156|  99.4k|  void* soo_data() { return heap_or_soo_.get_soo_data(); }
_ZNK4absl12lts_2026052618container_internal12CommonFields7controlEv:
 1158|   250M|  ctrl_t* control() const {
 1159|   250M|    ABSL_SWISSTABLE_ASSERT(capacity() > 0);
  ------------------
  |  |  256|   250M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1160|       |    // Assume that the control bytes don't alias `this`.
 1161|   250M|    ctrl_t* ctrl = heap_or_soo_.control().get();
 1162|   250M|    [[maybe_unused]] size_t num_control_bytes = NumControlBytes(capacity());
 1163|   250M|    ABSL_ASSUME(reinterpret_cast<uintptr_t>(ctrl + num_control_bytes) <=
  ------------------
  |  |  271|   379M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 121M, False: 128M]
  |  |  |  Branch (271:44): [True: 128M, False: 0]
  |  |  ------------------
  ------------------
 1164|   250M|                    reinterpret_cast<uintptr_t>(this) ||
 1165|   250M|                reinterpret_cast<uintptr_t>(this + 1) <=
 1166|   250M|                    reinterpret_cast<uintptr_t>(ctrl));
 1167|   250M|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(ctrl);
  ------------------
  |  |  488|   250M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 1168|   250M|  }
_ZNK4absl12lts_2026052618container_internal12CommonFields10slot_arrayEv:
 1173|   235M|  void* slot_array() const { return heap_or_soo_.slot_array().get(); }
_ZNK4absl12lts_2026052618container_internal12CommonFields11slots_unionEv:
 1174|  39.0k|  MaybeInitializedPtr<void> slots_union() const {
 1175|  39.0k|    return heap_or_soo_.slot_array();
 1176|  39.0k|  }
_ZNK4absl12lts_2026052618container_internal12CommonFields4sizeEv:
 1180|  7.40M|  size_t size() const { return inline_data_.size(); }
_ZN4absl12lts_2026052618container_internal12CommonFields12set_full_sooEv:
 1187|  9.92k|  void set_full_soo() {
 1188|  9.92k|    AssertInSooMode();
 1189|  9.92k|    inline_data_.set_size(1);
 1190|  9.92k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields14decrement_sizeEv:
 1199|  47.7k|  void decrement_size() {
 1200|       |    ABSL_SWISSTABLE_ASSERT(!empty());
  ------------------
  |  |  256|  47.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1201|  47.7k|    inline_data_.decrement_size();
 1202|  47.7k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields26set_soo_has_tried_samplingEv:
 1204|  9.92k|  void set_soo_has_tried_sampling() {
 1205|  9.92k|    inline_data_.set_soo_has_tried_sampling();
 1206|  9.92k|  }
_ZNK4absl12lts_2026052618container_internal12CommonFields22soo_has_tried_samplingEv:
 1207|  9.92k|  bool soo_has_tried_sampling() const {
 1208|  9.92k|    return inline_data_.soo_has_tried_sampling();
 1209|  9.92k|  }
_ZNK4absl12lts_2026052618container_internal12CommonFields4seedEv:
 1212|  85.6M|  PerTableSeed seed() const { return inline_data_.seed(); }
_ZNK4absl12lts_2026052618container_internal12CommonFields13capacity_implEv:
 1227|   343M|  HashtableCapacity capacity_impl() const {
 1228|   343M|    HashtableCapacity cap = inline_data_.capacity();
 1229|       |    ABSL_SWISSTABLE_ASSERT(cap.IsValid());
  ------------------
  |  |  256|   343M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1230|   343M|    return cap;
 1231|   343M|  }
_ZNK4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE8capacityEv:
  520|   490M|  constexpr size_t capacity() const {
  521|   490M|    ABSL_SWISSTABLE_ASSERT(IsValid());
  ------------------
  |  |  256|   490M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  522|   490M|    return StorageMode == kCapacityByValue ? capacity_data_
  ------------------
  |  Branch (522:12): [Folded, False: 490M]
  ------------------
  523|   490M|                                           : (size_t{1} << capacity_data_) - 1;
  524|   490M|  }
_ZNK4absl12lts_2026052618container_internal12CommonFields8capacityEv:
 1232|   262M|  size_t capacity() const { return capacity_impl().capacity(); }
_ZNK4absl12lts_2026052618container_internal12CommonFields8is_smallEv:
 1242|  80.7M|  bool is_small() const { return inline_data_.is_small(); }
_ZNK4absl12lts_2026052618container_internal12CommonFields9has_infozEv:
 1258|  4.21M|  bool has_infoz() const { return inline_data_.has_infoz(); }
_ZN4absl12lts_2026052618container_internal12CommonFields5infozEv:
 1274|  4.16M|  HashtablezInfoHandle infoz() {
 1275|  4.16M|    return has_infoz() ? *infoz_ptr() : HashtablezInfoHandle();
  ------------------
  |  Branch (1275:12): [True: 0, False: 4.16M]
  ------------------
 1276|  4.16M|  }
_ZNK4absl12lts_2026052618container_internal12CommonFields15AssertInSooModeEv:
 1342|  9.92k|  void AssertInSooMode() const {
 1343|  9.92k|    ABSL_SWISSTABLE_ASSERT(capacity() == SooCapacity());
  ------------------
  |  |  256|  9.92k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1344|       |    ABSL_SWISSTABLE_ASSERT(!has_infoz());
  ------------------
  |  |  256|  9.92k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1345|  9.92k|  }
_ZNK4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE4maskEm:
  536|   227M|  constexpr size_t mask(size_t value) const {
  537|       |#ifdef __BMI2__
  538|       |    if constexpr (StorageMode == kCapacityByLog) {
  539|       |      if constexpr (sizeof(size_t) == 8) {
  540|       |        return _bzhi_u64(value, capacity_data_);
  541|       |      } else {
  542|       |        return _bzhi_u32(value, capacity_data_);
  543|       |      }
  544|       |    }
  545|       |#endif  // __BMI2__
  546|   227M|    return value & capacity();
  547|   227M|  }
_ZN4absl12lts_2026052618container_internal22MaxValidSizeForKeySizeILm8EEEmm:
 1819|  5.83k|constexpr size_t MaxValidSizeForKeySize(size_t key_size) {
 1820|  5.83k|  if (key_size < kSizeOfSizeT) return size_t{1} << 8 * key_size;
  ------------------
  |  Branch (1820:7): [True: 0, False: 5.83k]
  ------------------
 1821|  5.83k|  return (std::numeric_limits<size_t>::max)();
 1822|  5.83k|}
_ZN4absl12lts_2026052618container_internal23MaxValidSizeForSlotSizeILm8EEEmm:
 1825|  5.83k|constexpr size_t MaxValidSizeForSlotSize(size_t slot_size) {
 1826|  5.83k|  if constexpr (kSizeOfSizeT == 8) {
 1827|       |    // For small slot sizes we are limited by HashtableStackData::kSizeBitCount.
 1828|  5.83k|    if (slot_size < size_t{1} << (64 - HashtableInlineData::kSizeBitCount)) {
  ------------------
  |  Branch (1828:9): [True: 5.83k, False: 0]
  ------------------
 1829|  5.83k|      return MaxStorableSize();
 1830|  5.83k|    }
 1831|  5.83k|  }
 1832|      0|  return MaxSizeAtMaxValidCapacity<kSizeOfSizeT>(slot_size);
 1833|  5.83k|}
_ZN4absl12lts_2026052618container_internal12MaxValidSizeILm8EEEmmm:
 1838|  5.83k|constexpr size_t MaxValidSize(size_t key_size, size_t slot_size) {
 1839|  5.83k|  return (std::min)(MaxValidSizeForKeySize<kSizeOfSizeT>(key_size),
 1840|  5.83k|                    MaxValidSizeForSlotSize<kSizeOfSizeT>(slot_size));
 1841|  5.83k|}
_ZN4absl12lts_2026052618container_internal10SooControlEv:
  340|  97.9k|inline ctrl_t* SooControl() {
  341|       |  // Const must be cast away here; no uses of this function will actually write
  342|       |  // to it because it is only used for SOO iterators.
  343|  97.9k|  return const_cast<ctrl_t*>(kSooControl);
  344|  97.9k|}
_ZN4absl12lts_2026052618container_internal11SooCapacityEv:
  364|  12.8k|constexpr size_t SooCapacity() { return 1; }
_ZN4absl12lts_2026052618container_internal16MaxSmallCapacityEv:
  366|   251M|constexpr size_t MaxSmallCapacity() { return 1; }
_ZN4absl12lts_2026052618container_internal15IsValidCapacityEm:
  381|   246k|constexpr bool IsValidCapacity(size_t n) { return ((n + 1) & n) == 0 && n > 0; }
  ------------------
  |  Branch (381:51): [True: 246k, False: 0]
  |  Branch (381:73): [True: 176k, False: 70.6k]
  ------------------
_ZN4absl12lts_2026052618container_internal15IsSmallCapacityEm:
  384|   251M|constexpr bool IsSmallCapacity(size_t capacity) {
  385|   251M|  return capacity <= MaxSmallCapacity();
  386|   251M|}
_ZN4absl12lts_2026052618container_internal16PreviousCapacityEm:
  400|  84.1k|constexpr size_t PreviousCapacity(size_t n) {
  401|       |  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(n));
  ------------------
  |  |  256|  84.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  402|  84.1k|  return n / 2;
  403|  84.1k|}
_ZN4absl12lts_2026052618container_internal16CapacityToGrowthEm:
  415|   178k|constexpr size_t CapacityToGrowth(size_t capacity) {
  416|   178k|  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(capacity));
  ------------------
  |  |  256|   178k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  417|       |  // `capacity*7/8`
  418|   178k|  if (Group::kWidth == 8 && capacity == 7) {
  ------------------
  |  Branch (418:7): [Folded, False: 178k]
  |  Branch (418:29): [True: 0, False: 0]
  ------------------
  419|       |    // x-x/8 does not work when x==7.
  420|      0|    return 6;
  421|      0|  }
  422|   178k|  return capacity - capacity / 8;
  423|   178k|}
_ZN4absl12lts_2026052618container_internal14SizeToCapacityEm:
  430|  11.6k|constexpr size_t SizeToCapacity(size_t size) {
  431|  11.6k|  if (size == 0) {
  ------------------
  |  Branch (431:7): [True: 0, False: 11.6k]
  ------------------
  432|      0|    return 0;
  433|      0|  }
  434|       |  // The minimum possible capacity is NormalizeCapacity(size).
  435|       |  // Shifting right `~size_t{}` by `leading_zeros` yields
  436|       |  // NormalizeCapacity(size).
  437|  11.6k|  int leading_zeros = absl::countl_zero(size);
  438|  11.6k|  constexpr size_t kLast3Bits = size_t{7} << (sizeof(size_t) * 8 - 3);
  439|       |  // max_size_for_next_capacity = max_load_factor * next_capacity
  440|       |  //                            = (7/8) * (~size_t{} >> leading_zeros)
  441|       |  //                            = (7/8*~size_t{}) >> leading_zeros
  442|       |  //                            = kLast3Bits >> leading_zeros
  443|  11.6k|  size_t max_size_for_next_capacity = kLast3Bits >> leading_zeros;
  444|       |  // Decrease shift if size is too big for the minimum capacity.
  445|  11.6k|  leading_zeros -= static_cast<int>(size > max_size_for_next_capacity);
  446|       |  if constexpr (Group::kWidth == 8) {
  447|       |    // Formula doesn't work when size==7 for 8-wide groups.
  448|       |    leading_zeros -= (size == 7);
  449|       |  }
  450|  11.6k|  return (~size_t{}) >> leading_zeros;
  451|  11.6k|}
_ZN4absl12lts_2026052618container_internal2H1Em:
  740|  85.5M|inline size_t H1(size_t hash) { return hash; }
_ZN4absl12lts_2026052618container_internal2H2Em:
  745|  89.4M|inline h2_t H2(size_t hash) { return hash >> (sizeof(size_t) * 8 - 7); }
_ZN4absl12lts_2026052618container_internal14NumClonedBytesEv:
  985|   258M|constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
_ZN4absl12lts_2026052618container_internal15NumControlBytesEm:
  988|   250M|constexpr size_t NumControlBytes(size_t capacity) {
  989|   250M|  return IsSmallCapacity(capacity) ? 0 : capacity + 1 + NumClonedBytes();
  ------------------
  |  Branch (989:10): [True: 128k, False: 250M]
  ------------------
  990|   250M|}
_ZN4absl12lts_2026052618container_internal24HasGrowthInfoForCapacityEm:
  993|   529k|constexpr bool HasGrowthInfoForCapacity(size_t capacity) {
  994|   529k|  return !IsSmallCapacity(capacity);
  995|   529k|}
_ZN4absl12lts_2026052618container_internal13ControlOffsetEbb:
  999|   523k|constexpr size_t ControlOffset(bool has_infoz, bool has_growth_info) {
 1000|   523k|  if (ABSL_PREDICT_FALSE(has_infoz)) {
  ------------------
  |  |  190|   523k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 523k]
  |  |  |  Branch (190:49): [Folded, False: 523k]
  |  |  |  Branch (190:58): [True: 0, False: 523k]
  |  |  ------------------
  ------------------
 1001|       |    // We always allocate GrowthInfo for sampled tables to allow branchless
 1002|       |    // access to infoz pointer.
 1003|      0|    return sizeof(HashtablezInfoHandle) + sizeof(GrowthInfo);
 1004|      0|  }
 1005|   523k|  return has_growth_info ? sizeof(GrowthInfo) : 0;
  ------------------
  |  Branch (1005:10): [True: 438k, False: 85.4k]
  ------------------
 1006|   523k|}
_ZN4absl12lts_2026052618container_internal12AssertIsFullEPKNS1_6ctrl_tEhPKhPKc:
 1413|  95.9M|                         const char* operation) {
 1414|  95.9M|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1414:7): [True: 95.9M, Folded]
  ------------------
 1415|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1416|       |  // enabled. To minimize their impact in those builds:
 1417|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1418|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1419|       |  //   the chances that the hot paths will be inlined.
 1420|      0|  if (ABSL_PREDICT_FALSE(ctrl == nullptr)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1421|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1422|      0|  }
 1423|      0|  if (ABSL_PREDICT_FALSE(ctrl == DefaultIterControl())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1424|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1425|      0|                 operation);
 1426|      0|  }
 1427|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1427:7): [Folded, False: 0]
  ------------------
 1428|      0|    if (ABSL_PREDICT_FALSE(generation !=
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1429|      0|                           CrashIfIteratorIsInvalid(generation_ptr))) {
 1430|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1431|      0|                   "%s called on invalid iterator. The table could have "
 1432|      0|                   "rehashed or moved since this iterator was initialized.",
 1433|      0|                   operation);
 1434|      0|    }
 1435|      0|    if (ABSL_PREDICT_FALSE(!IsFull(CrashIfIteratorIsInvalid(ctrl)))) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1436|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1437|      0|          FATAL,
 1438|      0|          "%s called on invalid iterator. The element was likely erased.",
 1439|      0|          operation);
 1440|      0|    }
 1441|      0|  } else {
 1442|      0|    if (ABSL_PREDICT_FALSE(!IsFull(CrashIfIteratorIsInvalid(ctrl)))) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1443|       |      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1444|      0|          FATAL,
 1445|      0|          "%s called on invalid iterator. The element might have been erased "
 1446|      0|          "or the table might have rehashed. Consider running with "
 1447|      0|          "--config=asan to diagnose rehashing issues.",
 1448|      0|          operation);
 1449|      0|    }
 1450|      0|  }
 1451|      0|}
_ZN4absl12lts_2026052618container_internal26AssertIsValidForComparisonEPKNS1_6ctrl_tEhPKh:
 1456|   123M|                                       const GenerationType* generation_ptr) {
 1457|   123M|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1457:7): [True: 123M, Folded]
  ------------------
 1458|      0|  const bool ctrl_is_valid_for_comparison =
 1459|      0|      ctrl == nullptr || ctrl == DefaultIterControl() ||
  ------------------
  |  Branch (1459:7): [True: 0, False: 0]
  |  Branch (1459:26): [True: 0, False: 0]
  ------------------
 1460|      0|      IsFull(CrashIfIteratorIsInvalid(ctrl));
  ------------------
  |  Branch (1460:7): [True: 0, False: 0]
  ------------------
 1461|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1461:7): [Folded, False: 0]
  ------------------
 1462|      0|    if (ABSL_PREDICT_FALSE(generation !=
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1463|      0|                           CrashIfIteratorIsInvalid(generation_ptr))) {
 1464|       |      // Note: in the case of a rehash, we would expect to see a sanitizer crash
 1465|       |      // in CrashIfIteratorIsInvalid so this assertion will only catch moved
 1466|       |      // table cases, unless we're using a custom allocator that does not
 1467|       |      // deallocate the old backing array (e.g. an arena allocator).
 1468|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1469|      0|          FATAL,
 1470|      0|          "Invalid iterator comparison. The table was likely moved (or "
 1471|      0|          "possibly rehashed) since this iterator was initialized.");
 1472|      0|    }
 1473|      0|    if (ABSL_PREDICT_FALSE(!ctrl_is_valid_for_comparison)) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1474|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1475|      0|          FATAL, "Invalid iterator comparison. The element was likely erased.");
 1476|      0|    }
 1477|      0|  } else {
 1478|      0|    ABSL_HARDENING_ASSERT_SLOW(
  ------------------
  |  |  175|      0|#define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  127|      0|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (87:42): [Folded, False: 0]
  |  |  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (87:57): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1479|      0|        ctrl_is_valid_for_comparison &&
 1480|      0|        "Invalid iterator comparison. The element might have been erased or "
 1481|      0|        "the table might have rehashed. Consider running with --config=asan to "
 1482|      0|        "diagnose rehashing issues.");
 1483|      0|  }
 1484|      0|}
_ZN4absl12lts_2026052618container_internal19AssertSameContainerEPKNS1_6ctrl_tES4_RKPKvS8_PKhSA_:
 1516|  61.5M|                                const GenerationType* generation_ptr_b) {
 1517|  61.5M|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1517:7): [True: 61.5M, Folded]
  ------------------
 1518|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1519|       |  // enabled. To minimize their impact in those builds:
 1520|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1521|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1522|       |  //   the chances that the hot paths will be inlined.
 1523|       |
 1524|       |  // fail_if(is_invalid, message) crashes when is_invalid is true and provides
 1525|       |  // an error message based on `message`.
 1526|      0|  const auto fail_if = [](bool is_invalid, const char* message) {
 1527|      0|    if (ABSL_PREDICT_FALSE(is_invalid)) {
 1528|      0|      ABSL_RAW_LOG(FATAL, "Invalid iterator comparison. %s", message);
 1529|      0|    }
 1530|      0|  };
 1531|       |
 1532|      0|  const bool a_is_default = ctrl_a == DefaultIterControl();
 1533|      0|  const bool b_is_default = ctrl_b == DefaultIterControl();
 1534|      0|  if (a_is_default && b_is_default) return;
  ------------------
  |  Branch (1534:7): [True: 0, False: 0]
  |  Branch (1534:23): [True: 0, False: 0]
  ------------------
 1535|      0|  fail_if(a_is_default != b_is_default,
 1536|      0|          "Comparing default-constructed hashtable iterator with a "
 1537|      0|          "non-default-constructed hashtable iterator.");
 1538|       |
 1539|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1539:7): [Folded, False: 0]
  ------------------
 1540|      0|    if (ABSL_PREDICT_TRUE(generation_ptr_a == generation_ptr_b)) return;
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1541|      0|    const bool a_is_empty = IsEmptyGeneration(generation_ptr_a);
 1542|      0|    const bool b_is_empty = IsEmptyGeneration(generation_ptr_b);
 1543|      0|    fail_if(a_is_empty != b_is_empty,
 1544|      0|            "Comparing an iterator from an empty hashtable with an iterator "
 1545|      0|            "from a non-empty hashtable.");
 1546|      0|    fail_if(a_is_empty && b_is_empty,
  ------------------
  |  Branch (1546:13): [True: 0, False: 0]
  |  Branch (1546:27): [True: 0, False: 0]
  ------------------
 1547|      0|            "Comparing iterators from different empty hashtables.");
 1548|       |
 1549|      0|    const bool a_is_end = ctrl_a == nullptr;
 1550|      0|    const bool b_is_end = ctrl_b == nullptr;
 1551|      0|    fail_if(a_is_end || b_is_end,
  ------------------
  |  Branch (1551:13): [True: 0, False: 0]
  |  Branch (1551:25): [True: 0, False: 0]
  ------------------
 1552|      0|            "Comparing iterator with an end() iterator from a different "
 1553|      0|            "hashtable.");
 1554|      0|    fail_if(true, "Comparing non-end() iterators from different hashtables.");
 1555|      0|  } else {
 1556|      0|    ABSL_HARDENING_ASSERT_SLOW(
  ------------------
  |  |  175|      0|#define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  127|      0|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  |  |  ------------------
  |  |  |  |  |  |   87|      0|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (87:42): [Folded, False: 0]
  |  |  |  |  |  |  |  Branch (87:57): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (87:57): [True: 0, Folded]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1557|      0|        AreItersFromSameContainer(ctrl_a, ctrl_b, slot_a, slot_b) &&
 1558|      0|        "Invalid iterator comparison. The iterators may be from different "
 1559|      0|        "containers or the container might have rehashed or moved. Consider "
 1560|      0|        "running with --config=asan to diagnose issues.");
 1561|      0|  }
 1562|      0|}
_ZN4absl12lts_2026052618container_internal8probe_h1ENS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEEm:
 1625|  80.6M|                                         size_t h1) {
 1626|  80.6M|  return probe_seq<Group::kWidth>(capacity, h1);
 1627|  80.6M|}
_ZN4absl12lts_2026052618container_internal5probeENS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEEm:
 1628|  80.4M|inline probe_seq<Group::kWidth> probe(HashtableCapacity capacity, size_t hash) {
 1629|  80.4M|  return probe_h1(capacity, H1(hash));
 1630|  80.4M|}
_ZN4absl12lts_2026052618container_internal5probeERKNS1_12CommonFieldsEm:
 1631|  80.4M|inline probe_seq<Group::kWidth> probe(const CommonFields& common, size_t hash) {
 1632|  80.4M|  return probe(common.capacity_impl(), hash);
 1633|  80.4M|}
_ZN4absl12lts_2026052618container_internal15MaxStorableSizeEv:
 1809|  5.83k|constexpr size_t MaxStorableSize() {
 1810|  5.83k|  return static_cast<size_t>(uint64_t{1}
 1811|  5.83k|                             << HashtableInlineData::kSizeBitCount) -
 1812|  5.83k|         1;
 1813|  5.83k|}
_ZNK4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE9ToRawDataEv:
  506|   343k|  IntType ToRawData() const { return capacity_data_; }
_ZNK4absl12lts_2026052618container_internal19MaybeInitializedPtrINS1_6ctrl_tEE3getEv:
 1060|   250M|  T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
  ------------------
  |  |  488|   250M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
_ZNK4absl12lts_2026052618container_internal19MaybeInitializedPtrIvE3getEv:
 1060|   235M|  T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
  ------------------
  |  |  488|   235M|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE4sizeEv:
  645|  7.40M|  size_t size() const { return static_cast<size_t>(data_ >> kSizeShift); }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8set_sizeEm:
  663|  13.9k|  void set_size(size_t size) {
  664|  13.9k|    data_ =
  665|  13.9k|        (data_ & kMetadataMask) | (static_cast<uint64_t>(size) << kSizeShift);
  666|  13.9k|  }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE14decrement_sizeEv:
  650|  47.7k|  void decrement_size() { data_ -= kSizeOneNoMetadata; }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE26set_soo_has_tried_samplingEv:
  660|  9.92k|  void set_soo_has_tried_sampling() { data_ |= kSooHasTriedSamplingMask; }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE22soo_has_tried_samplingEv:
  655|  9.92k|  bool soo_has_tried_sampling() const {
  656|  9.92k|    return (data_ & kSooHasTriedSamplingMask) != 0;
  657|  9.92k|  }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE4seedEv:
  668|  85.6M|  PerTableSeed seed() const { return PerTableSeed(data_ & kSeedMask); }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8capacityEv:
  636|   424M|  HashtableCapacity capacity() const {
  637|   424M|    return HashtableCapacity::FromRawData(capacity_internal_);
  638|   424M|  }
_ZN4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE11FromRawDataEm:
  501|   424M|  static HashtableCapacityImpl FromRawData(uint64_t capacity) {
  502|   424M|    auto cap = HashtableCapacityImpl(uninitialized_tag_t{});
  503|   424M|    cap.capacity_data_ = static_cast<IntType>(capacity);
  504|   424M|    return cap;
  505|   424M|  }
_ZNK4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EE8is_smallEv:
  526|  80.7M|  constexpr bool is_small() const {
  527|       |    // Small tables have capacity 0 or 1. This expression is valid for both
  528|       |    // capacity storage modes.
  529|       |    // Comparing capacity_data_ directly leads to a better generated code.
  530|       |    // One byte comparison is used before computing the capacity in order to
  531|       |    // detect small tables faster for critical path.
  532|  80.7M|    static_assert(MaxSmallCapacity() == 1);
  533|  80.7M|    return capacity_data_ <= 1;
  534|  80.7M|  }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE8is_smallEv:
  639|  80.7M|  bool is_small() const { return capacity().is_small(); }
_ZNK4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EE9has_infozEv:
  683|  4.21M|  bool has_infoz() const {
  684|  4.21M|    return ABSL_PREDICT_FALSE((data_ & kHasInfozMask) != 0);
  ------------------
  |  |  190|  4.21M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:49): [Folded, False: 4.21M]
  |  |  |  Branch (190:58): [True: 0, False: 4.21M]
  |  |  ------------------
  ------------------
  685|  4.21M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEEC2Ev:
 2352|  1.44k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026052618container_internal12CommonFields13CreateDefaultILb1EEES2_v:
 1149|  9.98k|  static CommonFields CreateDefault() {
 1150|  9.98k|    return kSooEnabled ? CommonFields{soo_tag_t{}}
  ------------------
  |  Branch (1150:12): [True: 9.98k, Folded]
  ------------------
 1151|  9.98k|                       : CommonFields{non_soo_tag_t{}};
 1152|  9.98k|  }
_ZN4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEC2Em:
  491|   343k|      : capacity_data_(static_cast<IntType>(
  492|   343k|            StorageMode == kCapacityByValue ? capacity
  ------------------
  |  Branch (492:13): [Folded, False: 343k]
  ------------------
  493|   343k|                                            : TrailingZeros(capacity + 1))) {
  494|       |    ABSL_SWISSTABLE_ASSERT(capacity == 0 || IsValidCapacity(capacity));
  ------------------
  |  |  256|   343k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  495|   343k|  }
_ZN4absl12lts_2026052618container_internal23HashtableInlineDataImplILNS1_28HashtableCapacityStorageModeE1EEC2ENS1_21HashtableCapacityImplILS3_1EEENS1_19no_seed_empty_tag_tE:
  629|  81.7k|      : capacity_internal_(capacity.ToRawData()), data_(0) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE15destructor_implEv:
 3307|  1.44k|  void destructor_impl() {
 3308|  1.44k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3308:9): [Folded, False: 1.44k]
  |  Branch (3308:9): [Folded, False: 1.44k]
  ------------------
 3309|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (3309:9): [True: 0, False: 0]
  ------------------
 3310|      0|      return;
 3311|      0|    }
 3312|  1.44k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3312:9): [True: 0, False: 1.44k]
  ------------------
 3313|  1.44k|    if (is_small()) {
  ------------------
  |  Branch (3313:9): [True: 429, False: 1.01k]
  ------------------
 3314|    429|      if (!empty()) {
  ------------------
  |  Branch (3314:11): [True: 0, False: 429]
  ------------------
 3315|      0|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|      0|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3316|      0|      }
 3317|    429|      if constexpr (SooEnabled()) return;
 3318|  1.01k|    } else {
 3319|  1.01k|      destroy_slots();
 3320|  1.01k|    }
 3321|      0|    dealloc();
 3322|  1.44k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE6commonEv:
 3719|  37.8M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8capacityEv:
 2601|  6.33k|  size_t capacity() const {
 2602|  6.33k|    const size_t cap = common().capacity();
 2603|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2604|  6.33k|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2605|  6.33k|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2606|  6.33k|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2607|  6.33k|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  271|  6.33k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 6.33k, False: 0]
  |  |  |  Branch (271:44): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2608|  6.33k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  271|  6.33k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2609|  6.33k|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  271|  6.33k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2610|  6.33k|    return cap;
 2611|  6.33k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8is_smallEv:
 2117|  4.91M|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE5emptyEv:
 2593|  7.78k|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE4sizeEv:
 2594|  9.58k|  size_t size() const {
 2595|  9.58k|    AssertNotDebugCapacity();
 2596|  9.58k|    const size_t size = common().size();
 2597|  9.58k|    [[maybe_unused]] const size_t kMaxValidSize = MaxValidSize();
 2598|  9.58k|    ABSL_ASSUME(size <= kMaxValidSize);
  ------------------
  |  |  271|  9.58k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2599|  9.58k|    return size;
 2600|  9.58k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE22AssertNotDebugCapacityEv:
 3573|  9.94M|  void AssertNotDebugCapacity() const {
 3574|  9.94M|#ifdef NDEBUG
 3575|  9.94M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3575:9): [True: 9.94M, Folded]
  ------------------
 3576|  9.94M|      return;
 3577|  9.94M|    }
 3578|      0|#endif
 3579|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 3580|      0|    if (ABSL_PREDICT_TRUE(cap.IsValid())) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3581|      0|      return;
 3582|      0|    }
 3583|      0|    assert(!cap.IsReentrance() &&
 3584|      0|           "Reentrant container access during element construction/destruction "
 3585|      0|           "is not allowed.");
 3586|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3587|       |      if (cap.IsDestroyed()) {
 3588|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3589|       |      }
 3590|       |    }
 3591|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3591:9): [Folded, False: 0]
  ------------------
 3592|      0|        ABSL_PREDICT_FALSE(cap.IsMovedFrom())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3593|      0|      if (cap.IsSelfMovedFrom()) {
  ------------------
  |  Branch (3593:11): [True: 0, False: 0]
  ------------------
 3594|       |        // If this log triggers, then a hash table was move-assigned to itself
 3595|       |        // and then used again later without being reinitialized.
 3596|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3597|      0|      }
 3598|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3599|      0|    }
 3600|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7destroyEPNS1_13map_slot_typeImS8_EE:
 3211|  47.5k|  inline void destroy(slot_type* slot) {
 3212|  47.5k|    common().RunWithReentrancyGuard([&] {
 3213|  47.5k|      allocator_type alloc(char_alloc_ref());
 3214|  47.5k|      PolicyTraits::destroy(&alloc, slot);
 3215|  47.5k|    });
 3216|  47.5k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE6commonEv:
 3718|  15.3M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE14char_alloc_refEv:
 3772|   713k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7destroyEPNS1_13map_slot_typeImSA_EEEUlvE_EEvT_:
 1322|  47.5k|  void RunWithReentrancyGuard(F f) {
 1323|  47.5k|#ifdef NDEBUG
 1324|  47.5k|    f();
 1325|  47.5k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE11single_slotEv:
 3743|  4.71k|  slot_type* single_slot() {
 3744|  4.71k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  4.71k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3745|  4.71k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3745:12): [True: 4.71k, Folded]
  ------------------
 3746|  4.71k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8soo_slotEv:
 3734|  4.71k|  slot_type* soo_slot() {
 3735|  4.71k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  256|  4.71k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3736|  4.71k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(
  ------------------
  |  |  488|  4.71k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 3737|  4.71k|        static_cast<slot_type*>(common().soo_data()));
 3738|  4.71k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE10slot_arrayEv:
 3730|  13.6M|  slot_type* slot_array() const {
 3731|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  13.6M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3732|  13.6M|    return static_cast<slot_type*>(common().slot_array());
 3733|  13.6M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE13destroy_slotsEv:
 3280|  2.43k|  void destroy_slots() {
 3281|  2.43k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|  2.43k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3282|  2.43k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (3282:9): [True: 2.43k, Folded]
  ------------------
 3283|      0|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|      0|      this->destroy(static_cast<slot_type*>(slot));
 3285|      0|    };
 3286|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3287|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3288|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 3289|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3290|       |      common().set_capacity(common_copy.capacity());
 3291|      0|    } else {
 3292|      0|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3293|      0|    }
 3294|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7deallocEv:
 3296|  1.01k|  void dealloc() {
 3297|  1.01k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  256|  1.01k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3298|       |    // Unpoison before returning the memory to the allocator.
 3299|  1.01k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3300|  1.01k|    infoz().Unregister();
 3301|  1.01k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3302|  1.01k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3303|  1.01k|                                      sizeof(slot_type), alignof(slot_type),
 3304|  1.01k|                                      common().has_infoz());
 3305|  1.01k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE5infozEv:
 3763|  1.01k|  HashtablezInfoHandle infoz() {
 3764|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  1.01k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3765|  1.01k|    return common().infoz();
 3766|  1.01k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7controlEv:
 3726|  14.1M|  ctrl_t* control() const {
 3727|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  14.1M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3728|  14.1M|    return common().control();
 3729|  14.1M|  }
_ZN4absl12lts_2026052618container_internal12CommonFields13CreateDefaultILb0EEES2_v:
 1149|  69.3k|  static CommonFields CreateDefault() {
 1150|  69.3k|    return kSooEnabled ? CommonFields{soo_tag_t{}}
  ------------------
  |  Branch (1150:12): [Folded, False: 69.3k]
  ------------------
 1151|  69.3k|                       : CommonFields{non_soo_tag_t{}};
 1152|  69.3k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE15destructor_implEv:
 3307|  11.8k|  void destructor_impl() {
 3308|  11.8k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3308:9): [Folded, False: 11.8k]
  |  Branch (3308:9): [Folded, False: 11.8k]
  ------------------
 3309|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (3309:9): [True: 0, False: 0]
  ------------------
 3310|      0|      return;
 3311|      0|    }
 3312|  11.8k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3312:9): [True: 11.8k, False: 0]
  ------------------
 3313|      0|    if (is_small()) {
  ------------------
  |  Branch (3313:9): [True: 0, False: 0]
  ------------------
 3314|      0|      if (!empty()) {
  ------------------
  |  Branch (3314:11): [True: 0, False: 0]
  ------------------
 3315|      0|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|      0|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3316|      0|      }
 3317|       |      if constexpr (SooEnabled()) return;
 3318|      0|    } else {
 3319|      0|      destroy_slots();
 3320|      0|    }
 3321|      0|    dealloc();
 3322|      0|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6commonEv:
 3719|  58.9k|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8capacityEv:
 2601|  58.9k|  size_t capacity() const {
 2602|  58.9k|    const size_t cap = common().capacity();
 2603|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2604|  58.9k|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2605|  58.9k|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2606|  58.9k|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2607|  58.9k|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  271|   117k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 0, False: 58.9k]
  |  |  |  Branch (271:44): [True: 58.9k, False: 0]
  |  |  ------------------
  ------------------
 2608|  58.9k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  271|  58.9k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2609|  58.9k|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  271|  58.9k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2610|  58.9k|    return cap;
 2611|  58.9k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22AssertNotDebugCapacityEv:
 3573|  47.1k|  void AssertNotDebugCapacity() const {
 3574|  47.1k|#ifdef NDEBUG
 3575|  47.1k|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3575:9): [True: 47.1k, Folded]
  ------------------
 3576|  47.1k|      return;
 3577|  47.1k|    }
 3578|      0|#endif
 3579|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 3580|      0|    if (ABSL_PREDICT_TRUE(cap.IsValid())) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3581|      0|      return;
 3582|      0|    }
 3583|      0|    assert(!cap.IsReentrance() &&
 3584|      0|           "Reentrant container access during element construction/destruction "
 3585|      0|           "is not allowed.");
 3586|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3587|       |      if (cap.IsDestroyed()) {
 3588|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3589|       |      }
 3590|       |    }
 3591|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3591:9): [Folded, False: 0]
  ------------------
 3592|      0|        ABSL_PREDICT_FALSE(cap.IsMovedFrom())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3593|      0|      if (cap.IsSelfMovedFrom()) {
  ------------------
  |  Branch (3593:11): [True: 0, False: 0]
  ------------------
 3594|       |        // If this log triggers, then a hash table was move-assigned to itself
 3595|       |        // and then used again later without being reinitialized.
 3596|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3597|      0|      }
 3598|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3599|      0|    }
 3600|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6commonEv:
 3718|  94.2k|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEED2Ev:
 2561|  8.54k|  ~raw_hash_set() {
 2562|  8.54k|    destructor_impl();
 2563|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2564|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 2565|       |    }
 2566|  8.54k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE15destructor_implEv:
 3307|  8.54k|  void destructor_impl() {
 3308|  8.54k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3308:9): [Folded, False: 8.54k]
  |  Branch (3308:9): [Folded, False: 8.54k]
  ------------------
 3309|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (3309:9): [True: 0, False: 0]
  ------------------
 3310|      0|      return;
 3311|      0|    }
 3312|  8.54k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3312:9): [True: 0, False: 8.54k]
  ------------------
 3313|  8.54k|    if (is_small()) {
  ------------------
  |  Branch (3313:9): [True: 126, False: 8.41k]
  ------------------
 3314|    126|      if (!empty()) {
  ------------------
  |  Branch (3314:11): [True: 83, False: 43]
  ------------------
 3315|     83|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|     83|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3316|     83|      }
 3317|    126|      if constexpr (SooEnabled()) return;
 3318|  8.41k|    } else {
 3319|  8.41k|      destroy_slots();
 3320|  8.41k|    }
 3321|      0|    dealloc();
 3322|  8.54k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8capacityEv:
 2601|  25.3k|  size_t capacity() const {
 2602|  25.3k|    const size_t cap = common().capacity();
 2603|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2604|  25.3k|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2605|  25.3k|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2606|  25.3k|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2607|  25.3k|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  271|  25.3k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 25.3k, False: 0]
  |  |  |  Branch (271:44): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2608|  25.3k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  271|  25.3k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2609|  25.3k|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  271|  25.3k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2610|  25.3k|    return cap;
 2611|  25.3k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE6commonEv:
 3719|  81.8M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEC2ENS1_19uninitialized_tag_tE:
  489|   424M|  explicit HashtableCapacityImpl(uninitialized_tag_t) {}
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8is_smallEv:
 2117|  10.4M|  bool is_small() const { return common().is_small(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE7destroyEPNS1_13map_slot_typeIDilEE:
 3211|     83|  inline void destroy(slot_type* slot) {
 3212|     83|    common().RunWithReentrancyGuard([&] {
 3213|     83|      allocator_type alloc(char_alloc_ref());
 3214|     83|      PolicyTraits::destroy(&alloc, slot);
 3215|     83|    });
 3216|     83|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE6commonEv:
 3718|  31.8M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE7destroyEPNS1_13map_slot_typeIDilEEEUlvE_EEvT_:
 1322|     83|  void RunWithReentrancyGuard(F f) {
 1323|     83|#ifdef NDEBUG
 1324|     83|    f();
 1325|     83|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE7destroyEPNS1_13map_slot_typeIDilEEENKUlvE_clEv:
 3212|     83|    common().RunWithReentrancyGuard([&] {
 3213|     83|      allocator_type alloc(char_alloc_ref());
 3214|     83|      PolicyTraits::destroy(&alloc, slot);
 3215|     83|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE14char_alloc_refEv:
 3772|   562k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE11single_slotEv:
 3743|  75.0k|  slot_type* single_slot() {
 3744|  75.0k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  75.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3745|  75.0k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3745:12): [True: 75.0k, Folded]
  ------------------
 3746|  75.0k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8soo_slotEv:
 3734|  75.0k|  slot_type* soo_slot() {
 3735|  75.0k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  256|  75.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3736|  75.0k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(
  ------------------
  |  |  488|  75.0k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 3737|  75.0k|        static_cast<slot_type*>(common().soo_data()));
 3738|  75.0k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE13destroy_slotsEv:
 3280|  8.41k|  void destroy_slots() {
 3281|  8.41k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|  8.41k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3282|  8.41k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (3282:9): [True: 8.41k, Folded]
  ------------------
 3283|      0|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|      0|      this->destroy(static_cast<slot_type*>(slot));
 3285|      0|    };
 3286|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3287|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3288|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 3289|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3290|       |      common().set_capacity(common_copy.capacity());
 3291|      0|    } else {
 3292|      0|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3293|      0|    }
 3294|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE7deallocEv:
 3296|  8.41k|  void dealloc() {
 3297|  8.41k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  256|  8.41k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3298|       |    // Unpoison before returning the memory to the allocator.
 3299|  8.41k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3300|  8.41k|    infoz().Unregister();
 3301|  8.41k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3302|  8.41k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3303|  8.41k|                                      sizeof(slot_type), alignof(slot_type),
 3304|  8.41k|                                      common().has_infoz());
 3305|  8.41k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE10slot_arrayEv:
 3730|  30.0M|  slot_type* slot_array() const {
 3731|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  30.0M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3732|  30.0M|    return static_cast<slot_type*>(common().slot_array());
 3733|  30.0M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE5infozEv:
 3763|  8.41k|  HashtablezInfoHandle infoz() {
 3764|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  8.41k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3765|  8.41k|    return common().infoz();
 3766|  8.41k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE7controlEv:
 3726|  30.6M|  ctrl_t* control() const {
 3727|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  30.6M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3728|  30.6M|    return common().control();
 3729|  30.6M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEED2Ev:
 2561|  8.52k|  ~raw_hash_set() {
 2562|  8.52k|    destructor_impl();
 2563|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2564|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 2565|       |    }
 2566|  8.52k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE15destructor_implEv:
 3307|  8.52k|  void destructor_impl() {
 3308|  8.52k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3308:9): [Folded, False: 8.52k]
  |  Branch (3308:9): [Folded, False: 8.52k]
  ------------------
 3309|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (3309:9): [True: 0, False: 0]
  ------------------
 3310|      0|      return;
 3311|      0|    }
 3312|  8.52k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3312:9): [True: 27, False: 8.50k]
  ------------------
 3313|  8.50k|    if (is_small()) {
  ------------------
  |  Branch (3313:9): [True: 47, False: 8.45k]
  ------------------
 3314|     47|      if (!empty()) {
  ------------------
  |  Branch (3314:11): [True: 47, False: 0]
  ------------------
 3315|     47|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|     47|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3316|     47|      }
 3317|       |      if constexpr (SooEnabled()) return;
 3318|  8.45k|    } else {
 3319|  8.45k|      destroy_slots();
 3320|  8.45k|    }
 3321|  8.50k|    dealloc();
 3322|  8.50k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8capacityEv:
 2601|  25.5k|  size_t capacity() const {
 2602|  25.5k|    const size_t cap = common().capacity();
 2603|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2604|  25.5k|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2605|  25.5k|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2606|  25.5k|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2607|  25.5k|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  271|  25.5k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 25.5k, False: 27]
  |  |  |  Branch (271:44): [True: 27, False: 0]
  |  |  ------------------
  ------------------
 2608|  25.5k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  271|  25.5k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2609|  25.5k|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  271|  25.5k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2610|  25.5k|    return cap;
 2611|  25.5k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE6commonEv:
 3719|  69.0M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8is_smallEv:
 2117|  8.61M|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE5emptyEv:
 2593|  26.8k|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE4sizeEv:
 2594|  26.8k|  size_t size() const {
 2595|  26.8k|    AssertNotDebugCapacity();
 2596|  26.8k|    const size_t size = common().size();
 2597|  26.8k|    [[maybe_unused]] const size_t kMaxValidSize = MaxValidSize();
 2598|  26.8k|    ABSL_ASSUME(size <= kMaxValidSize);
  ------------------
  |  |  271|  26.8k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2599|  26.8k|    return size;
 2600|  26.8k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE22AssertNotDebugCapacityEv:
 3573|  8.63M|  void AssertNotDebugCapacity() const {
 3574|  8.63M|#ifdef NDEBUG
 3575|  8.63M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3575:9): [True: 8.63M, Folded]
  ------------------
 3576|  8.63M|      return;
 3577|  8.63M|    }
 3578|      0|#endif
 3579|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 3580|      0|    if (ABSL_PREDICT_TRUE(cap.IsValid())) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3581|      0|      return;
 3582|      0|    }
 3583|      0|    assert(!cap.IsReentrance() &&
 3584|      0|           "Reentrant container access during element construction/destruction "
 3585|      0|           "is not allowed.");
 3586|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3587|       |      if (cap.IsDestroyed()) {
 3588|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3589|       |      }
 3590|       |    }
 3591|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3591:9): [Folded, False: 0]
  ------------------
 3592|      0|        ABSL_PREDICT_FALSE(cap.IsMovedFrom())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3593|      0|      if (cap.IsSelfMovedFrom()) {
  ------------------
  |  Branch (3593:11): [True: 0, False: 0]
  ------------------
 3594|       |        // If this log triggers, then a hash table was move-assigned to itself
 3595|       |        // and then used again later without being reinitialized.
 3596|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3597|      0|      }
 3598|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3599|      0|    }
 3600|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE7destroyEPNS1_13map_slot_typeIDiS6_EE:
 3211|     47|  inline void destroy(slot_type* slot) {
 3212|     47|    common().RunWithReentrancyGuard([&] {
 3213|     47|      allocator_type alloc(char_alloc_ref());
 3214|     47|      PolicyTraits::destroy(&alloc, slot);
 3215|     47|    });
 3216|     47|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE6commonEv:
 3718|  18.2M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE7destroyEPNS1_13map_slot_typeIDiS8_EEEUlvE_EEvT_:
 1322|     47|  void RunWithReentrancyGuard(F f) {
 1323|     47|#ifdef NDEBUG
 1324|     47|    f();
 1325|     47|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE7destroyEPNS1_13map_slot_typeIDiS6_EEENKUlvE_clEv:
 3212|     47|    common().RunWithReentrancyGuard([&] {
 3213|     47|      allocator_type alloc(char_alloc_ref());
 3214|     47|      PolicyTraits::destroy(&alloc, slot);
 3215|     47|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE14char_alloc_refEv:
 3772|   712k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE11single_slotEv:
 3743|  11.2k|  slot_type* single_slot() {
 3744|  11.2k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  11.2k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3745|  11.2k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3745:12): [Folded, False: 11.2k]
  ------------------
 3746|  11.2k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE10slot_arrayEv:
 3730|  25.6M|  slot_type* slot_array() const {
 3731|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  25.6M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3732|  25.6M|    return static_cast<slot_type*>(common().slot_array());
 3733|  25.6M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE13destroy_slotsEv:
 3280|  8.45k|  void destroy_slots() {
 3281|  8.45k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|  8.45k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3282|  8.45k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (3282:9): [True: 8.45k, Folded]
  ------------------
 3283|      0|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|      0|      this->destroy(static_cast<slot_type*>(slot));
 3285|      0|    };
 3286|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3287|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3288|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 3289|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3290|       |      common().set_capacity(common_copy.capacity());
 3291|      0|    } else {
 3292|      0|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3293|      0|    }
 3294|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE7deallocEv:
 3296|  8.50k|  void dealloc() {
 3297|  8.50k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  256|  8.50k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3298|       |    // Unpoison before returning the memory to the allocator.
 3299|  8.50k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3300|  8.50k|    infoz().Unregister();
 3301|  8.50k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3302|  8.50k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3303|  8.50k|                                      sizeof(slot_type), alignof(slot_type),
 3304|  8.50k|                                      common().has_infoz());
 3305|  8.50k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE5infozEv:
 3763|  8.50k|  HashtablezInfoHandle infoz() {
 3764|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  8.50k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3765|  8.50k|    return common().infoz();
 3766|  8.50k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE7controlEv:
 3726|  25.7M|  ctrl_t* control() const {
 3727|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  25.7M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3728|  25.7M|    return common().control();
 3729|  25.7M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEED2Ev:
 2561|  18.0k|  ~raw_hash_set() {
 2562|  18.0k|    destructor_impl();
 2563|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2564|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 2565|       |    }
 2566|  18.0k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE15destructor_implEv:
 3307|  18.0k|  void destructor_impl() {
 3308|  18.0k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3308:9): [Folded, False: 18.0k]
  |  Branch (3308:9): [Folded, False: 18.0k]
  ------------------
 3309|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (3309:9): [True: 0, False: 0]
  ------------------
 3310|      0|      return;
 3311|      0|    }
 3312|  18.0k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3312:9): [True: 2.62k, False: 15.3k]
  ------------------
 3313|  15.3k|    if (is_small()) {
  ------------------
  |  Branch (3313:9): [True: 2.00k, False: 13.3k]
  ------------------
 3314|  2.00k|      if (!empty()) {
  ------------------
  |  Branch (3314:11): [True: 1.76k, False: 241]
  ------------------
 3315|  1.76k|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|  1.76k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3316|  1.76k|      }
 3317|       |      if constexpr (SooEnabled()) return;
 3318|  13.3k|    } else {
 3319|  13.3k|      destroy_slots();
 3320|  13.3k|    }
 3321|  15.3k|    dealloc();
 3322|  15.3k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8capacityEv:
 2601|  54.6k|  size_t capacity() const {
 2602|  54.6k|    const size_t cap = common().capacity();
 2603|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2604|  54.6k|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2605|  54.6k|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2606|  54.6k|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2607|  54.6k|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  271|  57.8k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 51.4k, False: 3.19k]
  |  |  |  Branch (271:44): [True: 3.19k, False: 0]
  |  |  ------------------
  ------------------
 2608|  54.6k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  271|  54.6k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2609|  54.6k|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  271|  54.6k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2610|  54.6k|    return cap;
 2611|  54.6k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE6commonEv:
 3719|   121M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8is_smallEv:
 2117|  14.8M|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE5emptyEv:
 2593|  67.1k|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE4sizeEv:
 2594|  6.96M|  size_t size() const {
 2595|  6.96M|    AssertNotDebugCapacity();
 2596|  6.96M|    const size_t size = common().size();
 2597|  6.96M|    [[maybe_unused]] const size_t kMaxValidSize = MaxValidSize();
 2598|  6.96M|    ABSL_ASSUME(size <= kMaxValidSize);
  ------------------
  |  |  271|  6.96M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2599|  6.96M|    return size;
 2600|  6.96M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE22AssertNotDebugCapacityEv:
 3573|  25.3M|  void AssertNotDebugCapacity() const {
 3574|  25.3M|#ifdef NDEBUG
 3575|  25.3M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3575:9): [True: 25.3M, Folded]
  ------------------
 3576|  25.3M|      return;
 3577|  25.3M|    }
 3578|      0|#endif
 3579|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 3580|      0|    if (ABSL_PREDICT_TRUE(cap.IsValid())) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3581|      0|      return;
 3582|      0|    }
 3583|      0|    assert(!cap.IsReentrance() &&
 3584|      0|           "Reentrant container access during element construction/destruction "
 3585|      0|           "is not allowed.");
 3586|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3587|       |      if (cap.IsDestroyed()) {
 3588|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3589|       |      }
 3590|       |    }
 3591|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3591:9): [Folded, False: 0]
  ------------------
 3592|      0|        ABSL_PREDICT_FALSE(cap.IsMovedFrom())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3593|      0|      if (cap.IsSelfMovedFrom()) {
  ------------------
  |  Branch (3593:11): [True: 0, False: 0]
  ------------------
 3594|       |        // If this log triggers, then a hash table was move-assigned to itself
 3595|       |        // and then used again later without being reinitialized.
 3596|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3597|      0|      }
 3598|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3599|      0|    }
 3600|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7destroyEPNS1_13map_slot_typeISA_lEE:
 3211|  2.14M|  inline void destroy(slot_type* slot) {
 3212|  2.14M|    common().RunWithReentrancyGuard([&] {
 3213|  2.14M|      allocator_type alloc(char_alloc_ref());
 3214|  2.14M|      PolicyTraits::destroy(&alloc, slot);
 3215|  2.14M|    });
 3216|  2.14M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE6commonEv:
 3718|  40.8M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE7destroyEPNS1_13map_slot_typeISC_lEEEUlvE_EEvT_:
 1322|  2.14M|  void RunWithReentrancyGuard(F f) {
 1323|  2.14M|#ifdef NDEBUG
 1324|  2.14M|    f();
 1325|  2.14M|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7destroyEPNS1_13map_slot_typeISA_lEEENKUlvE_clEv:
 3212|  2.14M|    common().RunWithReentrancyGuard([&] {
 3213|  2.14M|      allocator_type alloc(char_alloc_ref());
 3214|  2.14M|      PolicyTraits::destroy(&alloc, slot);
 3215|  2.14M|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14char_alloc_refEv:
 3772|  7.34M|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE11single_slotEv:
 3743|  47.5k|  slot_type* single_slot() {
 3744|  47.5k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  47.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3745|  47.5k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3745:12): [Folded, False: 47.5k]
  ------------------
 3746|  47.5k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10slot_arrayEv:
 3730|  39.4M|  slot_type* slot_array() const {
 3731|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  39.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3732|  39.4M|    return static_cast<slot_type*>(common().slot_array());
 3733|  39.4M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE13destroy_slotsEv:
 3280|  18.4k|  void destroy_slots() {
 3281|  18.4k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|  18.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3282|  18.4k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (3282:9): [Folded, False: 18.4k]
  ------------------
 3283|  18.4k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|  18.4k|      this->destroy(static_cast<slot_type*>(slot));
 3285|  18.4k|    };
 3286|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3287|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3288|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 3289|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3290|       |      common().set_capacity(common_copy.capacity());
 3291|  18.4k|    } else {
 3292|  18.4k|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3293|  18.4k|    }
 3294|  18.4k|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE13destroy_slotsEvENKUlPKNS1_6ctrl_tEPvE_clESF_SG_:
 3283|  2.13M|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|  2.13M|      this->destroy(static_cast<slot_type*>(slot));
 3285|  2.13M|    };
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7deallocEv:
 3296|  15.3k|  void dealloc() {
 3297|  15.3k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  256|  15.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3298|       |    // Unpoison before returning the memory to the allocator.
 3299|  15.3k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3300|  15.3k|    infoz().Unregister();
 3301|  15.3k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3302|  15.3k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3303|  15.3k|                                      sizeof(slot_type), alignof(slot_type),
 3304|  15.3k|                                      common().has_infoz());
 3305|  15.3k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE5infozEv:
 3763|  15.3k|  HashtablezInfoHandle infoz() {
 3764|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  15.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3765|  15.3k|    return common().infoz();
 3766|  15.3k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7controlEv:
 3726|  42.4M|  ctrl_t* control() const {
 3727|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  42.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3728|  42.4M|    return common().control();
 3729|  42.4M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEED2Ev:
 2561|  18.3k|  ~raw_hash_set() {
 2562|  18.3k|    destructor_impl();
 2563|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2564|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 2565|       |    }
 2566|  18.3k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE15destructor_implEv:
 3307|  18.3k|  void destructor_impl() {
 3308|  18.3k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3308:9): [Folded, False: 18.3k]
  |  Branch (3308:9): [Folded, False: 18.3k]
  ------------------
 3309|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (3309:9): [True: 0, False: 0]
  ------------------
 3310|      0|      return;
 3311|      0|    }
 3312|  18.3k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3312:9): [True: 8.49k, False: 9.88k]
  ------------------
 3313|  9.88k|    if (is_small()) {
  ------------------
  |  Branch (3313:9): [True: 59, False: 9.82k]
  ------------------
 3314|     59|      if (!empty()) {
  ------------------
  |  Branch (3314:11): [True: 59, False: 0]
  ------------------
 3315|     59|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|     59|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3316|     59|      }
 3317|       |      if constexpr (SooEnabled()) return;
 3318|  9.82k|    } else {
 3319|  9.82k|      destroy_slots();
 3320|  9.82k|    }
 3321|  9.88k|    dealloc();
 3322|  9.88k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8capacityEv:
 2601|  38.1k|  size_t capacity() const {
 2602|  38.1k|    const size_t cap = common().capacity();
 2603|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2604|  38.1k|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2605|  38.1k|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2606|  38.1k|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2607|  38.1k|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  271|  46.6k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 29.6k, False: 8.49k]
  |  |  |  Branch (271:44): [True: 8.49k, False: 0]
  |  |  ------------------
  ------------------
 2608|  38.1k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  271|  38.1k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2609|  38.1k|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  271|  38.1k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2610|  38.1k|    return cap;
 2611|  38.1k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE6commonEv:
 3719|  3.46M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8is_smallEv:
 2117|   431k|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE5emptyEv:
 2593|  19.7k|  bool empty() const { return !size(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7destroyEPSA_:
 3211|   421k|  inline void destroy(slot_type* slot) {
 3212|   421k|    common().RunWithReentrancyGuard([&] {
 3213|   421k|      allocator_type alloc(char_alloc_ref());
 3214|   421k|      PolicyTraits::destroy(&alloc, slot);
 3215|   421k|    });
 3216|   421k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE6commonEv:
 3718|  2.68M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEE7destroyEPSC_EUlvE_EEvT_:
 1322|   421k|  void RunWithReentrancyGuard(F f) {
 1323|   421k|#ifdef NDEBUG
 1324|   421k|    f();
 1325|   421k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7destroyEPSA_ENKUlvE_clEv:
 3212|   421k|    common().RunWithReentrancyGuard([&] {
 3213|   421k|      allocator_type alloc(char_alloc_ref());
 3214|   421k|      PolicyTraits::destroy(&alloc, slot);
 3215|   421k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE14char_alloc_refEv:
 3772|  1.42M|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE11single_slotEv:
 3743|  9.88k|  slot_type* single_slot() {
 3744|  9.88k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  9.88k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3745|  9.88k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3745:12): [Folded, False: 9.88k]
  ------------------
 3746|  9.88k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE10slot_arrayEv:
 3730|   885k|  slot_type* slot_array() const {
 3731|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   885k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3732|   885k|    return static_cast<slot_type*>(common().slot_array());
 3733|   885k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE13destroy_slotsEv:
 3280|  9.82k|  void destroy_slots() {
 3281|  9.82k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|  9.82k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3282|  9.82k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (3282:9): [Folded, False: 9.82k]
  ------------------
 3283|  9.82k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|  9.82k|      this->destroy(static_cast<slot_type*>(slot));
 3285|  9.82k|    };
 3286|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3287|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3288|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 3289|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3290|       |      common().set_capacity(common_copy.capacity());
 3291|  9.82k|    } else {
 3292|  9.82k|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3293|  9.82k|    }
 3294|  9.82k|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE13destroy_slotsEvENKUlPKNS1_6ctrl_tEPvE_clESF_SG_:
 3283|   421k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|   421k|      this->destroy(static_cast<slot_type*>(slot));
 3285|   421k|    };
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7deallocEv:
 3296|  9.88k|  void dealloc() {
 3297|  9.88k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  256|  9.88k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3298|       |    // Unpoison before returning the memory to the allocator.
 3299|  9.88k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3300|  9.88k|    infoz().Unregister();
 3301|  9.88k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3302|  9.88k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3303|  9.88k|                                      sizeof(slot_type), alignof(slot_type),
 3304|  9.88k|                                      common().has_infoz());
 3305|  9.88k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE5infozEv:
 3763|  9.88k|  HashtablezInfoHandle infoz() {
 3764|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  9.88k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3765|  9.88k|    return common().infoz();
 3766|  9.88k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7controlEv:
 3726|  1.21M|  ctrl_t* control() const {
 3727|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  1.21M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3728|  1.21M|    return common().control();
 3729|  1.21M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEEC2Ev:
 2352|  8.54k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE5emptyEv:
 2593|  76.9k|  bool empty() const { return !size(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEEC2Ev:
 2352|  8.52k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE15unchecked_derefENS8_8iteratorE:
 3682|  8.59M|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8iterator15unchecked_derefEv:
 2282|  8.90M|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE22find_or_prepare_insertIDiEENS5_INS8_8iteratorEbEERKT_:
 3646|  8.59M|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3647|  8.59M|    AssertOnFind(key);
 3648|  8.59M|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3648:9): [True: 18.3k, False: 8.58M]
  ------------------
 3649|  8.58M|    return find_or_prepare_insert_large(key);
 3650|  8.59M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE12AssertOnFindIDiEEvRKT_:
 3567|  8.59M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3568|  8.59M|    AssertHashEqConsistent(key);
 3569|  8.59M|    AssertNotDebugCapacity();
 3570|  8.59M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE22AssertHashEqConsistentIDiEEvRKT_:
 3605|  8.59M|  void AssertHashEqConsistent(const K& key) {
 3606|  8.59M|#ifdef NDEBUG
 3607|  8.59M|    return;
 3608|      0|#endif
 3609|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3610|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3610:9): [Folded, False: 0]
  ------------------
 3611|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3611:9): [Folded, False: 0]
  ------------------
 3612|      0|      return;
 3613|      0|    }
 3614|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3614:9): [True: 0, Folded]
  ------------------
 3615|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3615:9): [True: 0, Folded]
  ------------------
 3616|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3616:9): [True: 0, Folded]
  ------------------
 3617|      0|      return;
 3618|      0|    }
 3619|      0|    if (empty()) return;
  ------------------
  |  Branch (3619:9): [True: 0, False: 0]
  ------------------
 3620|       |
 3621|      0|    const size_t hash_of_arg = hash_of(key);
 3622|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3623|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3624|      0|      if (!is_key_equal) return;
 3625|       |
 3626|      0|      [[maybe_unused]] const bool is_hash_equal =
 3627|      0|          hash_of_arg == hash_of(to_slot(slot));
 3628|      0|      assert((!is_key_equal || is_hash_equal) &&
 3629|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3630|      0|             "hash/eq functors are inconsistent.");
 3631|      0|    };
 3632|       |
 3633|      0|    if (is_small()) {
  ------------------
  |  Branch (3633:9): [True: 0, False: 0]
  ------------------
 3634|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3635|      0|      return;
 3636|      0|    }
 3637|       |    // We only do validation for small tables so that it's constant time.
 3638|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3638:9): [True: 0, False: 0]
  ------------------
 3639|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3640|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE28find_or_prepare_insert_smallIDiEENS5_INS8_8iteratorEbEERKT_:
 3497|  18.3k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3498|  18.3k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  18.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3499|       |    if constexpr (SooEnabled()) {
 3500|       |      return find_or_prepare_insert_soo(key);
 3501|       |    }
 3502|  18.3k|    if (!empty()) {
  ------------------
  |  Branch (3502:9): [True: 9.79k, False: 8.50k]
  ------------------
 3503|  9.79k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3503:11): [True: 1.34k, False: 8.45k]
  ------------------
 3504|  1.34k|        return {single_iterator(), false};
 3505|  1.34k|      }
 3506|  9.79k|    }
 3507|  16.9k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3508|  16.9k|                common(), GetPolicyFunctions(),
 3509|  16.9k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3510|  16.9k|            true};
 3511|  18.3k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8equal_toIDiEEbRKT_PNS1_13map_slot_typeIDiS6_EE:
 3344|  8.48M|                                             slot_type* slot) const {
 3345|  8.48M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3346|  8.48M|                               PolicyTraits::element(slot));
 3347|  8.48M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE6eq_refEv:
 3771|  8.48M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE15single_iteratorEv:
 3757|  1.39k|  iterator single_iterator() {
 3758|  1.39k|    return {SooControl(), single_slot(), common().generation_ptr()};
 3759|  1.39k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIDiS6_EEPKh:
 2236|  8.59M|        : HashSetIteratorGenerationInfo(generation_ptr),
 2237|  8.59M|          ctrl_(ctrl),
 2238|  8.59M|          slot_(slot) {
 2239|       |      // This assumption helps the compiler know that any non-end iterator is
 2240|       |      // not equal to any end iterator.
 2241|  8.59M|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|  8.59M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2242|  8.59M|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE15iterator_at_ptrENS5_IPNS1_6ctrl_tEPvEE:
 3678|  16.9k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3679|  16.9k|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3680|  16.9k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE7to_slotEPv:
 3361|  86.4k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3362|  86.4k|    return static_cast<slot_type*>(buf);
 3363|  86.4k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE18GetPolicyFunctionsEv:
 3851|   300k|  static const PolicyFunctions& GetPolicyFunctions() {
 3852|   300k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3853|   300k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3854|   300k|                  "or use absl::node_hash_{map,set}.");
 3855|   300k|    static_assert(alignof(slot_type) <=
 3856|   300k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3857|   300k|    static_assert(sizeof(key_type) <=
 3858|   300k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3859|   300k|    static_assert(sizeof(value_type) <=
 3860|   300k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3861|   300k|    static constexpr size_t kBackingArrayAlignment =
 3862|   300k|        BackingArrayAlignment(alignof(slot_type));
 3863|   300k|    static constexpr PolicyFunctions value = {
 3864|   300k|        static_cast<uint32_t>(sizeof(key_type)),
 3865|   300k|        static_cast<uint32_t>(sizeof(value_type)),
 3866|   300k|        static_cast<uint32_t>(sizeof(slot_type)),
 3867|   300k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3868|   300k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3869|       |        // TODO(b/328722020): try to type erase
 3870|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3871|   300k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3871:9): [True: 0, Folded]
  ------------------
 3872|   300k|                                : &raw_hash_set::get_hash_ref_fn,
 3873|   300k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3874|   300k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3874:9): [Folded, False: 300k]
  ------------------
 3875|   300k|            ? TransferNRelocatable<sizeof(slot_type)>
 3876|   300k|            : &raw_hash_set::transfer_n_slots_fn,
 3877|   300k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3877:9): [True: 0, Folded]
  ------------------
 3878|   300k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3879|   300k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3880|   300k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3881|   300k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3882|   300k|    return value;
 3883|   300k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE19transfer_n_slots_fnEPvS9_S9_m:
 3787|  25.0k|                                  size_t count) {
 3788|  25.0k|    auto* src_slot = to_slot(src);
 3789|  25.0k|    auto* dst_slot = to_slot(dst);
 3790|       |
 3791|  25.0k|    auto* h = static_cast<raw_hash_set*>(set);
 3792|   102k|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3792:12): [True: 77.5k, False: 25.0k]
  ------------------
 3793|  77.5k|      h->transfer(dst_slot, src_slot);
 3794|  77.5k|    }
 3795|  25.0k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8transferEPNS1_13map_slot_typeIDiS6_EESB_:
 3217|   403k|  inline void transfer(slot_type* to, slot_type* from) {
 3218|   403k|    common().RunWithReentrancyGuard([&] {
 3219|   403k|      allocator_type alloc(char_alloc_ref());
 3220|   403k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   403k|    });
 3222|   403k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8transferEPNS1_13map_slot_typeIDiS8_EESD_EUlvE_EEvT_:
 1322|   403k|  void RunWithReentrancyGuard(F f) {
 1323|   403k|#ifdef NDEBUG
 1324|   403k|    f();
 1325|   403k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8transferEPNS1_13map_slot_typeIDiS6_EESB_ENKUlvE_clEv:
 3218|   403k|    common().RunWithReentrancyGuard([&] {
 3219|   403k|      allocator_type alloc(char_alloc_ref());
 3220|   403k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   403k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSE_PFvSE_hmmE:
 3804|  10.9k|                                    size_t source_offset, size_t h1)) {
 3805|  10.9k|    const size_t new_capacity = common.capacity();
 3806|  10.9k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3807|  10.9k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  271|  10.9k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3808|  10.9k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  271|  10.9k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3809|       |
 3810|  10.9k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3811|  10.9k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3812|  10.9k|    ctrl_t* new_ctrl = common.control();
 3813|  10.9k|    slot_type* new_slots = set->slot_array();
 3814|       |
 3815|  34.4k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3815:34): [True: 23.4k, False: 10.9k]
  ------------------
 3816|  23.4k|         group_index += Group::kWidth) {
 3817|  23.4k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3818|  23.4k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3819|  23.4k|                  Group::kWidth);
 3820|  23.4k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3821|  23.4k|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3822|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3823|       |      // We will share a lot of code in expense of one function call per group.
 3824|   328k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3824:38): [True: 328k, False: 23.4k]
  ------------------
 3825|   328k|        size_t old_index = group_index + in_fixed_group_index;
 3826|   328k|        slot_type* old_slot = old_slots_ptr + old_index;
 3827|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3828|       |        // only one new bit of h1.
 3829|   328k|        size_t hash = set->hash_of(old_slot);
 3830|   328k|        size_t h1 = H1(hash);
 3831|   328k|        h2_t h2 = H2(hash);
 3832|   328k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3833|   328k|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3834|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3835|       |        // till and included the old_index.
 3836|   328k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  190|   328k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2.79k, False: 325k]
  |  |  |  Branch (190:49): [Folded, False: 328k]
  |  |  |  Branch (190:58): [True: 2.79k, False: 325k]
  |  |  ------------------
  ------------------
 3837|  2.79k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3838|  2.79k|          continue;
 3839|  2.79k|        }
 3840|   325k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  256|   325k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3841|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  256|   325k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3842|   325k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3843|   325k|        auto* new_slot = new_slots + new_index;
 3844|   325k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3845|   325k|        set->transfer(new_slot, old_slot);
 3846|   325k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3847|   325k|      }
 3848|  23.4k|    }
 3849|  10.9k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE7hash_ofEPNS1_13map_slot_typeIDiS6_EE:
 3353|   328k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3354|   328k|    return PolicyTraits::apply(
 3355|   328k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3356|   328k|        PolicyTraits::element(slot));
 3357|   328k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8hash_refEv:
 3769|  8.90M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal16PerTableSeedImplIhEC2Em:
  605|  85.6M|      : seed_(static_cast<IntType>(seed)) {}
_ZNK4absl12lts_2026052618container_internal16PerTableSeedImplIhE4seedEv:
  598|  85.6M|  size_t seed() const { return seed_; }
_ZN4absl12lts_2026052618container_internal29TryFindNewIndexWithoutProbingIvEEmmmmPNS1_6ctrl_tEm:
 1652|  4.95M|                                            size_t new_capacity) {
 1653|  4.95M|  size_t index_diff = old_index - h1;
 1654|       |  // The first probe group starts with h1 & capacity.
 1655|       |  // All following groups start at (h1 + Group::kWidth * K) & capacity.
 1656|       |  // We can find an index within the floating group as index_diff modulo
 1657|       |  // Group::kWidth.
 1658|       |  // Both old and new capacity are larger than Group::kWidth so we can avoid
 1659|       |  // computing `& capacity`.
 1660|  4.95M|  size_t in_floating_group_index = index_diff & (Group::kWidth - 1);
 1661|       |  // By subtracting we will get the difference between the first probe group
 1662|       |  // and the probe group corresponding to old_index.
 1663|  4.95M|  index_diff -= in_floating_group_index;
 1664|  4.95M|  if (ABSL_PREDICT_TRUE((index_diff & old_capacity) == 0)) {
  ------------------
  |  |  191|  4.95M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 4.78M, False: 167k]
  |  |  |  Branch (191:48): [Folded, False: 4.95M]
  |  |  |  Branch (191:57): [True: 4.78M, False: 167k]
  |  |  ------------------
  ------------------
 1665|  4.78M|    size_t new_index = (h1 + in_floating_group_index) & new_capacity;
 1666|  4.78M|    ABSL_ASSUME(new_index != kProbedElementIndexSentinel);
  ------------------
  |  |  271|  4.78M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1667|  4.78M|    return new_index;
 1668|  4.78M|  }
 1669|   167k|  ABSL_SWISSTABLE_ASSERT(((old_index - h1) & old_capacity) >= Group::kWidth);
  ------------------
  |  |  256|   167k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1670|       |  // Try to insert element into the first probe group.
 1671|       |  // new_ctrl is not yet fully initialized so we can't use regular search via
 1672|       |  // find_first_non_full.
 1673|       |
 1674|       |  // We can search in the first probe group only if it is located in already
 1675|       |  // initialized part of the table.
 1676|   167k|  if (ABSL_PREDICT_FALSE((h1 & old_capacity) >= old_index)) {
  ------------------
  |  |  190|   167k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 32.3k, False: 135k]
  |  |  |  Branch (190:49): [Folded, False: 167k]
  |  |  |  Branch (190:58): [True: 32.3k, False: 135k]
  |  |  ------------------
  ------------------
 1677|  32.3k|    return kProbedElementIndexSentinel;
 1678|  32.3k|  }
 1679|   135k|  size_t offset = h1 & new_capacity;
 1680|   135k|  Group new_g(new_ctrl + offset);
 1681|   135k|  if (auto mask = new_g.MaskNonFull(); ABSL_PREDICT_TRUE(mask)) {
  ------------------
  |  |  191|   135k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 135k, False: 60]
  |  |  |  Branch (191:48): [Folded, False: 135k]
  |  |  |  Branch (191:57): [True: 135k, False: 60]
  |  |  ------------------
  ------------------
 1682|   135k|    size_t result = offset + mask.LowestBitSet();
 1683|   135k|    ABSL_ASSUME(result != kProbedElementIndexSentinel);
  ------------------
  |  |  271|   135k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1684|   135k|    return result;
 1685|   135k|  }
 1686|     60|  return kProbedElementIndexSentinel;
 1687|   135k|}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8hash_refEv:
 3768|  16.9k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE28find_or_prepare_insert_largeIDiEENS5_INS8_8iteratorEbEERKT_:
 3514|  8.58M|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3515|  8.58M|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  8.58M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3516|  8.58M|    prefetch_heap_block();
 3517|  8.58M|    const size_t hash = hash_of(key);
 3518|  8.58M|    auto seq = probe(common(), hash);
 3519|  8.58M|    const h2_t h2 = H2(hash);
 3520|  8.58M|    const ctrl_t* ctrl = control();
 3521|  8.58M|    size_t index;
 3522|  8.58M|    bool inserted;
 3523|       |    // We use a lambda function to be able to exit from the nested loop without
 3524|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3525|  8.58M|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|  8.58M|      while (true) {
 3527|  8.58M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|  8.58M|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|  8.58M|#endif
 3530|  8.58M|        Group g{ctrl + seq.offset()};
 3531|  8.58M|        for (uint32_t i : g.Match(h2)) {
 3532|  8.58M|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3533|  8.58M|            index = seq.offset(i);
 3534|  8.58M|            inserted = false;
 3535|  8.58M|            return;
 3536|  8.58M|          }
 3537|  8.58M|        }
 3538|  8.58M|        auto mask_empty = g.MaskEmpty();
 3539|  8.58M|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3540|  8.58M|          size_t target_group_offset = seq.offset();
 3541|  8.58M|          index = SwisstableGenerationsEnabled()
 3542|  8.58M|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|  8.58M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|  8.58M|                            FindInfo{target_group_offset, seq.index()},
 3545|  8.58M|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|  8.58M|                      : PrepareInsertLarge(
 3547|  8.58M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|  8.58M|                            FindInfo{target_group_offset, seq.index()});
 3549|  8.58M|          inserted = true;
 3550|  8.58M|          return;
 3551|  8.58M|        }
 3552|  8.58M|        seq.next();
 3553|  8.58M|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3554|  8.58M|      }
 3555|  8.58M|    }();
 3556|  8.58M|    return {iterator_at(index), inserted};
 3557|  8.58M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE19prefetch_heap_blockEv:
 3711|  8.58M|  void prefetch_heap_block() const {
 3712|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  8.58M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3713|  8.58M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3714|  8.58M|    __builtin_prefetch(control(), 0, 1);
 3715|  8.58M|#endif
 3716|  8.58M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE7hash_ofIDiEEmRKT_:
 3349|  8.58M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3350|  8.58M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3351|  8.58M|                                               common().seed().seed()}(key);
 3352|  8.58M|  }
_ZN4absl12lts_2026052618container_internal9probe_seqILm16EEC2ENS1_21HashtableCapacityImplILNS1_28HashtableCapacityStorageModeE1EEEm:
 1603|  80.6M|      : capacity_(capacity), offset_(capacity.mask(hash)) {}
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE28find_or_prepare_insert_largeIDiEENS5_INS8_8iteratorEbEERKT_ENKUlvE_clEv:
 3525|  8.58M|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|  8.59M|      while (true) {
  ------------------
  |  Branch (3526:14): [True: 8.59M, Folded]
  ------------------
 3527|  8.59M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|  8.59M|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|  8.59M|#endif
 3530|  8.59M|        Group g{ctrl + seq.offset()};
 3531|  8.59M|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3531:25): [True: 8.47M, False: 297k]
  ------------------
 3532|  8.47M|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  191|  8.47M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 8.29M, False: 175k]
  |  |  |  Branch (191:48): [Folded, False: 8.47M]
  |  |  |  Branch (191:57): [True: 8.29M, False: 175k]
  |  |  ------------------
  ------------------
 3533|  8.29M|            index = seq.offset(i);
 3534|  8.29M|            inserted = false;
 3535|  8.29M|            return;
 3536|  8.29M|          }
 3537|  8.47M|        }
 3538|   297k|        auto mask_empty = g.MaskEmpty();
 3539|   297k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|   297k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 283k, False: 13.5k]
  |  |  |  Branch (191:48): [Folded, False: 297k]
  |  |  |  Branch (191:57): [True: 283k, False: 13.5k]
  |  |  ------------------
  ------------------
 3540|   283k|          size_t target_group_offset = seq.offset();
 3541|   283k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3541:19): [Folded, False: 283k]
  ------------------
 3542|   283k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|      0|                            FindInfo{target_group_offset, seq.index()},
 3545|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   283k|                      : PrepareInsertLarge(
 3547|   283k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   283k|                            FindInfo{target_group_offset, seq.index()});
 3549|   283k|          inserted = true;
 3550|   283k|          return;
 3551|   283k|        }
 3552|  13.5k|        seq.next();
 3553|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  13.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3554|  13.5k|      }
 3555|  8.58M|    }();
_ZNK4absl12lts_2026052618container_internal9probe_seqILm16EE6offsetEv:
 1606|   166M|  size_t offset() const { return offset_; }
_ZNK4absl12lts_2026052618container_internal9probe_seqILm16EE6offsetEm:
 1607|   145M|  size_t offset(size_t i) const { return capacity_.mask(offset_ + i); }
_ZNK4absl12lts_2026052618container_internal9probe_seqILm16EE5indexEv:
 1615|  4.11M|  size_t index() const { return index_; }
_ZN4absl12lts_2026052618container_internal9probe_seqILm16EE4nextEv:
 1609|   518k|  void next() {
 1610|   518k|    index_ += Width;
 1611|   518k|    offset_ += index_;
 1612|   518k|    offset_ = capacity_.mask(offset_);
 1613|   518k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE11iterator_atEm:
 3671|  8.58M|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3672|  8.58M|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3673|  8.58M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKDiEEENSD_IJEEEEEEvNS8_8iteratorEDpOT_:
 3661|   300k|  void emplace_at(iterator iter, Args&&... args) {
 3662|   300k|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|   300k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|   300k|           "constructed value does not match the lookup key");
 3669|   300k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKDiEEENSD_IJEEEEEEvPNS1_13map_slot_typeIDiS6_EEDpOT_:
 3205|   300k|  inline void construct(slot_type* slot, Args&&... args) {
 3206|   300k|    common().RunWithReentrancyGuard([&] {
 3207|   300k|      allocator_type alloc(char_alloc_ref());
 3208|   300k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   300k|    });
 3210|   300k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKDiEEENSF_IJEEEEEEvPNS1_13map_slot_typeIDiS8_EEDpOT_EUlvE_EEvT_:
 1322|   300k|  void RunWithReentrancyGuard(F f) {
 1323|   300k|#ifdef NDEBUG
 1324|   300k|    f();
 1325|   300k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKDiEEENSD_IJEEEEEEvPNS1_13map_slot_typeIDiS6_EEDpOT_ENKUlvE_clEv:
 3206|   300k|    common().RunWithReentrancyGuard([&] {
 3207|   300k|      allocator_type alloc(char_alloc_ref());
 3208|   300k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   300k|    });
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8iterator4slotEv:
 2285|   300k|    slot_type* slot() const { return slot_; }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE5beginEv:
 2582|  8.52k|  const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2583|  8.52k|    return const_cast<raw_hash_set*>(this)->begin();
 2584|  8.52k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE5beginEv:
 2568|  8.52k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2569|  8.52k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  190|  8.52k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 27, False: 8.50k]
  |  |  |  Branch (190:49): [Folded, False: 8.52k]
  |  |  |  Branch (190:58): [True: 27, False: 8.50k]
  |  |  ------------------
  ------------------
 2570|  8.50k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2570:9): [True: 47, False: 8.45k]
  ------------------
 2571|  8.45k|    iterator it = {control(), common().slots_union(),
 2572|  8.45k|                   common().generation_ptr()};
 2573|  8.45k|    it.skip_empty_or_deleted();
 2574|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  256|  8.45k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2575|  8.45k|    return it;
 2576|  8.50k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE3endEv:
 2577|  8.55k|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2578|  8.55k|    AssertNotDebugCapacity();
 2579|  8.55k|    return iterator(common().generation_ptr());
 2580|  8.55k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8iteratorC2EPKh:
 2257|  8.55k|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2248|  8.45k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2249|  8.45k|          ctrl_(ctrl),
 2250|  8.45k|          slot_(to_slot(slot.get())) {
 2251|       |      // This assumption helps the compiler know that any non-end iterator is
 2252|       |      // not equal to any end iterator.
 2253|  8.45k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|  8.45k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2254|  8.45k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8iterator21skip_empty_or_deletedEv:
 2265|   609k|    void skip_empty_or_deleted() {
 2266|   966k|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2266:14): [True: 357k, False: 609k]
  ------------------
 2267|   357k|        ++ctrl_;
 2268|   357k|        ++slot_;
 2269|   357k|      }
 2270|   609k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE14const_iteratorC2ENS8_8iteratorE:
 2312|  17.0k|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE3endEv:
 2585|  8.52k|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2586|  8.52k|    return const_cast<raw_hash_set*>(this)->end();
 2587|  8.52k|  }
_ZN4absl12lts_2026052618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE14const_iteratorESB_:
 2326|   617k|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2327|   617k|      return !(a == b);
 2328|   617k|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE14const_iteratorESB_:
 2323|   617k|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2324|   617k|      return a.inner_ == b.inner_;
 2325|   617k|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8iteratorESB_:
 2222|   617k|    friend bool operator==(const iterator& a, const iterator& b) {
 2223|   617k|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 2224|   617k|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 2225|   617k|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 2226|   617k|                          a.generation_ptr(), b.generation_ptr());
 2227|   617k|      return a.ctrl_ == b.ctrl_;
 2228|   617k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE14const_iteratorppEv:
 2317|   600k|    const_iterator& operator++() {
 2318|   600k|      ++inner_;
 2319|   600k|      return *this;
 2320|   600k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8iteratorppEv:
 2207|   600k|    iterator& operator++() {
 2208|   600k|      assert_is_full("operator++");
 2209|   600k|      ++ctrl_;
 2210|   600k|      ++slot_;
 2211|   600k|      skip_empty_or_deleted();
 2212|   600k|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  190|   600k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 17.0k, False: 583k]
  |  |  |  Branch (190:49): [Folded, False: 600k]
  |  |  |  Branch (190:58): [True: 17.0k, False: 583k]
  |  |  ------------------
  ------------------
 2213|   600k|      return *this;
 2214|   600k|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8iterator14assert_is_fullEPKc:
 2259|   901k|    void assert_is_full(const char* operation) const {
 2260|   901k|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2261|   901k|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE14const_iteratordeEv:
 2314|   300k|    reference operator*() const { return *inner_; }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiNSt3__14pairIblEEEEJEE8iteratordeEv:
 2195|   300k|    reference operator*() const {
 2196|   300k|      assert_is_full("operator*()");
 2197|   300k|      return unchecked_deref();
 2198|   300k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE7emplaceIJRKDiRKlETnNSt3__19enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSB_4pairINS5_8iteratorEbEEDpOSD_:
 2799|   272k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2800|   272k|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2801|   272k|                               std::forward<Args>(args)...);
 2802|   272k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE19EmplaceDecomposableclIDiJRKNSt3__121piecewise_construct_tENS8_5tupleIJRKDiEEENSC_IJRKlEEEEEENS8_4pairINS5_8iteratorEbEERKT_DpOT0_:
 3177|   272k|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 3178|   272k|      auto res = s.find_or_prepare_insert(key);
 3179|   272k|      if (res.second) {
  ------------------
  |  Branch (3179:11): [True: 272k, False: 0]
  ------------------
 3180|   272k|        s.emplace_at(res.first, std::forward<Args>(args)...);
 3181|   272k|      }
 3182|   272k|      return res;
 3183|   272k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE22find_or_prepare_insertIDiEENSt3__14pairINS5_8iteratorEbEERKT_:
 3646|   272k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3647|   272k|    AssertOnFind(key);
 3648|   272k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3648:9): [True: 16.9k, False: 255k]
  ------------------
 3649|   255k|    return find_or_prepare_insert_large(key);
 3650|   272k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE12AssertOnFindIDiEEvRKT_:
 3567|  10.4M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3568|  10.4M|    AssertHashEqConsistent(key);
 3569|  10.4M|    AssertNotDebugCapacity();
 3570|  10.4M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE22AssertHashEqConsistentIDiEEvRKT_:
 3605|  10.4M|  void AssertHashEqConsistent(const K& key) {
 3606|  10.4M|#ifdef NDEBUG
 3607|  10.4M|    return;
 3608|      0|#endif
 3609|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3610|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3610:9): [Folded, False: 0]
  ------------------
 3611|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3611:9): [Folded, False: 0]
  ------------------
 3612|      0|      return;
 3613|      0|    }
 3614|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3614:9): [True: 0, Folded]
  ------------------
 3615|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3615:9): [True: 0, Folded]
  ------------------
 3616|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3616:9): [True: 0, Folded]
  ------------------
 3617|      0|      return;
 3618|      0|    }
 3619|      0|    if (empty()) return;
  ------------------
  |  Branch (3619:9): [True: 0, False: 0]
  ------------------
 3620|       |
 3621|      0|    const size_t hash_of_arg = hash_of(key);
 3622|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3623|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3624|      0|      if (!is_key_equal) return;
 3625|       |
 3626|      0|      [[maybe_unused]] const bool is_hash_equal =
 3627|      0|          hash_of_arg == hash_of(to_slot(slot));
 3628|      0|      assert((!is_key_equal || is_hash_equal) &&
 3629|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3630|      0|             "hash/eq functors are inconsistent.");
 3631|      0|    };
 3632|       |
 3633|      0|    if (is_small()) {
  ------------------
  |  Branch (3633:9): [True: 0, False: 0]
  ------------------
 3634|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3635|      0|      return;
 3636|      0|    }
 3637|       |    // We only do validation for small tables so that it's constant time.
 3638|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3638:9): [True: 0, False: 0]
  ------------------
 3639|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3640|      0|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE22AssertNotDebugCapacityEv:
 3573|  21.1M|  void AssertNotDebugCapacity() const {
 3574|  21.1M|#ifdef NDEBUG
 3575|  21.1M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3575:9): [True: 21.1M, Folded]
  ------------------
 3576|  21.1M|      return;
 3577|  21.1M|    }
 3578|      0|#endif
 3579|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 3580|      0|    if (ABSL_PREDICT_TRUE(cap.IsValid())) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3581|      0|      return;
 3582|      0|    }
 3583|      0|    assert(!cap.IsReentrance() &&
 3584|      0|           "Reentrant container access during element construction/destruction "
 3585|      0|           "is not allowed.");
 3586|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3587|       |      if (cap.IsDestroyed()) {
 3588|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3589|       |      }
 3590|       |    }
 3591|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3591:9): [Folded, False: 0]
  ------------------
 3592|      0|        ABSL_PREDICT_FALSE(cap.IsMovedFrom())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3593|      0|      if (cap.IsSelfMovedFrom()) {
  ------------------
  |  Branch (3593:11): [True: 0, False: 0]
  ------------------
 3594|       |        // If this log triggers, then a hash table was move-assigned to itself
 3595|       |        // and then used again later without being reinitialized.
 3596|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3597|      0|      }
 3598|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3599|      0|    }
 3600|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE28find_or_prepare_insert_smallIDiEENSt3__14pairINS5_8iteratorEbEERKT_:
 3497|  16.9k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3498|  16.9k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  16.9k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3499|  16.9k|    if constexpr (SooEnabled()) {
 3500|  16.9k|      return find_or_prepare_insert_soo(key);
 3501|  16.9k|    }
 3502|  16.9k|    if (!empty()) {
  ------------------
  |  Branch (3502:9): [True: 0, False: 16.9k]
  ------------------
 3503|      0|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3503:11): [True: 0, False: 0]
  ------------------
 3504|      0|        return {single_iterator(), false};
 3505|      0|      }
 3506|      0|    }
 3507|  16.9k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3508|  16.9k|                common(), GetPolicyFunctions(),
 3509|  16.9k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3510|  16.9k|            true};
 3511|  16.9k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE26find_or_prepare_insert_sooIDiEENSt3__14pairINS5_8iteratorEbEERKT_:
 3471|  16.9k|  std::pair<iterator, bool> find_or_prepare_insert_soo(const K& key) {
 3472|  16.9k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  256|  16.9k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3473|  16.9k|    bool force_sampling;
 3474|  16.9k|    if (empty()) {
  ------------------
  |  Branch (3474:9): [True: 8.50k, False: 8.41k]
  ------------------
 3475|  8.50k|      if (!should_sample_soo()) {
  ------------------
  |  Branch (3475:11): [True: 8.50k, False: 0]
  ------------------
 3476|  8.50k|        common().set_full_soo();
 3477|  8.50k|        return {single_iterator(), true};
 3478|  8.50k|      }
 3479|      0|      force_sampling = true;
 3480|  8.41k|    } else if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3480:16): [True: 0, False: 8.41k]
  ------------------
 3481|      0|      return {single_iterator(), false};
 3482|  8.41k|    } else {
 3483|  8.41k|      force_sampling = false;
 3484|  8.41k|    }
 3485|  8.41k|    ABSL_SWISSTABLE_ASSERT(capacity() == 1);
  ------------------
  |  |  256|  8.41k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3486|  8.41k|    constexpr bool kUseMemcpy =
 3487|  8.41k|        PolicyTraits::transfer_uses_memcpy() && SooEnabled();
  ------------------
  |  Branch (3487:9): [True: 0, Folded]
  |  Branch (3487:49): [True: 0, Folded]
  ------------------
 3488|  8.41k|    size_t index = GrowSooTableToNextCapacityAndPrepareInsert<
 3489|  8.41k|        kUseMemcpy ? OptimalMemcpySizeForSooSlotTransfer(sizeof(slot_type)) : 0,
 3490|  8.41k|        kUseMemcpy>(common(), GetPolicyFunctions(),
 3491|  8.41k|                    HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key},
 3492|  8.41k|                    force_sampling);
 3493|  8.41k|    return {iterator_at(index), true};
 3494|  16.9k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE17should_sample_sooEv:
 3259|  8.50k|  bool should_sample_soo() {
 3260|  8.50k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  256|  8.50k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3261|       |    if constexpr (!ShouldSampleHashtablezInfoForAlloc<CharAlloc>()) {
 3262|       |      return false;
 3263|       |    }
 3264|  8.50k|    if (common().soo_has_tried_sampling()) {
  ------------------
  |  Branch (3264:9): [True: 0, False: 8.50k]
  ------------------
 3265|       |      // Already evaluated sampling on this SOO table; do not re-evaluate
 3266|       |      // sampling each time it transitions from empty to full SOO state.
 3267|      0|      return false;
 3268|      0|    }
 3269|       |    // TODO: b/396049910 -- consider managing this flag on the 1->0 size
 3270|       |    // transition of SOO tables rather than the 0->1 transition.
 3271|  8.50k|    common().set_soo_has_tried_sampling();
 3272|  8.50k|    return ABSL_PREDICT_FALSE(ShouldSampleNextTable());
  ------------------
  |  |  190|  8.50k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:49): [Folded, False: 8.50k]
  |  |  |  Branch (190:58): [True: 0, False: 8.50k]
  |  |  ------------------
  ------------------
 3273|  8.50k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE15single_iteratorEv:
 3757|  34.7k|  iterator single_iterator() {
 3758|  34.7k|    return {SooControl(), single_slot(), common().generation_ptr()};
 3759|  34.7k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIDilEEPKh:
 2236|  9.89M|        : HashSetIteratorGenerationInfo(generation_ptr),
 2237|  9.89M|          ctrl_(ctrl),
 2238|  9.89M|          slot_(slot) {
 2239|       |      // This assumption helps the compiler know that any non-end iterator is
 2240|       |      // not equal to any end iterator.
 2241|  9.89M|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|  9.89M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2242|  9.89M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8equal_toIDiEEbRKT_PNS1_13map_slot_typeIDilEE:
 3344|  9.84M|                                             slot_type* slot) const {
 3345|  9.84M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3346|  9.84M|                               PolicyTraits::element(slot));
 3347|  9.84M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE6eq_refEv:
 3771|  9.84M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE18GetPolicyFunctionsEv:
 3851|   263k|  static const PolicyFunctions& GetPolicyFunctions() {
 3852|   263k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3853|   263k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3854|   263k|                  "or use absl::node_hash_{map,set}.");
 3855|   263k|    static_assert(alignof(slot_type) <=
 3856|   263k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3857|   263k|    static_assert(sizeof(key_type) <=
 3858|   263k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3859|   263k|    static_assert(sizeof(value_type) <=
 3860|   263k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3861|   263k|    static constexpr size_t kBackingArrayAlignment =
 3862|   263k|        BackingArrayAlignment(alignof(slot_type));
 3863|   263k|    static constexpr PolicyFunctions value = {
 3864|   263k|        static_cast<uint32_t>(sizeof(key_type)),
 3865|   263k|        static_cast<uint32_t>(sizeof(value_type)),
 3866|   263k|        static_cast<uint32_t>(sizeof(slot_type)),
 3867|   263k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3868|   263k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3869|       |        // TODO(b/328722020): try to type erase
 3870|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3871|   263k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3871:9): [True: 0, Folded]
  ------------------
 3872|   263k|                                : &raw_hash_set::get_hash_ref_fn,
 3873|   263k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3874|   263k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3874:9): [True: 0, Folded]
  ------------------
 3875|   263k|            ? TransferNRelocatable<sizeof(slot_type)>
 3876|   263k|            : &raw_hash_set::transfer_n_slots_fn,
 3877|   263k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3877:9): [True: 0, Folded]
  ------------------
 3878|   263k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3879|   263k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3880|   263k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3881|   263k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3882|   263k|    return value;
 3883|   263k|  }
_ZN4absl12lts_2026052618container_internal20TransferNRelocatableILm16EEEvPvS3_S3_m:
 1955|  21.3k|                                                  size_t count) {
 1956|       |  // TODO(b/382423690): Experiment with making specialization for power of 2 and
 1957|       |  // non power of 2. This would require passing the size of the slot.
 1958|  21.3k|  memcpy(dst, src, SizeOfSlot * count);
 1959|  21.3k|}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSB_PFvSB_hmmE:
 3804|  10.1k|                                    size_t source_offset, size_t h1)) {
 3805|  10.1k|    const size_t new_capacity = common.capacity();
 3806|  10.1k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3807|  10.1k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  271|  10.1k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3808|  10.1k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  271|  10.1k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3809|       |
 3810|  10.1k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3811|  10.1k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3812|  10.1k|    ctrl_t* new_ctrl = common.control();
 3813|  10.1k|    slot_type* new_slots = set->slot_array();
 3814|       |
 3815|  30.4k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3815:34): [True: 20.3k, False: 10.1k]
  ------------------
 3816|  20.3k|         group_index += Group::kWidth) {
 3817|  20.3k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3818|  20.3k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3819|  20.3k|                  Group::kWidth);
 3820|  20.3k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3821|  20.3k|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3822|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3823|       |      // We will share a lot of code in expense of one function call per group.
 3824|   284k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3824:38): [True: 284k, False: 20.3k]
  ------------------
 3825|   284k|        size_t old_index = group_index + in_fixed_group_index;
 3826|   284k|        slot_type* old_slot = old_slots_ptr + old_index;
 3827|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3828|       |        // only one new bit of h1.
 3829|   284k|        size_t hash = set->hash_of(old_slot);
 3830|   284k|        size_t h1 = H1(hash);
 3831|   284k|        h2_t h2 = H2(hash);
 3832|   284k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3833|   284k|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3834|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3835|       |        // till and included the old_index.
 3836|   284k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  190|   284k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2.45k, False: 282k]
  |  |  |  Branch (190:49): [Folded, False: 284k]
  |  |  |  Branch (190:58): [True: 2.45k, False: 282k]
  |  |  ------------------
  ------------------
 3837|  2.45k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3838|  2.45k|          continue;
 3839|  2.45k|        }
 3840|   282k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  256|   282k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3841|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  256|   282k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3842|   282k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3843|   282k|        auto* new_slot = new_slots + new_index;
 3844|   282k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3845|   282k|        set->transfer(new_slot, old_slot);
 3846|   282k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3847|   282k|      }
 3848|  20.3k|    }
 3849|  10.1k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE7to_slotEPv:
 3361|  17.7k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3362|  17.7k|    return static_cast<slot_type*>(buf);
 3363|  17.7k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE7hash_ofEPNS1_13map_slot_typeIDilEE:
 3353|   284k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3354|   284k|    return PolicyTraits::apply(
 3355|   284k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3356|   284k|        PolicyTraits::element(slot));
 3357|   284k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8hash_refEv:
 3769|  10.6M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8transferEPNS1_13map_slot_typeIDilEES8_:
 3217|   282k|  inline void transfer(slot_type* to, slot_type* from) {
 3218|   282k|    common().RunWithReentrancyGuard([&] {
 3219|   282k|      allocator_type alloc(char_alloc_ref());
 3220|   282k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   282k|    });
 3222|   282k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8transferEPNS1_13map_slot_typeIDilEESA_EUlvE_EEvT_:
 1322|   282k|  void RunWithReentrancyGuard(F f) {
 1323|   282k|#ifdef NDEBUG
 1324|   282k|    f();
 1325|   282k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8transferEPNS1_13map_slot_typeIDilEES8_ENKUlvE_clEv:
 3218|   282k|    common().RunWithReentrancyGuard([&] {
 3219|   282k|      allocator_type alloc(char_alloc_ref());
 3220|   282k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   282k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8hash_refEv:
 3768|  8.41k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE11iterator_atEm:
 3671|  9.85M|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3672|  9.85M|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3673|  9.85M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE28find_or_prepare_insert_largeIDiEENSt3__14pairINS5_8iteratorEbEERKT_:
 3514|   255k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3515|   255k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   255k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3516|   255k|    prefetch_heap_block();
 3517|   255k|    const size_t hash = hash_of(key);
 3518|   255k|    auto seq = probe(common(), hash);
 3519|   255k|    const h2_t h2 = H2(hash);
 3520|   255k|    const ctrl_t* ctrl = control();
 3521|   255k|    size_t index;
 3522|   255k|    bool inserted;
 3523|       |    // We use a lambda function to be able to exit from the nested loop without
 3524|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3525|   255k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   255k|      while (true) {
 3527|   255k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   255k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   255k|#endif
 3530|   255k|        Group g{ctrl + seq.offset()};
 3531|   255k|        for (uint32_t i : g.Match(h2)) {
 3532|   255k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3533|   255k|            index = seq.offset(i);
 3534|   255k|            inserted = false;
 3535|   255k|            return;
 3536|   255k|          }
 3537|   255k|        }
 3538|   255k|        auto mask_empty = g.MaskEmpty();
 3539|   255k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3540|   255k|          size_t target_group_offset = seq.offset();
 3541|   255k|          index = SwisstableGenerationsEnabled()
 3542|   255k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|   255k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|   255k|                            FindInfo{target_group_offset, seq.index()},
 3545|   255k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   255k|                      : PrepareInsertLarge(
 3547|   255k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   255k|                            FindInfo{target_group_offset, seq.index()});
 3549|   255k|          inserted = true;
 3550|   255k|          return;
 3551|   255k|        }
 3552|   255k|        seq.next();
 3553|   255k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3554|   255k|      }
 3555|   255k|    }();
 3556|   255k|    return {iterator_at(index), inserted};
 3557|   255k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE19prefetch_heap_blockEv:
 3711|  10.3M|  void prefetch_heap_block() const {
 3712|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  10.3M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3713|  10.3M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3714|  10.3M|    __builtin_prefetch(control(), 0, 1);
 3715|  10.3M|#endif
 3716|  10.3M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE7hash_ofIDiEEmRKT_:
 3349|  10.3M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3350|  10.3M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3351|  10.3M|                                               common().seed().seed()}(key);
 3352|  10.3M|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE28find_or_prepare_insert_largeIDiEENSt3__14pairINS5_8iteratorEbEERKT_ENKUlvE_clEv:
 3525|   255k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   262k|      while (true) {
  ------------------
  |  Branch (3526:14): [True: 262k, Folded]
  ------------------
 3527|   262k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   262k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   262k|#endif
 3530|   262k|        Group g{ctrl + seq.offset()};
 3531|   262k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3531:25): [True: 12.0k, False: 262k]
  ------------------
 3532|  12.0k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  191|  12.0k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 12.0k]
  |  |  |  Branch (191:48): [Folded, False: 12.0k]
  |  |  |  Branch (191:57): [True: 0, False: 12.0k]
  |  |  ------------------
  ------------------
 3533|      0|            index = seq.offset(i);
 3534|      0|            inserted = false;
 3535|      0|            return;
 3536|      0|          }
 3537|  12.0k|        }
 3538|   262k|        auto mask_empty = g.MaskEmpty();
 3539|   262k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|   262k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 255k, False: 7.34k]
  |  |  |  Branch (191:48): [Folded, False: 262k]
  |  |  |  Branch (191:57): [True: 255k, False: 7.34k]
  |  |  ------------------
  ------------------
 3540|   255k|          size_t target_group_offset = seq.offset();
 3541|   255k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3541:19): [Folded, False: 255k]
  ------------------
 3542|   255k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|      0|                            FindInfo{target_group_offset, seq.index()},
 3545|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   255k|                      : PrepareInsertLarge(
 3547|   255k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   255k|                            FindInfo{target_group_offset, seq.index()});
 3549|   255k|          inserted = true;
 3550|   255k|          return;
 3551|   255k|        }
 3552|  7.34k|        seq.next();
 3553|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  7.34k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3554|  7.34k|      }
 3555|   255k|    }();
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE10emplace_atIJRKNSt3__121piecewise_construct_tENS7_5tupleIJRKDiEEENSB_IJRKlEEEEEEvNS5_8iteratorEDpOT_:
 3661|   272k|  void emplace_at(iterator iter, Args&&... args) {
 3662|   272k|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|   272k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|   272k|           "constructed value does not match the lookup key");
 3669|   272k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE9constructIJRKNSt3__121piecewise_construct_tENS7_5tupleIJRKDiEEENSB_IJRKlEEEEEEvPNS1_13map_slot_typeIDilEEDpOT_:
 3205|   272k|  inline void construct(slot_type* slot, Args&&... args) {
 3206|   272k|    common().RunWithReentrancyGuard([&] {
 3207|   272k|      allocator_type alloc(char_alloc_ref());
 3208|   272k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   272k|    });
 3210|   272k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE9constructIJRKNSt3__121piecewise_construct_tENS9_5tupleIJRKDiEEENSD_IJRKlEEEEEEvPNS1_13map_slot_typeIDilEEDpOT_EUlvE_EEvT_:
 1322|   272k|  void RunWithReentrancyGuard(F f) {
 1323|   272k|#ifdef NDEBUG
 1324|   272k|    f();
 1325|   272k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE9constructIJRKNSt3__121piecewise_construct_tENS7_5tupleIJRKDiEEENSB_IJRKlEEEEEEvPNS1_13map_slot_typeIDilEEDpOT_ENKUlvE_clEv:
 3206|   272k|    common().RunWithReentrancyGuard([&] {
 3207|   272k|      allocator_type alloc(char_alloc_ref());
 3208|   272k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   272k|    });
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iterator4slotEv:
 2285|   272k|    slot_type* slot() const { return slot_; }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE4sizeEv:
 2594|  94.2k|  size_t size() const {
 2595|  94.2k|    AssertNotDebugCapacity();
 2596|  94.2k|    const size_t size = common().size();
 2597|  94.2k|    [[maybe_unused]] const size_t kMaxValidSize = MaxValidSize();
 2598|  94.2k|    ABSL_ASSUME(size <= kMaxValidSize);
  ------------------
  |  |  271|  94.2k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2599|  94.2k|    return size;
 2600|  94.2k|  }
_ZN4absl12lts_2026052618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE14const_iteratorES8_:
 2326|  10.6M|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2327|  10.6M|      return !(a == b);
 2328|  10.6M|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE14const_iteratorES8_:
 2323|  10.6M|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2324|  10.6M|      return a.inner_ == b.inner_;
 2325|  10.6M|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iteratorES8_:
 2222|  10.6M|    friend bool operator==(const iterator& a, const iterator& b) {
 2223|  10.6M|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 2224|  10.6M|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 2225|  10.6M|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 2226|  10.6M|                          a.generation_ptr(), b.generation_ptr());
 2227|  10.6M|      return a.ctrl_ == b.ctrl_;
 2228|  10.6M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE4findIDiEENS5_14const_iteratorERKDi:
 3079|  10.1M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3080|  10.1M|    return const_cast<raw_hash_set*>(this)->find(key);
 3081|  10.1M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE4findIDiEENS5_8iteratorERKDi:
 3064|  10.1M|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3065|  10.1M|    AssertOnFind(key);
 3066|  10.1M|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (3066:9): [True: 31.8k, False: 10.1M]
  ------------------
 3067|  10.1M|    prefetch_heap_block();
 3068|  10.1M|    return find_large(key, hash_of(key));
 3069|  10.1M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE10find_smallIDiEENS5_8iteratorERKDi:
 3227|  31.8k|  iterator find_small(const key_arg<K>& key) {
 3228|  31.8k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  31.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3229|  31.8k|    return empty() || !equal_to(key, single_slot()) ? end() : single_iterator();
  ------------------
  |  Branch (3229:12): [True: 27, False: 31.8k]
  |  Branch (3229:23): [True: 5.70k, False: 26.1k]
  ------------------
 3230|  31.8k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE3endEv:
 2577|  10.6M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2578|  10.6M|    AssertNotDebugCapacity();
 2579|  10.6M|    return iterator(common().generation_ptr());
 2580|  10.6M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iteratorC2EPKh:
 2257|  10.6M|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE10find_largeIDiEENS5_8iteratorERKDim:
 3233|  10.1M|  iterator find_large(const key_arg<K>& key, size_t hash) {
 3234|  10.1M|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|  10.1M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3235|  10.1M|    auto seq = probe(common(), hash);
 3236|  10.1M|    const h2_t h2 = H2(hash);
 3237|  10.1M|    const ctrl_t* ctrl = control();
 3238|  10.1M|    while (true) {
  ------------------
  |  Branch (3238:12): [True: 10.1M, Folded]
  ------------------
 3239|  10.1M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3240|  10.1M|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3241|  10.1M|#endif
 3242|  10.1M|      Group g{ctrl + seq.offset()};
 3243|  10.1M|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3243:23): [True: 9.78M, False: 533k]
  ------------------
 3244|  9.78M|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  191|  9.78M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 9.59M, False: 194k]
  |  |  |  Branch (191:48): [Folded, False: 9.78M]
  |  |  |  Branch (191:57): [True: 9.59M, False: 194k]
  |  |  ------------------
  ------------------
 3245|  9.59M|          return iterator_at(seq.offset(i));
 3246|  9.78M|      }
 3247|   533k|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  191|   533k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 517k, False: 16.2k]
  |  |  |  Branch (191:48): [Folded, False: 533k]
  |  |  |  Branch (191:57): [True: 517k, False: 16.2k]
  |  |  ------------------
  ------------------
 3248|  16.2k|      seq.next();
 3249|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  16.2k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3250|  16.2k|    }
 3251|  10.1M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE14const_iteratorC2ENS5_8iteratorE:
 2312|  20.3M|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE3endEv:
 2585|  10.1M|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2586|  10.1M|    return const_cast<raw_hash_set*>(this)->end();
 2587|  10.1M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEEC2Ev:
 2352|  18.0k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE15unchecked_derefENSC_8iteratorE:
 3682|  13.0M|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iterator15unchecked_derefEv:
 2282|  15.1M|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE22find_or_prepare_insertINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3646|   295k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3647|   295k|    AssertOnFind(key);
 3648|   295k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3648:9): [True: 11.3k, False: 283k]
  ------------------
 3649|   283k|    return find_or_prepare_insert_large(key);
 3650|   295k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE12AssertOnFindINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3567|   295k|  void AssertOnFind([[maybe_unused]] const K& key) {
 3568|   295k|    AssertHashEqConsistent(key);
 3569|   295k|    AssertNotDebugCapacity();
 3570|   295k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE22AssertHashEqConsistentINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3605|   295k|  void AssertHashEqConsistent(const K& key) {
 3606|   295k|#ifdef NDEBUG
 3607|   295k|    return;
 3608|      0|#endif
 3609|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3610|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3610:9): [True: 0, Folded]
  ------------------
 3611|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3611:9): [True: 0, Folded]
  ------------------
 3612|      0|      return;
 3613|      0|    }
 3614|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3614:9): [Folded, False: 0]
  ------------------
 3615|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3615:9): [Folded, False: 0]
  ------------------
 3616|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3616:9): [Folded, False: 0]
  ------------------
 3617|      0|      return;
 3618|      0|    }
 3619|      0|    if (empty()) return;
  ------------------
  |  Branch (3619:9): [True: 0, False: 0]
  ------------------
 3620|       |
 3621|      0|    const size_t hash_of_arg = hash_of(key);
 3622|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3623|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3624|      0|      if (!is_key_equal) return;
 3625|       |
 3626|      0|      [[maybe_unused]] const bool is_hash_equal =
 3627|      0|          hash_of_arg == hash_of(to_slot(slot));
 3628|      0|      assert((!is_key_equal || is_hash_equal) &&
 3629|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3630|      0|             "hash/eq functors are inconsistent.");
 3631|      0|    };
 3632|       |
 3633|      0|    if (is_small()) {
  ------------------
  |  Branch (3633:9): [True: 0, False: 0]
  ------------------
 3634|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3635|      0|      return;
 3636|      0|    }
 3637|       |    // We only do validation for small tables so that it's constant time.
 3638|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3638:9): [True: 0, False: 0]
  ------------------
 3639|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3640|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_smallINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3497|  11.3k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3498|  11.3k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  11.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3499|       |    if constexpr (SooEnabled()) {
 3500|       |      return find_or_prepare_insert_soo(key);
 3501|       |    }
 3502|  11.3k|    if (!empty()) {
  ------------------
  |  Branch (3502:9): [True: 5.06k, False: 6.33k]
  ------------------
 3503|  5.06k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3503:11): [True: 443, False: 4.61k]
  ------------------
 3504|    443|        return {single_iterator(), false};
 3505|    443|      }
 3506|  5.06k|    }
 3507|  10.9k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3508|  10.9k|                common(), GetPolicyFunctions(),
 3509|  10.9k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3510|  10.9k|            true};
 3511|  11.3k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8equal_toINS4_17basic_string_viewIcS7_EEEEbRKT_PNS1_13map_slot_typeISA_lEE:
 3344|   122k|                                             slot_type* slot) const {
 3345|   122k|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3346|   122k|                               PolicyTraits::element(slot));
 3347|   122k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE6eq_refEv:
 3771|  11.4M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE15single_iteratorEv:
 3757|  15.8k|  iterator single_iterator() {
 3758|  15.8k|    return {SooControl(), single_slot(), common().generation_ptr()};
 3759|  15.8k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeISA_lEEPKh:
 2236|  13.0M|        : HashSetIteratorGenerationInfo(generation_ptr),
 2237|  13.0M|          ctrl_(ctrl),
 2238|  13.0M|          slot_(slot) {
 2239|       |      // This assumption helps the compiler know that any non-end iterator is
 2240|       |      // not equal to any end iterator.
 2241|  13.0M|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|  13.0M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2242|  13.0M|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3678|  32.8k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3679|  32.8k|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3680|  32.8k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7to_slotEPv:
 3361|   186k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3362|   186k|    return static_cast<slot_type*>(buf);
 3363|   186k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE18GetPolicyFunctionsEv:
 3851|  2.14M|  static const PolicyFunctions& GetPolicyFunctions() {
 3852|  2.14M|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3853|  2.14M|                  "Slot size is too large. Use std::unique_ptr for value type "
 3854|  2.14M|                  "or use absl::node_hash_{map,set}.");
 3855|  2.14M|    static_assert(alignof(slot_type) <=
 3856|  2.14M|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3857|  2.14M|    static_assert(sizeof(key_type) <=
 3858|  2.14M|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3859|  2.14M|    static_assert(sizeof(value_type) <=
 3860|  2.14M|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3861|  2.14M|    static constexpr size_t kBackingArrayAlignment =
 3862|  2.14M|        BackingArrayAlignment(alignof(slot_type));
 3863|  2.14M|    static constexpr PolicyFunctions value = {
 3864|  2.14M|        static_cast<uint32_t>(sizeof(key_type)),
 3865|  2.14M|        static_cast<uint32_t>(sizeof(value_type)),
 3866|  2.14M|        static_cast<uint32_t>(sizeof(slot_type)),
 3867|  2.14M|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3868|  2.14M|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3869|       |        // TODO(b/328722020): try to type erase
 3870|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3871|  2.14M|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3871:9): [True: 0, Folded]
  ------------------
 3872|  2.14M|                                : &raw_hash_set::get_hash_ref_fn,
 3873|  2.14M|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3874|  2.14M|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3874:9): [Folded, False: 2.14M]
  ------------------
 3875|  2.14M|            ? TransferNRelocatable<sizeof(slot_type)>
 3876|  2.14M|            : &raw_hash_set::transfer_n_slots_fn,
 3877|  2.14M|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3877:9): [True: 0, Folded]
  ------------------
 3878|  2.14M|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3879|  2.14M|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3880|  2.14M|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3881|  2.14M|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3882|  2.14M|    return value;
 3883|  2.14M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE19transfer_n_slots_fnEPvSD_SD_m:
 3787|  55.7k|                                  size_t count) {
 3788|  55.7k|    auto* src_slot = to_slot(src);
 3789|  55.7k|    auto* dst_slot = to_slot(dst);
 3790|       |
 3791|  55.7k|    auto* h = static_cast<raw_hash_set*>(set);
 3792|   204k|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3792:12): [True: 148k, False: 55.7k]
  ------------------
 3793|   148k|      h->transfer(dst_slot, src_slot);
 3794|   148k|    }
 3795|  55.7k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8transferEPNS1_13map_slot_typeISA_lEESF_:
 3217|  3.04M|  inline void transfer(slot_type* to, slot_type* from) {
 3218|  3.04M|    common().RunWithReentrancyGuard([&] {
 3219|  3.04M|      allocator_type alloc(char_alloc_ref());
 3220|  3.04M|      PolicyTraits::transfer(&alloc, to, from);
 3221|  3.04M|    });
 3222|  3.04M|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE8transferEPNS1_13map_slot_typeISC_lEESH_EUlvE_EEvT_:
 1322|  3.04M|  void RunWithReentrancyGuard(F f) {
 1323|  3.04M|#ifdef NDEBUG
 1324|  3.04M|    f();
 1325|  3.04M|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8transferEPNS1_13map_slot_typeISA_lEESF_ENKUlvE_clEv:
 3218|  3.04M|    common().RunWithReentrancyGuard([&] {
 3219|  3.04M|      allocator_type alloc(char_alloc_ref());
 3220|  3.04M|      PolicyTraits::transfer(&alloc, to, from);
 3221|  3.04M|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3804|  26.3k|                                    size_t source_offset, size_t h1)) {
 3805|  26.3k|    const size_t new_capacity = common.capacity();
 3806|  26.3k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3807|  26.3k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  271|  26.3k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3808|  26.3k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  271|  26.3k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3809|       |
 3810|  26.3k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3811|  26.3k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3812|  26.3k|    ctrl_t* new_ctrl = common.control();
 3813|  26.3k|    slot_type* new_slots = set->slot_array();
 3814|       |
 3815|   234k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3815:34): [True: 207k, False: 26.3k]
  ------------------
 3816|   207k|         group_index += Group::kWidth) {
 3817|   207k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3818|   207k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3819|   207k|                  Group::kWidth);
 3820|   207k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3821|   207k|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3822|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3823|       |      // We will share a lot of code in expense of one function call per group.
 3824|  2.90M|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3824:38): [True: 2.90M, False: 207k]
  ------------------
 3825|  2.90M|        size_t old_index = group_index + in_fixed_group_index;
 3826|  2.90M|        slot_type* old_slot = old_slots_ptr + old_index;
 3827|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3828|       |        // only one new bit of h1.
 3829|  2.90M|        size_t hash = set->hash_of(old_slot);
 3830|  2.90M|        size_t h1 = H1(hash);
 3831|  2.90M|        h2_t h2 = H2(hash);
 3832|  2.90M|        size_t new_index = TryFindNewIndexWithoutProbing(
 3833|  2.90M|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3834|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3835|       |        // till and included the old_index.
 3836|  2.90M|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  190|  2.90M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 15.8k, False: 2.89M]
  |  |  |  Branch (190:49): [Folded, False: 2.90M]
  |  |  |  Branch (190:58): [True: 15.8k, False: 2.89M]
  |  |  ------------------
  ------------------
 3837|  15.8k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3838|  15.8k|          continue;
 3839|  15.8k|        }
 3840|  2.89M|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  256|  2.89M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3841|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  256|  2.89M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3842|  2.89M|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3843|  2.89M|        auto* new_slot = new_slots + new_index;
 3844|  2.89M|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3845|  2.89M|        set->transfer(new_slot, old_slot);
 3846|  2.89M|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3847|  2.89M|      }
 3848|   207k|    }
 3849|  26.3k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7hash_ofEPNS1_13map_slot_typeISA_lEE:
 3353|  2.90M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3354|  2.90M|    return PolicyTraits::apply(
 3355|  2.90M|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3356|  2.90M|        PolicyTraits::element(slot));
 3357|  2.90M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8hash_refEv:
 3769|  17.6M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8hash_refEv:
 3768|  32.8k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_largeINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3514|   283k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3515|   283k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   283k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3516|   283k|    prefetch_heap_block();
 3517|   283k|    const size_t hash = hash_of(key);
 3518|   283k|    auto seq = probe(common(), hash);
 3519|   283k|    const h2_t h2 = H2(hash);
 3520|   283k|    const ctrl_t* ctrl = control();
 3521|   283k|    size_t index;
 3522|   283k|    bool inserted;
 3523|       |    // We use a lambda function to be able to exit from the nested loop without
 3524|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3525|   283k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   283k|      while (true) {
 3527|   283k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   283k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   283k|#endif
 3530|   283k|        Group g{ctrl + seq.offset()};
 3531|   283k|        for (uint32_t i : g.Match(h2)) {
 3532|   283k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3533|   283k|            index = seq.offset(i);
 3534|   283k|            inserted = false;
 3535|   283k|            return;
 3536|   283k|          }
 3537|   283k|        }
 3538|   283k|        auto mask_empty = g.MaskEmpty();
 3539|   283k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3540|   283k|          size_t target_group_offset = seq.offset();
 3541|   283k|          index = SwisstableGenerationsEnabled()
 3542|   283k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|   283k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|   283k|                            FindInfo{target_group_offset, seq.index()},
 3545|   283k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   283k|                      : PrepareInsertLarge(
 3547|   283k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   283k|                            FindInfo{target_group_offset, seq.index()});
 3549|   283k|          inserted = true;
 3550|   283k|          return;
 3551|   283k|        }
 3552|   283k|        seq.next();
 3553|   283k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3554|   283k|      }
 3555|   283k|    }();
 3556|   283k|    return {iterator_at(index), inserted};
 3557|   283k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE19prefetch_heap_blockEv:
 3711|  14.7M|  void prefetch_heap_block() const {
 3712|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  14.7M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3713|  14.7M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3714|  14.7M|    __builtin_prefetch(control(), 0, 1);
 3715|  14.7M|#endif
 3716|  14.7M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7hash_ofINS4_17basic_string_viewIcS7_EEEEmRKT_:
 3349|   283k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3350|   283k|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3351|   283k|                                               common().seed().seed()}(key);
 3352|   283k|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_largeINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3525|   283k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   297k|      while (true) {
  ------------------
  |  Branch (3526:14): [True: 297k, Folded]
  ------------------
 3527|   297k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   297k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   297k|#endif
 3530|   297k|        Group g{ctrl + seq.offset()};
 3531|   297k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3531:25): [True: 117k, False: 195k]
  ------------------
 3532|   117k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  191|   117k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 101k, False: 16.6k]
  |  |  |  Branch (191:48): [Folded, False: 117k]
  |  |  |  Branch (191:57): [True: 101k, False: 16.6k]
  |  |  ------------------
  ------------------
 3533|   101k|            index = seq.offset(i);
 3534|   101k|            inserted = false;
 3535|   101k|            return;
 3536|   101k|          }
 3537|   117k|        }
 3538|   195k|        auto mask_empty = g.MaskEmpty();
 3539|   195k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|   195k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 182k, False: 13.1k]
  |  |  |  Branch (191:48): [Folded, False: 195k]
  |  |  |  Branch (191:57): [True: 182k, False: 13.1k]
  |  |  ------------------
  ------------------
 3540|   182k|          size_t target_group_offset = seq.offset();
 3541|   182k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3541:19): [Folded, False: 182k]
  ------------------
 3542|   182k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|      0|                            FindInfo{target_group_offset, seq.index()},
 3545|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   182k|                      : PrepareInsertLarge(
 3547|   182k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   182k|                            FindInfo{target_group_offset, seq.index()});
 3549|   182k|          inserted = true;
 3550|   182k|          return;
 3551|   182k|        }
 3552|  13.1k|        seq.next();
 3553|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  13.1k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3554|  13.1k|      }
 3555|   283k|    }();
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE11iterator_atEm:
 3671|  12.9M|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3672|  12.9M|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3673|  12.9M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3661|   193k|  void emplace_at(iterator iter, Args&&... args) {
 3662|   193k|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|   193k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|   193k|           "constructed value does not match the lookup key");
 3669|   193k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_:
 3205|   193k|  inline void construct(slot_type* slot, Args&&... args) {
 3206|   193k|    common().RunWithReentrancyGuard([&] {
 3207|   193k|      allocator_type alloc(char_alloc_ref());
 3208|   193k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   193k|    });
 3210|   193k|  }
_ZN4absl12lts_2026052618container_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_:
 1322|   193k|  void RunWithReentrancyGuard(F f) {
 1323|   193k|#ifdef NDEBUG
 1324|   193k|    f();
 1325|   193k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_ENKUlvE_clEv:
 3206|   193k|    common().RunWithReentrancyGuard([&] {
 3207|   193k|      allocator_type alloc(char_alloc_ref());
 3208|   193k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   193k|    });
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iterator4slotEv:
 2285|  2.14M|    slot_type* slot() const { return slot_; }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE5beginEv:
 2582|  12.1k|  const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2583|  12.1k|    return const_cast<raw_hash_set*>(this)->begin();
 2584|  12.1k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE5beginEv:
 2568|  18.0k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2569|  18.0k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  190|  18.0k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 568, False: 17.4k]
  |  |  |  Branch (190:49): [Folded, False: 18.0k]
  |  |  |  Branch (190:58): [True: 568, False: 17.4k]
  |  |  ------------------
  ------------------
 2570|  17.4k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2570:9): [True: 2.00k, False: 15.4k]
  ------------------
 2571|  15.4k|    iterator it = {control(), common().slots_union(),
 2572|  15.4k|                   common().generation_ptr()};
 2573|  15.4k|    it.skip_empty_or_deleted();
 2574|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  256|  15.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2575|  15.4k|    return it;
 2576|  17.4k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE3endEv:
 2577|  3.57M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2578|  3.57M|    AssertNotDebugCapacity();
 2579|  3.57M|    return iterator(common().generation_ptr());
 2580|  3.57M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorC2EPKh:
 2257|  3.57M|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2248|  15.4k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2249|  15.4k|          ctrl_(ctrl),
 2250|  15.4k|          slot_(to_slot(slot.get())) {
 2251|       |      // This assumption helps the compiler know that any non-end iterator is
 2252|       |      // not equal to any end iterator.
 2253|  15.4k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|  15.4k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2254|  15.4k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iterator21skip_empty_or_deletedEv:
 2265|  2.52M|    void skip_empty_or_deleted() {
 2266|  4.10M|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2266:14): [True: 1.58M, False: 2.52M]
  ------------------
 2267|  1.58M|        ++ctrl_;
 2268|  1.58M|        ++slot_;
 2269|  1.58M|      }
 2270|  2.52M|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14const_iteratorC2ENSC_8iteratorE:
 2312|  3.57M|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE3endEv:
 2585|  1.78M|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2586|  1.78M|    return const_cast<raw_hash_set*>(this)->end();
 2587|  1.78M|  }
_ZN4absl12lts_2026052618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14const_iteratorESF_:
 2326|  2.53M|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2327|  2.53M|      return !(a == b);
 2328|  2.53M|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14const_iteratorESF_:
 2323|  2.53M|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2324|  2.53M|      return a.inner_ == b.inner_;
 2325|  2.53M|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorESF_:
 2222|  4.31M|    friend bool operator==(const iterator& a, const iterator& b) {
 2223|  4.31M|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 2224|  4.31M|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 2225|  4.31M|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 2226|  4.31M|                          a.generation_ptr(), b.generation_ptr());
 2227|  4.31M|      return a.ctrl_ == b.ctrl_;
 2228|  4.31M|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14const_iteratorppEv:
 2317|   729k|    const_iterator& operator++() {
 2318|   729k|      ++inner_;
 2319|   729k|      return *this;
 2320|   729k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorppEv:
 2207|  2.50M|    iterator& operator++() {
 2208|  2.50M|      assert_is_full("operator++");
 2209|  2.50M|      ++ctrl_;
 2210|  2.50M|      ++slot_;
 2211|  2.50M|      skip_empty_or_deleted();
 2212|  2.50M|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  190|  2.50M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 29.6k, False: 2.47M]
  |  |  |  Branch (190:49): [Folded, False: 2.50M]
  |  |  |  Branch (190:58): [True: 29.6k, False: 2.47M]
  |  |  ------------------
  ------------------
 2213|  2.50M|      return *this;
 2214|  2.50M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iterator14assert_is_fullEPKc:
 2259|  4.64M|    void assert_is_full(const char* operation) const {
 2260|  4.64M|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2261|  4.64M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE14const_iteratordeEv:
 2314|   364k|    reference operator*() const { return *inner_; }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratordeEv:
 2195|  2.14M|    reference operator*() const {
 2196|  2.14M|      assert_is_full("operator*()");
 2197|  2.14M|      return unchecked_deref();
 2198|  2.14M|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEEC2Ev:
 2352|  18.3k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE6insertISA_Li0EEENS4_4pairINSC_8iteratorEbEERKT_:
 2684|   374k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2685|   374k|    return emplace(value);
 2686|   374k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7emplaceIJRKSA_ETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENS4_4pairINSC_8iteratorEbEEDpOSH_:
 2799|   374k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2800|   374k|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2801|   374k|                               std::forward<Args>(args)...);
 2802|   374k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE19EmplaceDecomposableclISA_JRKSA_EEENS4_4pairINSC_8iteratorEbEERKT_DpOT0_:
 3177|   374k|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 3178|   374k|      auto res = s.find_or_prepare_insert(key);
 3179|   374k|      if (res.second) {
  ------------------
  |  Branch (3179:11): [True: 374k, False: 0]
  ------------------
 3180|   374k|        s.emplace_at(res.first, std::forward<Args>(args)...);
 3181|   374k|      }
 3182|   374k|      return res;
 3183|   374k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE22find_or_prepare_insertISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3646|   421k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3647|   421k|    AssertOnFind(key);
 3648|   421k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3648:9): [True: 19.7k, False: 402k]
  ------------------
 3649|   402k|    return find_or_prepare_insert_large(key);
 3650|   421k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE12AssertOnFindISA_EEvRKT_:
 3567|   421k|  void AssertOnFind([[maybe_unused]] const K& key) {
 3568|   421k|    AssertHashEqConsistent(key);
 3569|   421k|    AssertNotDebugCapacity();
 3570|   421k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE22AssertHashEqConsistentISA_EEvRKT_:
 3605|   421k|  void AssertHashEqConsistent(const K& key) {
 3606|   421k|#ifdef NDEBUG
 3607|   421k|    return;
 3608|      0|#endif
 3609|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3610|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3610:9): [True: 0, Folded]
  ------------------
 3611|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3611:9): [True: 0, Folded]
  ------------------
 3612|      0|      return;
 3613|      0|    }
 3614|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3614:9): [Folded, False: 0]
  ------------------
 3615|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3615:9): [Folded, False: 0]
  ------------------
 3616|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3616:9): [Folded, False: 0]
  ------------------
 3617|      0|      return;
 3618|      0|    }
 3619|      0|    if (empty()) return;
  ------------------
  |  Branch (3619:9): [True: 0, False: 0]
  ------------------
 3620|       |
 3621|      0|    const size_t hash_of_arg = hash_of(key);
 3622|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3623|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3624|      0|      if (!is_key_equal) return;
 3625|       |
 3626|      0|      [[maybe_unused]] const bool is_hash_equal =
 3627|      0|          hash_of_arg == hash_of(to_slot(slot));
 3628|      0|      assert((!is_key_equal || is_hash_equal) &&
 3629|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3630|      0|             "hash/eq functors are inconsistent.");
 3631|      0|    };
 3632|       |
 3633|      0|    if (is_small()) {
  ------------------
  |  Branch (3633:9): [True: 0, False: 0]
  ------------------
 3634|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3635|      0|      return;
 3636|      0|    }
 3637|       |    // We only do validation for small tables so that it's constant time.
 3638|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3638:9): [True: 0, False: 0]
  ------------------
 3639|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3640|      0|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE22AssertNotDebugCapacityEv:
 3573|   445k|  void AssertNotDebugCapacity() const {
 3574|   445k|#ifdef NDEBUG
 3575|   445k|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3575:9): [True: 445k, Folded]
  ------------------
 3576|   445k|      return;
 3577|   445k|    }
 3578|      0|#endif
 3579|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 3580|      0|    if (ABSL_PREDICT_TRUE(cap.IsValid())) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3581|      0|      return;
 3582|      0|    }
 3583|      0|    assert(!cap.IsReentrance() &&
 3584|      0|           "Reentrant container access during element construction/destruction "
 3585|      0|           "is not allowed.");
 3586|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3587|       |      if (cap.IsDestroyed()) {
 3588|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3589|       |      }
 3590|       |    }
 3591|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3591:9): [Folded, False: 0]
  ------------------
 3592|      0|        ABSL_PREDICT_FALSE(cap.IsMovedFrom())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3593|      0|      if (cap.IsSelfMovedFrom()) {
  ------------------
  |  Branch (3593:11): [True: 0, False: 0]
  ------------------
 3594|       |        // If this log triggers, then a hash table was move-assigned to itself
 3595|       |        // and then used again later without being reinitialized.
 3596|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3597|      0|      }
 3598|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3599|      0|    }
 3600|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE28find_or_prepare_insert_smallISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3497|  19.7k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3498|  19.7k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  19.7k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3499|       |    if constexpr (SooEnabled()) {
 3500|       |      return find_or_prepare_insert_soo(key);
 3501|       |    }
 3502|  19.7k|    if (!empty()) {
  ------------------
  |  Branch (3502:9): [True: 9.82k, False: 9.88k]
  ------------------
 3503|  9.82k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3503:11): [True: 0, False: 9.82k]
  ------------------
 3504|      0|        return {single_iterator(), false};
 3505|      0|      }
 3506|  9.82k|    }
 3507|  19.7k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3508|  19.7k|                common(), GetPolicyFunctions(),
 3509|  19.7k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3510|  19.7k|            true};
 3511|  19.7k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8equal_toISA_EEbRKT_PSA_:
 3344|  38.1k|                                             slot_type* slot) const {
 3345|  38.1k|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3346|  38.1k|                               PolicyTraits::element(slot));
 3347|  38.1k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE6eq_refEv:
 3771|  38.1k|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8iteratorC2EPNS1_6ctrl_tEPSA_PKh:
 2236|   421k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2237|   421k|          ctrl_(ctrl),
 2238|   421k|          slot_(slot) {
 2239|       |      // This assumption helps the compiler know that any non-end iterator is
 2240|       |      // not equal to any end iterator.
 2241|   421k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|   421k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2242|   421k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3678|  19.7k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3679|  19.7k|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3680|  19.7k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7to_slotEPv:
 3361|   103k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3362|   103k|    return static_cast<slot_type*>(buf);
 3363|   103k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE18GetPolicyFunctionsEv:
 3851|   421k|  static const PolicyFunctions& GetPolicyFunctions() {
 3852|   421k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3853|   421k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3854|   421k|                  "or use absl::node_hash_{map,set}.");
 3855|   421k|    static_assert(alignof(slot_type) <=
 3856|   421k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3857|   421k|    static_assert(sizeof(key_type) <=
 3858|   421k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3859|   421k|    static_assert(sizeof(value_type) <=
 3860|   421k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3861|   421k|    static constexpr size_t kBackingArrayAlignment =
 3862|   421k|        BackingArrayAlignment(alignof(slot_type));
 3863|   421k|    static constexpr PolicyFunctions value = {
 3864|   421k|        static_cast<uint32_t>(sizeof(key_type)),
 3865|   421k|        static_cast<uint32_t>(sizeof(value_type)),
 3866|   421k|        static_cast<uint32_t>(sizeof(slot_type)),
 3867|   421k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3868|   421k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3869|       |        // TODO(b/328722020): try to type erase
 3870|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3871|   421k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3871:9): [True: 0, Folded]
  ------------------
 3872|   421k|                                : &raw_hash_set::get_hash_ref_fn,
 3873|   421k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3874|   421k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3874:9): [Folded, False: 421k]
  ------------------
 3875|   421k|            ? TransferNRelocatable<sizeof(slot_type)>
 3876|   421k|            : &raw_hash_set::transfer_n_slots_fn,
 3877|   421k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3877:9): [True: 0, Folded]
  ------------------
 3878|   421k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3879|   421k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3880|   421k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3881|   421k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3882|   421k|    return value;
 3883|   421k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE19transfer_n_slots_fnEPvSD_SD_m:
 3787|  33.5k|                                  size_t count) {
 3788|  33.5k|    auto* src_slot = to_slot(src);
 3789|  33.5k|    auto* dst_slot = to_slot(dst);
 3790|       |
 3791|  33.5k|    auto* h = static_cast<raw_hash_set*>(set);
 3792|   139k|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3792:12): [True: 105k, False: 33.5k]
  ------------------
 3793|   105k|      h->transfer(dst_slot, src_slot);
 3794|   105k|    }
 3795|  33.5k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8transferEPSA_SD_:
 3217|   568k|  inline void transfer(slot_type* to, slot_type* from) {
 3218|   568k|    common().RunWithReentrancyGuard([&] {
 3219|   568k|      allocator_type alloc(char_alloc_ref());
 3220|   568k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   568k|    });
 3222|   568k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEE8transferEPSC_SF_EUlvE_EEvT_:
 1322|   568k|  void RunWithReentrancyGuard(F f) {
 1323|   568k|#ifdef NDEBUG
 1324|   568k|    f();
 1325|   568k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8transferEPSA_SD_ENKUlvE_clEv:
 3218|   568k|    common().RunWithReentrancyGuard([&] {
 3219|   568k|      allocator_type alloc(char_alloc_ref());
 3220|   568k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   568k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3804|  16.4k|                                    size_t source_offset, size_t h1)) {
 3805|  16.4k|    const size_t new_capacity = common.capacity();
 3806|  16.4k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3807|  16.4k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  271|  16.4k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3808|  16.4k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  271|  16.4k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3809|       |
 3810|  16.4k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3811|  16.4k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3812|  16.4k|    ctrl_t* new_ctrl = common.control();
 3813|  16.4k|    slot_type* new_slots = set->slot_array();
 3814|       |
 3815|  49.9k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3815:34): [True: 33.4k, False: 16.4k]
  ------------------
 3816|  33.4k|         group_index += Group::kWidth) {
 3817|  33.4k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3818|  33.4k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3819|  33.4k|                  Group::kWidth);
 3820|  33.4k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3821|  33.4k|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3822|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3823|       |      // We will share a lot of code in expense of one function call per group.
 3824|   468k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3824:38): [True: 468k, False: 33.4k]
  ------------------
 3825|   468k|        size_t old_index = group_index + in_fixed_group_index;
 3826|   468k|        slot_type* old_slot = old_slots_ptr + old_index;
 3827|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3828|       |        // only one new bit of h1.
 3829|   468k|        size_t hash = set->hash_of(old_slot);
 3830|   468k|        size_t h1 = H1(hash);
 3831|   468k|        h2_t h2 = H2(hash);
 3832|   468k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3833|   468k|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3834|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3835|       |        // till and included the old_index.
 3836|   468k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  190|   468k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 5.17k, False: 463k]
  |  |  |  Branch (190:49): [Folded, False: 468k]
  |  |  |  Branch (190:58): [True: 5.17k, False: 463k]
  |  |  ------------------
  ------------------
 3837|  5.17k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3838|  5.17k|          continue;
 3839|  5.17k|        }
 3840|   463k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  256|   463k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3841|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  256|   463k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3842|   463k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3843|   463k|        auto* new_slot = new_slots + new_index;
 3844|   463k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3845|   463k|        set->transfer(new_slot, old_slot);
 3846|   463k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3847|   463k|      }
 3848|  33.4k|    }
 3849|  16.4k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7hash_ofEPSA_:
 3353|   468k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3354|   468k|    return PolicyTraits::apply(
 3355|   468k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3356|   468k|        PolicyTraits::element(slot));
 3357|   468k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8hash_refEv:
 3769|   870k|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8hash_refEv:
 3768|  19.7k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3514|   402k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3515|   402k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   402k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3516|   402k|    prefetch_heap_block();
 3517|   402k|    const size_t hash = hash_of(key);
 3518|   402k|    auto seq = probe(common(), hash);
 3519|   402k|    const h2_t h2 = H2(hash);
 3520|   402k|    const ctrl_t* ctrl = control();
 3521|   402k|    size_t index;
 3522|   402k|    bool inserted;
 3523|       |    // We use a lambda function to be able to exit from the nested loop without
 3524|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3525|   402k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   402k|      while (true) {
 3527|   402k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   402k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   402k|#endif
 3530|   402k|        Group g{ctrl + seq.offset()};
 3531|   402k|        for (uint32_t i : g.Match(h2)) {
 3532|   402k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3533|   402k|            index = seq.offset(i);
 3534|   402k|            inserted = false;
 3535|   402k|            return;
 3536|   402k|          }
 3537|   402k|        }
 3538|   402k|        auto mask_empty = g.MaskEmpty();
 3539|   402k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3540|   402k|          size_t target_group_offset = seq.offset();
 3541|   402k|          index = SwisstableGenerationsEnabled()
 3542|   402k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|   402k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|   402k|                            FindInfo{target_group_offset, seq.index()},
 3545|   402k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   402k|                      : PrepareInsertLarge(
 3547|   402k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   402k|                            FindInfo{target_group_offset, seq.index()});
 3549|   402k|          inserted = true;
 3550|   402k|          return;
 3551|   402k|        }
 3552|   402k|        seq.next();
 3553|   402k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3554|   402k|      }
 3555|   402k|    }();
 3556|   402k|    return {iterator_at(index), inserted};
 3557|   402k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE19prefetch_heap_blockEv:
 3711|   402k|  void prefetch_heap_block() const {
 3712|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   402k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3713|   402k|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3714|   402k|    __builtin_prefetch(control(), 0, 1);
 3715|   402k|#endif
 3716|   402k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7hash_ofISA_EEmRKT_:
 3349|   402k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3350|   402k|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3351|   402k|                                               common().seed().seed()}(key);
 3352|   402k|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3525|   402k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   418k|      while (true) {
  ------------------
  |  Branch (3526:14): [True: 418k, Folded]
  ------------------
 3527|   418k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   418k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   418k|#endif
 3530|   418k|        Group g{ctrl + seq.offset()};
 3531|   418k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3531:25): [True: 28.3k, False: 418k]
  ------------------
 3532|  28.3k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  191|  28.3k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 28.3k]
  |  |  |  Branch (191:48): [Folded, False: 28.3k]
  |  |  |  Branch (191:57): [True: 0, False: 28.3k]
  |  |  ------------------
  ------------------
 3533|      0|            index = seq.offset(i);
 3534|      0|            inserted = false;
 3535|      0|            return;
 3536|      0|          }
 3537|  28.3k|        }
 3538|   418k|        auto mask_empty = g.MaskEmpty();
 3539|   418k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|   418k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 402k, False: 16.4k]
  |  |  |  Branch (191:48): [Folded, False: 418k]
  |  |  |  Branch (191:57): [True: 402k, False: 16.4k]
  |  |  ------------------
  ------------------
 3540|   402k|          size_t target_group_offset = seq.offset();
 3541|   402k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3541:19): [Folded, False: 402k]
  ------------------
 3542|   402k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|      0|                            FindInfo{target_group_offset, seq.index()},
 3545|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   402k|                      : PrepareInsertLarge(
 3547|   402k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   402k|                            FindInfo{target_group_offset, seq.index()});
 3549|   402k|          inserted = true;
 3550|   402k|          return;
 3551|   402k|        }
 3552|  16.4k|        seq.next();
 3553|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  16.4k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3554|  16.4k|      }
 3555|   402k|    }();
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE11iterator_atEm:
 3671|   402k|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3672|   402k|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3673|   402k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE10emplace_atIJRKSA_EEEvNSC_8iteratorEDpOT_:
 3661|   374k|  void emplace_at(iterator iter, Args&&... args) {
 3662|   374k|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|   374k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|   374k|           "constructed value does not match the lookup key");
 3669|   374k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE9constructIJRKSA_EEEvPSA_DpOT_:
 3205|   374k|  inline void construct(slot_type* slot, Args&&... args) {
 3206|   374k|    common().RunWithReentrancyGuard([&] {
 3207|   374k|      allocator_type alloc(char_alloc_ref());
 3208|   374k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   374k|    });
 3210|   374k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEE9constructIJRKSC_EEEvPSC_DpOT_EUlvE_EEvT_:
 1322|   374k|  void RunWithReentrancyGuard(F f) {
 1323|   374k|#ifdef NDEBUG
 1324|   374k|    f();
 1325|   374k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE9constructIJRKSA_EEEvPSA_DpOT_ENKUlvE_clEv:
 3206|   374k|    common().RunWithReentrancyGuard([&] {
 3207|   374k|      allocator_type alloc(char_alloc_ref());
 3208|   374k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   374k|    });
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE8iterator4slotEv:
 2285|   421k|    slot_type* slot() const { return slot_; }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE4sizeEv:
 2594|  24.0k|  size_t size() const {
 2595|  24.0k|    AssertNotDebugCapacity();
 2596|  24.0k|    const size_t size = common().size();
 2597|  24.0k|    [[maybe_unused]] const size_t kMaxValidSize = MaxValidSize();
 2598|  24.0k|    ABSL_ASSUME(size <= kMaxValidSize);
  ------------------
  |  |  271|  24.0k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2599|  24.0k|    return size;
 2600|  24.0k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEEC2Ev:
 2352|  11.8k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEED2Ev:
 2561|  11.8k|  ~raw_hash_set() {
 2562|  11.8k|    destructor_impl();
 2563|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2564|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 2565|       |    }
 2566|  11.8k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEEC2INS4_11__wrap_iterIPKNS4_4pairISA_fEEEEEET_SK_mRKNS1_10StringHashERKNS1_8StringEqERKNS8_INSF_IKSA_fEEEE:
 2381|  5.83k|      : raw_hash_set(SelectBucketCountForIterRange(first, last, bucket_count),
 2382|  5.83k|                     hash, eq, alloc) {
 2383|  5.83k|    insert(first, last);
 2384|  5.83k|  }
_ZN4absl12lts_2026052618container_internal29SelectBucketCountForIterRangeINSt3__111__wrap_iterIPKNS3_4pairINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEfEEEEEEmT_SG_m:
 1371|  5.83k|                                     size_t bucket_count) {
 1372|  5.83k|  if (bucket_count != 0) {
  ------------------
  |  Branch (1372:7): [True: 0, False: 5.83k]
  ------------------
 1373|      0|    return bucket_count;
 1374|      0|  }
 1375|  5.83k|  if (base_internal::IsAtLeastIterator<std::random_access_iterator_tag,
  ------------------
  |  Branch (1375:7): [True: 5.83k, Folded]
  ------------------
 1376|  5.83k|                                       InputIter>()) {
 1377|  5.83k|    return SizeToCapacity(static_cast<size_t>(std::distance(first, last)));
 1378|  5.83k|  }
 1379|      0|  return 0;
 1380|  5.83k|}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEEC2EmRKNS1_10StringHashERKNS1_8StringEqERKNS8_INS4_4pairIKSA_fEEEE:
 2358|  5.83k|      : settings_(CommonFields::CreateDefault<SooEnabled()>(), hash, eq,
 2359|  5.83k|                  alloc) {
 2360|  5.83k|    if (bucket_count > DefaultCapacity()) {
  ------------------
  |  Branch (2360:9): [True: 5.83k, False: 0]
  ------------------
 2361|  5.83k|      ReserveEmptyNonAllocatedTableToFitBucketCount(
 2362|  5.83k|          common(), GetPolicyFunctions(),
 2363|  5.83k|          (std::min)(bucket_count, MaxValidCapacity()));
 2364|  5.83k|    }
 2365|  5.83k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE15DefaultCapacityEv:
 2095|  5.83k|  constexpr static size_t DefaultCapacity() {
 2096|  5.83k|    return SooEnabled() ? SooCapacity() : 0;
  ------------------
  |  Branch (2096:12): [Folded, False: 5.83k]
  ------------------
 2097|  5.83k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE6commonEv:
 3718|  3.81M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE18GetPolicyFunctionsEv:
 3851|   463k|  static const PolicyFunctions& GetPolicyFunctions() {
 3852|   463k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3853|   463k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3854|   463k|                  "or use absl::node_hash_{map,set}.");
 3855|   463k|    static_assert(alignof(slot_type) <=
 3856|   463k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3857|   463k|    static_assert(sizeof(key_type) <=
 3858|   463k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3859|   463k|    static_assert(sizeof(value_type) <=
 3860|   463k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3861|   463k|    static constexpr size_t kBackingArrayAlignment =
 3862|   463k|        BackingArrayAlignment(alignof(slot_type));
 3863|   463k|    static constexpr PolicyFunctions value = {
 3864|   463k|        static_cast<uint32_t>(sizeof(key_type)),
 3865|   463k|        static_cast<uint32_t>(sizeof(value_type)),
 3866|   463k|        static_cast<uint32_t>(sizeof(slot_type)),
 3867|   463k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3868|   463k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3869|       |        // TODO(b/328722020): try to type erase
 3870|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3871|   463k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3871:9): [True: 0, Folded]
  ------------------
 3872|   463k|                                : &raw_hash_set::get_hash_ref_fn,
 3873|   463k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3874|   463k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3874:9): [Folded, False: 463k]
  ------------------
 3875|   463k|            ? TransferNRelocatable<sizeof(slot_type)>
 3876|   463k|            : &raw_hash_set::transfer_n_slots_fn,
 3877|   463k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3877:9): [True: 0, Folded]
  ------------------
 3878|   463k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3879|   463k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3880|   463k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3881|   463k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3882|   463k|    return value;
 3883|   463k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE19transfer_n_slots_fnEPvSD_SD_m:
 3787|  18.2k|                                  size_t count) {
 3788|  18.2k|    auto* src_slot = to_slot(src);
 3789|  18.2k|    auto* dst_slot = to_slot(dst);
 3790|       |
 3791|  18.2k|    auto* h = static_cast<raw_hash_set*>(set);
 3792|  74.8k|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3792:12): [True: 56.5k, False: 18.2k]
  ------------------
 3793|  56.5k|      h->transfer(dst_slot, src_slot);
 3794|  56.5k|    }
 3795|  18.2k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7to_slotEPv:
 3361|  62.8k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3362|  62.8k|    return static_cast<slot_type*>(buf);
 3363|  62.8k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8transferEPNS1_13map_slot_typeISA_fEESF_:
 3217|   285k|  inline void transfer(slot_type* to, slot_type* from) {
 3218|   285k|    common().RunWithReentrancyGuard([&] {
 3219|   285k|      allocator_type alloc(char_alloc_ref());
 3220|   285k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   285k|    });
 3222|   285k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE8transferEPNS1_13map_slot_typeISC_fEESH_EUlvE_EEvT_:
 1322|   285k|  void RunWithReentrancyGuard(F f) {
 1323|   285k|#ifdef NDEBUG
 1324|   285k|    f();
 1325|   285k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8transferEPNS1_13map_slot_typeISA_fEESF_ENKUlvE_clEv:
 3218|   285k|    common().RunWithReentrancyGuard([&] {
 3219|   285k|      allocator_type alloc(char_alloc_ref());
 3220|   285k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   285k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14char_alloc_refEv:
 3772|  1.21M|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3804|  8.78k|                                    size_t source_offset, size_t h1)) {
 3805|  8.78k|    const size_t new_capacity = common.capacity();
 3806|  8.78k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3807|  8.78k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  271|  8.78k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3808|  8.78k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  271|  8.78k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3809|       |
 3810|  8.78k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3811|  8.78k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3812|  8.78k|    ctrl_t* new_ctrl = common.control();
 3813|  8.78k|    slot_type* new_slots = set->slot_array();
 3814|       |
 3815|  25.3k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3815:34): [True: 16.5k, False: 8.78k]
  ------------------
 3816|  16.5k|         group_index += Group::kWidth) {
 3817|  16.5k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3818|  16.5k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3819|  16.5k|                  Group::kWidth);
 3820|  16.5k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3821|  16.5k|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3822|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3823|       |      // We will share a lot of code in expense of one function call per group.
 3824|   231k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3824:38): [True: 231k, False: 16.5k]
  ------------------
 3825|   231k|        size_t old_index = group_index + in_fixed_group_index;
 3826|   231k|        slot_type* old_slot = old_slots_ptr + old_index;
 3827|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3828|       |        // only one new bit of h1.
 3829|   231k|        size_t hash = set->hash_of(old_slot);
 3830|   231k|        size_t h1 = H1(hash);
 3831|   231k|        h2_t h2 = H2(hash);
 3832|   231k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3833|   231k|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3834|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3835|       |        // till and included the old_index.
 3836|   231k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  190|   231k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2.39k, False: 229k]
  |  |  |  Branch (190:49): [Folded, False: 231k]
  |  |  |  Branch (190:58): [True: 2.39k, False: 229k]
  |  |  ------------------
  ------------------
 3837|  2.39k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3838|  2.39k|          continue;
 3839|  2.39k|        }
 3840|   229k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  256|   229k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3841|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  256|   229k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3842|   229k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3843|   229k|        auto* new_slot = new_slots + new_index;
 3844|   229k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3845|   229k|        set->transfer(new_slot, old_slot);
 3846|   229k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3847|   229k|      }
 3848|  16.5k|    }
 3849|  8.78k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE10slot_arrayEv:
 3730|  2.11M|  slot_type* slot_array() const {
 3731|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  2.11M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3732|  2.11M|    return static_cast<slot_type*>(common().slot_array());
 3733|  2.11M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE6commonEv:
 3719|  6.84M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7hash_ofEPNS1_13map_slot_typeISA_fEE:
 3353|   231k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3354|   231k|    return PolicyTraits::apply(
 3355|   231k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3356|   231k|        PolicyTraits::element(slot));
 3357|   231k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8hash_refEv:
 3769|  1.11M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE16MaxValidCapacityEv:
 2102|  5.83k|  constexpr static size_t MaxValidCapacity() {
 2103|  5.83k|    return SizeToCapacity(MaxValidSize());
 2104|  5.83k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE12MaxValidSizeEv:
 2098|  5.83k|  constexpr static size_t MaxValidSize() {
 2099|  5.83k|    return container_internal::MaxValidSize(sizeof(key_type),
 2100|  5.83k|                                            sizeof(slot_type));
 2101|  5.83k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE6insertINS4_11__wrap_iterIPKNS4_4pairISA_fEEEEEEvT_SK_:
 2752|  5.83k|  void insert(InputIt first, InputIt last) {
 2753|  5.83k|    insert_range(first, last);
 2754|  5.83k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE12insert_rangeINS4_11__wrap_iterIPKNS4_4pairISA_fEEEEEEvT_SK_:
 3560|  5.83k|  void insert_range(InputIt first, InputIt last) {
 3561|   239k|    for (; first != last; ++first) emplace(*first);
  ------------------
  |  Branch (3561:12): [True: 233k, False: 5.83k]
  ------------------
 3562|  5.83k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7emplaceIJRKNS4_4pairISA_fEEETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSE_INSC_8iteratorEbEEDpOSJ_:
 2799|   233k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2800|   233k|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2801|   233k|                               std::forward<Args>(args)...);
 2802|   233k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE19EmplaceDecomposableclISA_JRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSI_IJRKfEEEEEENS4_4pairINSC_8iteratorEbEERKT_DpOT0_:
 3177|   233k|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 3178|   233k|      auto res = s.find_or_prepare_insert(key);
 3179|   233k|      if (res.second) {
  ------------------
  |  Branch (3179:11): [True: 233k, False: 0]
  ------------------
 3180|   233k|        s.emplace_at(res.first, std::forward<Args>(args)...);
 3181|   233k|      }
 3182|   233k|      return res;
 3183|   233k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE22find_or_prepare_insertISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3646|   589k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3647|   589k|    AssertOnFind(key);
 3648|   589k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3648:9): [True: 11.8k, False: 578k]
  ------------------
 3649|   578k|    return find_or_prepare_insert_large(key);
 3650|   589k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE12AssertOnFindISA_EEvRKT_:
 3567|   900k|  void AssertOnFind([[maybe_unused]] const K& key) {
 3568|   900k|    AssertHashEqConsistent(key);
 3569|   900k|    AssertNotDebugCapacity();
 3570|   900k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE22AssertHashEqConsistentISA_EEvRKT_:
 3605|   900k|  void AssertHashEqConsistent(const K& key) {
 3606|   900k|#ifdef NDEBUG
 3607|   900k|    return;
 3608|      0|#endif
 3609|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3610|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3610:9): [True: 0, Folded]
  ------------------
 3611|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3611:9): [True: 0, Folded]
  ------------------
 3612|      0|      return;
 3613|      0|    }
 3614|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3614:9): [Folded, False: 0]
  ------------------
 3615|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3615:9): [Folded, False: 0]
  ------------------
 3616|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3616:9): [Folded, False: 0]
  ------------------
 3617|      0|      return;
 3618|      0|    }
 3619|      0|    if (empty()) return;
  ------------------
  |  Branch (3619:9): [True: 0, False: 0]
  ------------------
 3620|       |
 3621|      0|    const size_t hash_of_arg = hash_of(key);
 3622|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3623|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3624|      0|      if (!is_key_equal) return;
 3625|       |
 3626|      0|      [[maybe_unused]] const bool is_hash_equal =
 3627|      0|          hash_of_arg == hash_of(to_slot(slot));
 3628|      0|      assert((!is_key_equal || is_hash_equal) &&
 3629|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3630|      0|             "hash/eq functors are inconsistent.");
 3631|      0|    };
 3632|       |
 3633|      0|    if (is_small()) {
  ------------------
  |  Branch (3633:9): [True: 0, False: 0]
  ------------------
 3634|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3635|      0|      return;
 3636|      0|    }
 3637|       |    // We only do validation for small tables so that it's constant time.
 3638|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3638:9): [True: 0, False: 0]
  ------------------
 3639|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3640|      0|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE22AssertNotDebugCapacityEv:
 3573|  1.38M|  void AssertNotDebugCapacity() const {
 3574|  1.38M|#ifdef NDEBUG
 3575|  1.38M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3575:9): [True: 1.38M, Folded]
  ------------------
 3576|  1.38M|      return;
 3577|  1.38M|    }
 3578|      0|#endif
 3579|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 3580|      0|    if (ABSL_PREDICT_TRUE(cap.IsValid())) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3581|      0|      return;
 3582|      0|    }
 3583|      0|    assert(!cap.IsReentrance() &&
 3584|      0|           "Reentrant container access during element construction/destruction "
 3585|      0|           "is not allowed.");
 3586|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3587|       |      if (cap.IsDestroyed()) {
 3588|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3589|       |      }
 3590|       |    }
 3591|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3591:9): [Folded, False: 0]
  ------------------
 3592|      0|        ABSL_PREDICT_FALSE(cap.IsMovedFrom())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3593|      0|      if (cap.IsSelfMovedFrom()) {
  ------------------
  |  Branch (3593:11): [True: 0, False: 0]
  ------------------
 3594|       |        // If this log triggers, then a hash table was move-assigned to itself
 3595|       |        // and then used again later without being reinitialized.
 3596|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3597|      0|      }
 3598|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3599|      0|    }
 3600|      0|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8is_smallEv:
 2117|   917k|  bool is_small() const { return common().is_small(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE28find_or_prepare_insert_smallISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3497|  11.8k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3498|  11.8k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  11.8k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3499|       |    if constexpr (SooEnabled()) {
 3500|       |      return find_or_prepare_insert_soo(key);
 3501|       |    }
 3502|  11.8k|    if (!empty()) {
  ------------------
  |  Branch (3502:9): [True: 5.89k, False: 5.95k]
  ------------------
 3503|  5.89k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3503:11): [True: 96, False: 5.79k]
  ------------------
 3504|     96|        return {single_iterator(), false};
 3505|     96|      }
 3506|  5.89k|    }
 3507|  11.7k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3508|  11.7k|                common(), GetPolicyFunctions(),
 3509|  11.7k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3510|  11.7k|            true};
 3511|  11.8k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE5emptyEv:
 2593|  18.1k|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8equal_toISA_EEbRKT_PNS1_13map_slot_typeISA_fEE:
 3344|   386k|                                             slot_type* slot) const {
 3345|   386k|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3346|   386k|                               PolicyTraits::element(slot));
 3347|   386k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE6eq_refEv:
 3771|   386k|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE11single_slotEv:
 3743|  6.64k|  slot_type* single_slot() {
 3744|  6.64k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  6.64k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3745|  6.64k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3745:12): [Folded, False: 6.64k]
  ------------------
 3746|  6.64k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE15single_iteratorEv:
 3757|    277|  iterator single_iterator() {
 3758|    277|    return {SooControl(), single_slot(), common().generation_ptr()};
 3759|    277|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeISA_fEEPKh:
 2236|   805k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2237|   805k|          ctrl_(ctrl),
 2238|   805k|          slot_(slot) {
 2239|       |      // This assumption helps the compiler know that any non-end iterator is
 2240|       |      // not equal to any end iterator.
 2241|   805k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|   805k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2242|   805k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3678|  11.7k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3679|  11.7k|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3680|  11.7k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8hash_refEv:
 3768|  11.7k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3514|   578k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3515|   578k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   578k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3516|   578k|    prefetch_heap_block();
 3517|   578k|    const size_t hash = hash_of(key);
 3518|   578k|    auto seq = probe(common(), hash);
 3519|   578k|    const h2_t h2 = H2(hash);
 3520|   578k|    const ctrl_t* ctrl = control();
 3521|   578k|    size_t index;
 3522|   578k|    bool inserted;
 3523|       |    // We use a lambda function to be able to exit from the nested loop without
 3524|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3525|   578k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   578k|      while (true) {
 3527|   578k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   578k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   578k|#endif
 3530|   578k|        Group g{ctrl + seq.offset()};
 3531|   578k|        for (uint32_t i : g.Match(h2)) {
 3532|   578k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3533|   578k|            index = seq.offset(i);
 3534|   578k|            inserted = false;
 3535|   578k|            return;
 3536|   578k|          }
 3537|   578k|        }
 3538|   578k|        auto mask_empty = g.MaskEmpty();
 3539|   578k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3540|   578k|          size_t target_group_offset = seq.offset();
 3541|   578k|          index = SwisstableGenerationsEnabled()
 3542|   578k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|   578k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|   578k|                            FindInfo{target_group_offset, seq.index()},
 3545|   578k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   578k|                      : PrepareInsertLarge(
 3547|   578k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   578k|                            FindInfo{target_group_offset, seq.index()});
 3549|   578k|          inserted = true;
 3550|   578k|          return;
 3551|   578k|        }
 3552|   578k|        seq.next();
 3553|   578k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3554|   578k|      }
 3555|   578k|    }();
 3556|   578k|    return {iterator_at(index), inserted};
 3557|   578k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE19prefetch_heap_blockEv:
 3711|   888k|  void prefetch_heap_block() const {
 3712|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   888k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3713|   888k|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3714|   888k|    __builtin_prefetch(control(), 0, 1);
 3715|   888k|#endif
 3716|   888k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7hash_ofISA_EEmRKT_:
 3349|   888k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3350|   888k|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3351|   888k|                                               common().seed().seed()}(key);
 3352|   888k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7controlEv:
 3726|  2.58M|  ctrl_t* control() const {
 3727|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  2.58M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3728|  2.58M|    return common().control();
 3729|  2.58M|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3525|   578k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   588k|      while (true) {
  ------------------
  |  Branch (3526:14): [True: 588k, Folded]
  ------------------
 3527|   588k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   588k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   588k|#endif
 3530|   588k|        Group g{ctrl + seq.offset()};
 3531|   588k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3531:25): [True: 154k, False: 456k]
  ------------------
 3532|   154k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  191|   154k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 132k, False: 22.6k]
  |  |  |  Branch (191:48): [Folded, False: 154k]
  |  |  |  Branch (191:57): [True: 132k, False: 22.6k]
  |  |  ------------------
  ------------------
 3533|   132k|            index = seq.offset(i);
 3534|   132k|            inserted = false;
 3535|   132k|            return;
 3536|   132k|          }
 3537|   154k|        }
 3538|   456k|        auto mask_empty = g.MaskEmpty();
 3539|   456k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|   456k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 445k, False: 10.6k]
  |  |  |  Branch (191:48): [Folded, False: 456k]
  |  |  |  Branch (191:57): [True: 445k, False: 10.6k]
  |  |  ------------------
  ------------------
 3540|   445k|          size_t target_group_offset = seq.offset();
 3541|   445k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3541:19): [Folded, False: 445k]
  ------------------
 3542|   445k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|      0|                            FindInfo{target_group_offset, seq.index()},
 3545|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   445k|                      : PrepareInsertLarge(
 3547|   445k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   445k|                            FindInfo{target_group_offset, seq.index()});
 3549|   445k|          inserted = true;
 3550|   445k|          return;
 3551|   445k|        }
 3552|  10.6k|        seq.next();
 3553|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  10.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3554|  10.6k|      }
 3555|   578k|    }();
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE11iterator_atEm:
 3671|   793k|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3672|   793k|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3673|   793k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJRKfEEEEEEvNSC_8iteratorEDpOT_:
 3661|   233k|  void emplace_at(iterator iter, Args&&... args) {
 3662|   233k|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|   233k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|   233k|           "constructed value does not match the lookup key");
 3669|   233k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJRKfEEEEEEvPNS1_13map_slot_typeISA_fEEDpOT_:
 3205|   233k|  inline void construct(slot_type* slot, Args&&... args) {
 3206|   233k|    common().RunWithReentrancyGuard([&] {
 3207|   233k|      allocator_type alloc(char_alloc_ref());
 3208|   233k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   233k|    });
 3210|   233k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSJ_IJRKfEEEEEEvPNS1_13map_slot_typeISC_fEEDpOT_EUlvE_EEvT_:
 1322|   233k|  void RunWithReentrancyGuard(F f) {
 1323|   233k|#ifdef NDEBUG
 1324|   233k|    f();
 1325|   233k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJRKfEEEEEEvPNS1_13map_slot_typeISA_fEEDpOT_ENKUlvE_clEv:
 3206|   233k|    common().RunWithReentrancyGuard([&] {
 3207|   233k|      allocator_type alloc(char_alloc_ref());
 3208|   233k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   233k|    });
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iterator4slotEv:
 2285|   457k|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEED2Ev:
 2561|  11.6k|  ~raw_hash_set() {
 2562|  11.6k|    destructor_impl();
 2563|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2564|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 2565|       |    }
 2566|  11.6k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE15destructor_implEv:
 3307|  11.6k|  void destructor_impl() {
 3308|  11.6k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3308:9): [Folded, False: 11.6k]
  |  Branch (3308:9): [Folded, False: 11.6k]
  ------------------
 3309|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (3309:9): [True: 0, False: 0]
  ------------------
 3310|      0|      return;
 3311|      0|    }
 3312|  11.6k|    if (capacity() == 0) return;
  ------------------
  |  Branch (3312:9): [True: 0, False: 11.6k]
  ------------------
 3313|  11.6k|    if (is_small()) {
  ------------------
  |  Branch (3313:9): [True: 163, False: 11.5k]
  ------------------
 3314|    163|      if (!empty()) {
  ------------------
  |  Branch (3314:11): [True: 163, False: 0]
  ------------------
 3315|    163|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|    163|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3316|    163|      }
 3317|       |      if constexpr (SooEnabled()) return;
 3318|  11.5k|    } else {
 3319|  11.5k|      destroy_slots();
 3320|  11.5k|    }
 3321|  11.6k|    dealloc();
 3322|  11.6k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8capacityEv:
 2601|  34.9k|  size_t capacity() const {
 2602|  34.9k|    const size_t cap = common().capacity();
 2603|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2604|  34.9k|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2605|  34.9k|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2606|  34.9k|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2607|  34.9k|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  271|  34.9k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 34.9k, False: 0]
  |  |  |  Branch (271:44): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2608|  34.9k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  271|  34.9k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2609|  34.9k|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  271|  34.9k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2610|  34.9k|    return cap;
 2611|  34.9k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7destroyEPNS1_13map_slot_typeISA_fEE:
 3211|   457k|  inline void destroy(slot_type* slot) {
 3212|   457k|    common().RunWithReentrancyGuard([&] {
 3213|   457k|      allocator_type alloc(char_alloc_ref());
 3214|   457k|      PolicyTraits::destroy(&alloc, slot);
 3215|   457k|    });
 3216|   457k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE7destroyEPNS1_13map_slot_typeISC_fEEEUlvE_EEvT_:
 1322|   457k|  void RunWithReentrancyGuard(F f) {
 1323|   457k|#ifdef NDEBUG
 1324|   457k|    f();
 1325|   457k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7destroyEPNS1_13map_slot_typeISA_fEEENKUlvE_clEv:
 3212|   457k|    common().RunWithReentrancyGuard([&] {
 3213|   457k|      allocator_type alloc(char_alloc_ref());
 3214|   457k|      PolicyTraits::destroy(&alloc, slot);
 3215|   457k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE13destroy_slotsEv:
 3280|  11.5k|  void destroy_slots() {
 3281|  11.5k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|  11.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3282|  11.5k|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (3282:9): [Folded, False: 11.5k]
  ------------------
 3283|  11.5k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|  11.5k|      this->destroy(static_cast<slot_type*>(slot));
 3285|  11.5k|    };
 3286|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3287|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3288|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 3289|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3290|       |      common().set_capacity(common_copy.capacity());
 3291|  11.5k|    } else {
 3292|  11.5k|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3293|  11.5k|    }
 3294|  11.5k|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE13destroy_slotsEvENKUlPKNS1_6ctrl_tEPvE_clESF_SG_:
 3283|   457k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|   457k|      this->destroy(static_cast<slot_type*>(slot));
 3285|   457k|    };
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE7deallocEv:
 3296|  11.6k|  void dealloc() {
 3297|  11.6k|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  256|  11.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3298|       |    // Unpoison before returning the memory to the allocator.
 3299|  11.6k|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3300|  11.6k|    infoz().Unregister();
 3301|  11.6k|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3302|  11.6k|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3303|  11.6k|                                      sizeof(slot_type), alignof(slot_type),
 3304|  11.6k|                                      common().has_infoz());
 3305|  11.6k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE5infozEv:
 3763|  11.6k|  HashtablezInfoHandle infoz() {
 3764|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  11.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3765|  11.6k|    return common().infoz();
 3766|  11.6k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE22find_or_prepare_insertISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3646|  12.7M|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3647|  12.7M|    AssertOnFind(key);
 3648|  12.7M|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3648:9): [True: 35.3k, False: 12.6M]
  ------------------
 3649|  12.6M|    return find_or_prepare_insert_large(key);
 3650|  12.7M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE12AssertOnFindISA_EEvRKT_:
 3567|  14.4M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3568|  14.4M|    AssertHashEqConsistent(key);
 3569|  14.4M|    AssertNotDebugCapacity();
 3570|  14.4M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE22AssertHashEqConsistentISA_EEvRKT_:
 3605|  14.4M|  void AssertHashEqConsistent(const K& key) {
 3606|  14.4M|#ifdef NDEBUG
 3607|  14.4M|    return;
 3608|      0|#endif
 3609|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3610|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3610:9): [True: 0, Folded]
  ------------------
 3611|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3611:9): [True: 0, Folded]
  ------------------
 3612|      0|      return;
 3613|      0|    }
 3614|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3614:9): [Folded, False: 0]
  ------------------
 3615|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3615:9): [Folded, False: 0]
  ------------------
 3616|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3616:9): [Folded, False: 0]
  ------------------
 3617|      0|      return;
 3618|      0|    }
 3619|      0|    if (empty()) return;
  ------------------
  |  Branch (3619:9): [True: 0, False: 0]
  ------------------
 3620|       |
 3621|      0|    const size_t hash_of_arg = hash_of(key);
 3622|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3623|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3624|      0|      if (!is_key_equal) return;
 3625|       |
 3626|      0|      [[maybe_unused]] const bool is_hash_equal =
 3627|      0|          hash_of_arg == hash_of(to_slot(slot));
 3628|      0|      assert((!is_key_equal || is_hash_equal) &&
 3629|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3630|      0|             "hash/eq functors are inconsistent.");
 3631|      0|    };
 3632|       |
 3633|      0|    if (is_small()) {
  ------------------
  |  Branch (3633:9): [True: 0, False: 0]
  ------------------
 3634|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3635|      0|      return;
 3636|      0|    }
 3637|       |    // We only do validation for small tables so that it's constant time.
 3638|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3638:9): [True: 0, False: 0]
  ------------------
 3639|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3640|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_smallISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3497|  35.3k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3498|  35.3k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  35.3k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3499|       |    if constexpr (SooEnabled()) {
 3500|       |      return find_or_prepare_insert_soo(key);
 3501|       |    }
 3502|  35.3k|    if (!empty()) {
  ------------------
  |  Branch (3502:9): [True: 24.2k, False: 11.1k]
  ------------------
 3503|  24.2k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3503:11): [True: 13.3k, False: 10.8k]
  ------------------
 3504|  13.3k|        return {single_iterator(), false};
 3505|  13.3k|      }
 3506|  24.2k|    }
 3507|  21.9k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3508|  21.9k|                common(), GetPolicyFunctions(),
 3509|  21.9k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3510|  21.9k|            true};
 3511|  35.3k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8equal_toISA_EEbRKT_PNS1_13map_slot_typeISA_lEE:
 3344|  11.3M|                                             slot_type* slot) const {
 3345|  11.3M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3346|  11.3M|                               PolicyTraits::element(slot));
 3347|  11.3M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3514|  12.6M|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3515|  12.6M|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  12.6M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3516|  12.6M|    prefetch_heap_block();
 3517|  12.6M|    const size_t hash = hash_of(key);
 3518|  12.6M|    auto seq = probe(common(), hash);
 3519|  12.6M|    const h2_t h2 = H2(hash);
 3520|  12.6M|    const ctrl_t* ctrl = control();
 3521|  12.6M|    size_t index;
 3522|  12.6M|    bool inserted;
 3523|       |    // We use a lambda function to be able to exit from the nested loop without
 3524|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3525|  12.6M|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|  12.6M|      while (true) {
 3527|  12.6M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|  12.6M|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|  12.6M|#endif
 3530|  12.6M|        Group g{ctrl + seq.offset()};
 3531|  12.6M|        for (uint32_t i : g.Match(h2)) {
 3532|  12.6M|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3533|  12.6M|            index = seq.offset(i);
 3534|  12.6M|            inserted = false;
 3535|  12.6M|            return;
 3536|  12.6M|          }
 3537|  12.6M|        }
 3538|  12.6M|        auto mask_empty = g.MaskEmpty();
 3539|  12.6M|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3540|  12.6M|          size_t target_group_offset = seq.offset();
 3541|  12.6M|          index = SwisstableGenerationsEnabled()
 3542|  12.6M|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|  12.6M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|  12.6M|                            FindInfo{target_group_offset, seq.index()},
 3545|  12.6M|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|  12.6M|                      : PrepareInsertLarge(
 3547|  12.6M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|  12.6M|                            FindInfo{target_group_offset, seq.index()});
 3549|  12.6M|          inserted = true;
 3550|  12.6M|          return;
 3551|  12.6M|        }
 3552|  12.6M|        seq.next();
 3553|  12.6M|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3554|  12.6M|      }
 3555|  12.6M|    }();
 3556|  12.6M|    return {iterator_at(index), inserted};
 3557|  12.6M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE7hash_ofISA_EEmRKT_:
 3349|  14.4M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3350|  14.4M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3351|  14.4M|                                               common().seed().seed()}(key);
 3352|  14.4M|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3525|  12.6M|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|  12.8M|      while (true) {
  ------------------
  |  Branch (3526:14): [True: 12.8M, Folded]
  ------------------
 3527|  12.8M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|  12.8M|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|  12.8M|#endif
 3530|  12.8M|        Group g{ctrl + seq.offset()};
 3531|  12.8M|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3531:25): [True: 11.1M, False: 2.14M]
  ------------------
 3532|  11.1M|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  191|  11.1M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 10.7M, False: 372k]
  |  |  |  Branch (191:48): [Folded, False: 11.1M]
  |  |  |  Branch (191:57): [True: 10.7M, False: 372k]
  |  |  ------------------
  ------------------
 3533|  10.7M|            index = seq.offset(i);
 3534|  10.7M|            inserted = false;
 3535|  10.7M|            return;
 3536|  10.7M|          }
 3537|  11.1M|        }
 3538|  2.14M|        auto mask_empty = g.MaskEmpty();
 3539|  2.14M|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|  2.14M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1.92M, False: 218k]
  |  |  |  Branch (191:48): [Folded, False: 2.14M]
  |  |  |  Branch (191:57): [True: 1.92M, False: 218k]
  |  |  ------------------
  ------------------
 3540|  1.92M|          size_t target_group_offset = seq.offset();
 3541|  1.92M|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3541:19): [Folded, False: 1.92M]
  ------------------
 3542|  1.92M|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|      0|                            FindInfo{target_group_offset, seq.index()},
 3545|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|  1.92M|                      : PrepareInsertLarge(
 3547|  1.92M|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|  1.92M|                            FindInfo{target_group_offset, seq.index()});
 3549|  1.92M|          inserted = true;
 3550|  1.92M|          return;
 3551|  1.92M|        }
 3552|   218k|        seq.next();
 3553|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|   218k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3554|   218k|      }
 3555|  12.6M|    }();
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3661|   170k|  void emplace_at(iterator iter, Args&&... args) {
 3662|   170k|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|   170k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|   170k|           "constructed value does not match the lookup key");
 3669|   170k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_:
 3205|   170k|  inline void construct(slot_type* slot, Args&&... args) {
 3206|   170k|    common().RunWithReentrancyGuard([&] {
 3207|   170k|      allocator_type alloc(char_alloc_ref());
 3208|   170k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   170k|    });
 3210|   170k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJOSC_EEENSJ_IJEEEEEEvPNS1_13map_slot_typeISC_lEEDpOT_EUlvE_EEvT_:
 1322|   170k|  void RunWithReentrancyGuard(F f) {
 1323|   170k|#ifdef NDEBUG
 1324|   170k|    f();
 1325|   170k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_ENKUlvE_clEv:
 3206|   170k|    common().RunWithReentrancyGuard([&] {
 3207|   170k|      allocator_type alloc(char_alloc_ref());
 3208|   170k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   170k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3661|  1.77M|  void emplace_at(iterator iter, Args&&... args) {
 3662|  1.77M|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|  1.77M|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|  1.77M|           "constructed value does not match the lookup key");
 3669|  1.77M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_:
 3205|  1.77M|  inline void construct(slot_type* slot, Args&&... args) {
 3206|  1.77M|    common().RunWithReentrancyGuard([&] {
 3207|  1.77M|      allocator_type alloc(char_alloc_ref());
 3208|  1.77M|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|  1.77M|    });
 3210|  1.77M|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSJ_IJEEEEEEvPNS1_13map_slot_typeISC_lEEDpOT_EUlvE_EEvT_:
 1322|  1.77M|  void RunWithReentrancyGuard(F f) {
 1323|  1.77M|#ifdef NDEBUG
 1324|  1.77M|    f();
 1325|  1.77M|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_lEEDpOT_ENKUlvE_clEv:
 3206|  1.77M|    common().RunWithReentrancyGuard([&] {
 3207|  1.77M|      allocator_type alloc(char_alloc_ref());
 3208|  1.77M|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|  1.77M|    });
_ZN4absl12lts_2026052618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE8iteratorESF_:
 2229|  1.78M|    friend bool operator!=(const iterator& a, const iterator& b) {
 2230|  1.78M|      return !(a == b);
 2231|  1.78M|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE5clearEv:
 2614|  5.83k|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2615|  5.83k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (2615:9): [Folded, False: 5.83k]
  |  Branch (2615:9): [Folded, False: 5.83k]
  ------------------
 2616|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (2616:9): [True: 0, False: 0]
  ------------------
 2617|      0|      common().set_capacity(DefaultCapacity());
 2618|      0|    }
 2619|  5.83k|    AssertNotDebugCapacity();
 2620|       |    // Iterating over this container is O(bucket_count()). When bucket_count()
 2621|       |    // is much greater than size(), iteration becomes prohibitively expensive.
 2622|       |    // For clear() it is more important to reuse the allocated array when the
 2623|       |    // container is small because allocation takes comparatively long time
 2624|       |    // compared to destruction of the elements of the container. So we pick the
 2625|       |    // largest bucket_count() threshold for which iteration is still fast and
 2626|       |    // past that we simply deallocate the array.
 2627|  5.83k|    const size_t cap = capacity();
 2628|  5.83k|    if (cap == 0) {
  ------------------
  |  Branch (2628:9): [True: 565, False: 5.27k]
  ------------------
 2629|       |      // Already guaranteed to be empty; so nothing to do.
 2630|  5.27k|    } else if (is_small()) {
  ------------------
  |  Branch (2630:16): [True: 241, False: 5.03k]
  ------------------
 2631|    241|      if (!empty()) {
  ------------------
  |  Branch (2631:11): [True: 241, False: 0]
  ------------------
 2632|    241|        destroy(single_slot());
 2633|    241|        decrement_small_size();
 2634|    241|      }
 2635|  5.03k|    } else {
 2636|  5.03k|      destroy_slots();
 2637|  5.03k|      clear_backing_array(/*reuse=*/cap < 128);
 2638|  5.03k|    }
 2639|  5.83k|    common().set_reserved_growth(0);
 2640|  5.83k|    common().set_reservation_size(0);
 2641|  5.83k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE20decrement_small_sizeEv:
 3750|    241|  void decrement_small_size() {
 3751|    241|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|    241|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3752|    241|    SooEnabled() ? common().set_empty_soo() : common().decrement_size();
  ------------------
  |  Branch (3752:5): [Folded, False: 241]
  ------------------
 3753|    241|    if (!SooEnabled()) {
  ------------------
  |  Branch (3753:9): [True: 241, Folded]
  ------------------
 3754|    241|      SanitizerPoisonObject(single_slot());
 3755|    241|    }
 3756|    241|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE19clear_backing_arrayEb:
 3275|  5.03k|  void clear_backing_array(bool reuse) {
 3276|       |    ABSL_SWISSTABLE_ASSERT(capacity() > MaxSmallCapacity());
  ------------------
  |  |  256|  5.03k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3277|  5.03k|    ClearBackingArray(common(), GetPolicyFunctions(), &char_alloc_ref(), reuse);
 3278|  5.03k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE4findISA_EENSC_14const_iteratorERKT_:
 3079|  1.77M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3080|  1.77M|    return const_cast<raw_hash_set*>(this)->find(key);
 3081|  1.77M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE4findISA_EENSC_8iteratorERKT_:
 3064|  1.77M|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3065|  1.77M|    AssertOnFind(key);
 3066|  1.77M|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (3066:9): [True: 200, False: 1.77M]
  ------------------
 3067|  1.77M|    prefetch_heap_block();
 3068|  1.77M|    return find_large(key, hash_of(key));
 3069|  1.77M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10find_smallISA_EENSC_8iteratorERKT_:
 3227|    200|  iterator find_small(const key_arg<K>& key) {
 3228|    200|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|    200|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3229|    200|    return empty() || !equal_to(key, single_slot()) ? end() : single_iterator();
  ------------------
  |  Branch (3229:12): [True: 0, False: 200]
  |  Branch (3229:23): [True: 200, False: 0]
  ------------------
 3230|    200|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEElEEJEE10find_largeISA_EENSC_8iteratorERKT_m:
 3233|  1.77M|  iterator find_large(const key_arg<K>& key, size_t hash) {
 3234|  1.77M|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|  1.77M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3235|  1.77M|    auto seq = probe(common(), hash);
 3236|  1.77M|    const h2_t h2 = H2(hash);
 3237|  1.77M|    const ctrl_t* ctrl = control();
 3238|  1.84M|    while (true) {
  ------------------
  |  Branch (3238:12): [True: 1.84M, Folded]
  ------------------
 3239|  1.84M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3240|  1.84M|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3241|  1.84M|#endif
 3242|  1.84M|      Group g{ctrl + seq.offset()};
 3243|  1.84M|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3243:23): [True: 151k, False: 1.84M]
  ------------------
 3244|   151k|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  191|   151k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 151k]
  |  |  |  Branch (191:48): [Folded, False: 151k]
  |  |  |  Branch (191:57): [True: 0, False: 151k]
  |  |  ------------------
  ------------------
 3245|      0|          return iterator_at(seq.offset(i));
 3246|   151k|      }
 3247|  1.84M|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  191|  1.84M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1.77M, False: 64.0k]
  |  |  |  Branch (191:48): [Folded, False: 1.84M]
  |  |  |  Branch (191:57): [True: 1.77M, False: 64.0k]
  |  |  ------------------
  ------------------
 3248|  64.0k|      seq.next();
 3249|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  64.0k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3250|  64.0k|    }
 3251|  1.77M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEEC2Ev:
 2352|  5.83k|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE5beginEv:
 2582|  7.50k|  const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2583|  7.50k|    return const_cast<raw_hash_set*>(this)->begin();
 2584|  7.50k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE5beginEv:
 2568|  7.74k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2569|  7.74k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  190|  7.74k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 14, False: 7.73k]
  |  |  |  Branch (190:49): [Folded, False: 7.74k]
  |  |  |  Branch (190:58): [True: 14, False: 7.73k]
  |  |  ------------------
  ------------------
 2570|  7.73k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2570:9): [True: 76, False: 7.65k]
  ------------------
 2571|  7.65k|    iterator it = {control(), common().slots_union(),
 2572|  7.65k|                   common().generation_ptr()};
 2573|  7.65k|    it.skip_empty_or_deleted();
 2574|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  256|  7.65k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2575|  7.65k|    return it;
 2576|  7.73k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2248|  7.65k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2249|  7.65k|          ctrl_(ctrl),
 2250|  7.65k|          slot_(to_slot(slot.get())) {
 2251|       |      // This assumption helps the compiler know that any non-end iterator is
 2252|       |      // not equal to any end iterator.
 2253|  7.65k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|  7.65k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2254|  7.65k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iterator21skip_empty_or_deletedEv:
 2265|   505k|    void skip_empty_or_deleted() {
 2266|   793k|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2266:14): [True: 287k, False: 505k]
  ------------------
 2267|   287k|        ++ctrl_;
 2268|   287k|        ++slot_;
 2269|   287k|      }
 2270|   505k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE14const_iteratorppEv:
 2317|   464k|    const_iterator& operator++() {
 2318|   464k|      ++inner_;
 2319|   464k|      return *this;
 2320|   464k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iteratorppEv:
 2207|   497k|    iterator& operator++() {
 2208|   497k|      assert_is_full("operator++");
 2209|   497k|      ++ctrl_;
 2210|   497k|      ++slot_;
 2211|   497k|      skip_empty_or_deleted();
 2212|   497k|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  190|   497k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 15.2k, False: 482k]
  |  |  |  Branch (190:49): [Folded, False: 497k]
  |  |  |  Branch (190:58): [True: 15.2k, False: 482k]
  |  |  ------------------
  ------------------
 2213|   497k|      return *this;
 2214|   497k|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iterator14assert_is_fullEPKc:
 2259|  2.90M|    void assert_is_full(const char* operation) const {
 2260|  2.90M|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2261|  2.90M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE14const_iteratordeEv:
 2314|   232k|    reference operator*() const { return *inner_; }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iteratordeEv:
 2195|  1.33M|    reference operator*() const {
 2196|  1.33M|      assert_is_full("operator*()");
 2197|  1.33M|      return unchecked_deref();
 2198|  1.33M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iterator15unchecked_derefEv:
 2282|  1.33M|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026052618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14const_iteratorESF_:
 2326|   770k|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2327|   770k|      return !(a == b);
 2328|   770k|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14const_iteratorESF_:
 2323|   770k|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2324|   770k|      return a.inner_ == b.inner_;
 2325|   770k|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratorESF_:
 2222|   770k|    friend bool operator==(const iterator& a, const iterator& b) {
 2223|   770k|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 2224|   770k|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 2225|   770k|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 2226|   770k|                          a.generation_ptr(), b.generation_ptr());
 2227|   770k|      return a.ctrl_ == b.ctrl_;
 2228|   770k|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE4findISA_EENSC_14const_iteratorERKT_:
 3079|   310k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3080|   310k|    return const_cast<raw_hash_set*>(this)->find(key);
 3081|   310k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE4findISA_EENSC_8iteratorERKT_:
 3064|   310k|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3065|   310k|    AssertOnFind(key);
 3066|   310k|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (3066:9): [True: 311, False: 310k]
  ------------------
 3067|   310k|    prefetch_heap_block();
 3068|   310k|    return find_large(key, hash_of(key));
 3069|   310k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE10find_smallISA_EENSC_8iteratorERKT_:
 3227|    311|  iterator find_small(const key_arg<K>& key) {
 3228|    311|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|    311|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3229|    311|    return empty() || !equal_to(key, single_slot()) ? end() : single_iterator();
  ------------------
  |  Branch (3229:12): [True: 0, False: 311]
  |  Branch (3229:23): [True: 168, False: 143]
  ------------------
 3230|    311|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE3endEv:
 2577|   410k|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2578|   410k|    AssertNotDebugCapacity();
 2579|   410k|    return iterator(common().generation_ptr());
 2580|   410k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratorC2EPKh:
 2257|   410k|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE10find_largeISA_EENSC_8iteratorERKT_m:
 3233|   310k|  iterator find_large(const key_arg<K>& key, size_t hash) {
 3234|   310k|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|   310k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3235|   310k|    auto seq = probe(common(), hash);
 3236|   310k|    const h2_t h2 = H2(hash);
 3237|   310k|    const ctrl_t* ctrl = control();
 3238|   320k|    while (true) {
  ------------------
  |  Branch (3238:12): [True: 320k, Folded]
  ------------------
 3239|   320k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3240|   320k|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3241|   320k|#endif
 3242|   320k|      Group g{ctrl + seq.offset()};
 3243|   320k|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3243:23): [True: 225k, False: 104k]
  ------------------
 3244|   225k|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  191|   225k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 215k, False: 9.97k]
  |  |  |  Branch (191:48): [Folded, False: 225k]
  |  |  |  Branch (191:57): [True: 215k, False: 9.97k]
  |  |  ------------------
  ------------------
 3245|   215k|          return iterator_at(seq.offset(i));
 3246|   225k|      }
 3247|   104k|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  191|   104k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 94.3k, False: 10.2k]
  |  |  |  Branch (191:48): [Folded, False: 104k]
  |  |  |  Branch (191:57): [True: 94.3k, False: 10.2k]
  |  |  ------------------
  ------------------
 3248|  10.2k|      seq.next();
 3249|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  10.2k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3250|  10.2k|    }
 3251|   310k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14const_iteratorC2ENSC_8iteratorE:
 2312|   632k|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE3endEv:
 2585|   316k|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2586|   316k|    return const_cast<raw_hash_set*>(this)->end();
 2587|   316k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE15unchecked_derefENSC_8iteratorE:
 3682|   356k|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iterator15unchecked_derefEv:
 2282|   580k|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3661|   224k|  void emplace_at(iterator iter, Args&&... args) {
 3662|   224k|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|   224k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|   224k|           "constructed value does not match the lookup key");
 3669|   224k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_fEEDpOT_:
 3205|   224k|  inline void construct(slot_type* slot, Args&&... args) {
 3206|   224k|    common().RunWithReentrancyGuard([&] {
 3207|   224k|      allocator_type alloc(char_alloc_ref());
 3208|   224k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   224k|    });
 3210|   224k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSJ_IJEEEEEEvPNS1_13map_slot_typeISC_fEEDpOT_EUlvE_EEvT_:
 1322|   224k|  void RunWithReentrancyGuard(F f) {
 1323|   224k|#ifdef NDEBUG
 1324|   224k|    f();
 1325|   224k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_fEEDpOT_ENKUlvE_clEv:
 3206|   224k|    common().RunWithReentrancyGuard([&] {
 3207|   224k|      allocator_type alloc(char_alloc_ref());
 3208|   224k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   224k|    });
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE4sizeEv:
 2594|  74.2k|  size_t size() const {
 2595|  74.2k|    AssertNotDebugCapacity();
 2596|  74.2k|    const size_t size = common().size();
 2597|  74.2k|    [[maybe_unused]] const size_t kMaxValidSize = MaxValidSize();
 2598|  74.2k|    ABSL_ASSUME(size <= kMaxValidSize);
  ------------------
  |  |  271|  74.2k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2599|  74.2k|    return size;
 2600|  74.2k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE5beginEv:
 2582|  5.83k|  const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2583|  5.83k|    return const_cast<raw_hash_set*>(this)->begin();
 2584|  5.83k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE5beginEv:
 2568|  5.83k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2569|  5.83k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  190|  5.83k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 5.83k]
  |  |  |  Branch (190:49): [Folded, False: 5.83k]
  |  |  |  Branch (190:58): [True: 0, False: 5.83k]
  |  |  ------------------
  ------------------
 2570|  5.83k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2570:9): [True: 38, False: 5.79k]
  ------------------
 2571|  5.79k|    iterator it = {control(), common().slots_union(),
 2572|  5.79k|                   common().generation_ptr()};
 2573|  5.79k|    it.skip_empty_or_deleted();
 2574|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  256|  5.79k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2575|  5.79k|    return it;
 2576|  5.83k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2248|  5.79k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2249|  5.79k|          ctrl_(ctrl),
 2250|  5.79k|          slot_(to_slot(slot.get())) {
 2251|       |      // This assumption helps the compiler know that any non-end iterator is
 2252|       |      // not equal to any end iterator.
 2253|  5.79k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|  5.79k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2254|  5.79k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iterator21skip_empty_or_deletedEv:
 2265|   453k|    void skip_empty_or_deleted() {
 2266|   684k|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2266:14): [True: 230k, False: 453k]
  ------------------
 2267|   230k|        ++ctrl_;
 2268|   230k|        ++slot_;
 2269|   230k|      }
 2270|   453k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14const_iteratorppEv:
 2317|   448k|    const_iterator& operator++() {
 2318|   448k|      ++inner_;
 2319|   448k|      return *this;
 2320|   448k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratorppEv:
 2207|   448k|    iterator& operator++() {
 2208|   448k|      assert_is_full("operator++");
 2209|   448k|      ++ctrl_;
 2210|   448k|      ++slot_;
 2211|   448k|      skip_empty_or_deleted();
 2212|   448k|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  190|   448k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 11.6k, False: 436k]
  |  |  |  Branch (190:49): [Folded, False: 448k]
  |  |  |  Branch (190:58): [True: 11.6k, False: 436k]
  |  |  ------------------
  ------------------
 2213|   448k|      return *this;
 2214|   448k|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iterator14assert_is_fullEPKc:
 2259|   672k|    void assert_is_full(const char* operation) const {
 2260|   672k|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2261|   672k|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE14const_iteratordeEv:
 2314|   224k|    reference operator*() const { return *inner_; }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEfEEJEE8iteratordeEv:
 2195|   224k|    reference operator*() const {
 2196|   224k|      assert_is_full("operator*()");
 2197|   224k|      return unchecked_deref();
 2198|   224k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEED2Ev:
 2561|    929|  ~raw_hash_set() {
 2562|    929|    destructor_impl();
 2563|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2564|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 2565|       |    }
 2566|    929|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE15destructor_implEv:
 3307|    929|  void destructor_impl() {
 3308|    929|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3308:9): [Folded, False: 929]
  |  Branch (3308:9): [Folded, False: 929]
  ------------------
 3309|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (3309:9): [True: 0, False: 0]
  ------------------
 3310|      0|      return;
 3311|      0|    }
 3312|    929|    if (capacity() == 0) return;
  ------------------
  |  Branch (3312:9): [True: 4, False: 925]
  ------------------
 3313|    925|    if (is_small()) {
  ------------------
  |  Branch (3313:9): [True: 37, False: 888]
  ------------------
 3314|     37|      if (!empty()) {
  ------------------
  |  Branch (3314:11): [True: 37, False: 0]
  ------------------
 3315|     37|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|     37|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3316|     37|      }
 3317|       |      if constexpr (SooEnabled()) return;
 3318|    888|    } else {
 3319|    888|      destroy_slots();
 3320|    888|    }
 3321|    925|    dealloc();
 3322|    925|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8capacityEv:
 2601|  2.77k|  size_t capacity() const {
 2602|  2.77k|    const size_t cap = common().capacity();
 2603|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2604|  2.77k|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2605|  2.77k|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2606|  2.77k|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2607|  2.77k|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  271|  2.78k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 2.77k, False: 4]
  |  |  |  Branch (271:44): [True: 4, False: 0]
  |  |  ------------------
  ------------------
 2608|  2.77k|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  271|  2.77k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2609|  2.77k|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  271|  2.77k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2610|  2.77k|    return cap;
 2611|  2.77k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE6commonEv:
 3719|  1.22M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8is_smallEv:
 2117|   149k|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE5emptyEv:
 2593|  4.91k|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE4sizeEv:
 2594|  4.91k|  size_t size() const {
 2595|  4.91k|    AssertNotDebugCapacity();
 2596|  4.91k|    const size_t size = common().size();
 2597|  4.91k|    [[maybe_unused]] const size_t kMaxValidSize = MaxValidSize();
 2598|  4.91k|    ABSL_ASSUME(size <= kMaxValidSize);
  ------------------
  |  |  271|  4.91k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2599|  4.91k|    return size;
 2600|  4.91k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE22AssertNotDebugCapacityEv:
 3573|   153k|  void AssertNotDebugCapacity() const {
 3574|   153k|#ifdef NDEBUG
 3575|   153k|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3575:9): [True: 153k, Folded]
  ------------------
 3576|   153k|      return;
 3577|   153k|    }
 3578|      0|#endif
 3579|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 3580|      0|    if (ABSL_PREDICT_TRUE(cap.IsValid())) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3581|      0|      return;
 3582|      0|    }
 3583|      0|    assert(!cap.IsReentrance() &&
 3584|      0|           "Reentrant container access during element construction/destruction "
 3585|      0|           "is not allowed.");
 3586|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3587|       |      if (cap.IsDestroyed()) {
 3588|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3589|       |      }
 3590|       |    }
 3591|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3591:9): [Folded, False: 0]
  ------------------
 3592|      0|        ABSL_PREDICT_FALSE(cap.IsMovedFrom())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3593|      0|      if (cap.IsSelfMovedFrom()) {
  ------------------
  |  Branch (3593:11): [True: 0, False: 0]
  ------------------
 3594|       |        // If this log triggers, then a hash table was move-assigned to itself
 3595|       |        // and then used again later without being reinitialized.
 3596|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3597|      0|      }
 3598|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3599|      0|    }
 3600|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7destroyEPNS1_13map_slot_typeISA_mEE:
 3211|  93.3k|  inline void destroy(slot_type* slot) {
 3212|  93.3k|    common().RunWithReentrancyGuard([&] {
 3213|  93.3k|      allocator_type alloc(char_alloc_ref());
 3214|  93.3k|      PolicyTraits::destroy(&alloc, slot);
 3215|  93.3k|    });
 3216|  93.3k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE6commonEv:
 3718|   716k|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEmEEJEE7destroyEPNS1_13map_slot_typeISC_mEEEUlvE_EEvT_:
 1322|  93.3k|  void RunWithReentrancyGuard(F f) {
 1323|  93.3k|#ifdef NDEBUG
 1324|  93.3k|    f();
 1325|  93.3k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7destroyEPNS1_13map_slot_typeISA_mEEENKUlvE_clEv:
 3212|  93.3k|    common().RunWithReentrancyGuard([&] {
 3213|  93.3k|      allocator_type alloc(char_alloc_ref());
 3214|  93.3k|      PolicyTraits::destroy(&alloc, slot);
 3215|  93.3k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14char_alloc_refEv:
 3772|   326k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE11single_slotEv:
 3743|  3.47k|  slot_type* single_slot() {
 3744|  3.47k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  3.47k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3745|  3.47k|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3745:12): [Folded, False: 3.47k]
  ------------------
 3746|  3.47k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE10slot_arrayEv:
 3730|   362k|  slot_type* slot_array() const {
 3731|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   362k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3732|   362k|    return static_cast<slot_type*>(common().slot_array());
 3733|   362k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE13destroy_slotsEv:
 3280|    888|  void destroy_slots() {
 3281|    888|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|    888|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3282|    888|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (3282:9): [Folded, False: 888]
  ------------------
 3283|    888|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|    888|      this->destroy(static_cast<slot_type*>(slot));
 3285|    888|    };
 3286|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3287|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3288|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 3289|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3290|       |      common().set_capacity(common_copy.capacity());
 3291|    888|    } else {
 3292|    888|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3293|    888|    }
 3294|    888|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE13destroy_slotsEvENKUlPKNS1_6ctrl_tEPvE_clESF_SG_:
 3283|  93.2k|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|  93.2k|      this->destroy(static_cast<slot_type*>(slot));
 3285|  93.2k|    };
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7deallocEv:
 3296|    925|  void dealloc() {
 3297|    925|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  256|    925|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3298|       |    // Unpoison before returning the memory to the allocator.
 3299|    925|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3300|    925|    infoz().Unregister();
 3301|    925|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3302|    925|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3303|    925|                                      sizeof(slot_type), alignof(slot_type),
 3304|    925|                                      common().has_infoz());
 3305|    925|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE5infozEv:
 3763|    925|  HashtablezInfoHandle infoz() {
 3764|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|    925|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3765|    925|    return common().infoz();
 3766|    925|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7controlEv:
 3726|   433k|  ctrl_t* control() const {
 3727|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   433k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3728|   433k|    return common().control();
 3729|   433k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEEC2Ev:
 2352|    929|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE15unchecked_derefENSC_8iteratorE:
 3682|   146k|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iterator15unchecked_derefEv:
 2282|   332k|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE22find_or_prepare_insertINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3646|   146k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3647|   146k|    AssertOnFind(key);
 3648|   146k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3648:9): [True: 3.05k, False: 143k]
  ------------------
 3649|   143k|    return find_or_prepare_insert_large(key);
 3650|   146k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE12AssertOnFindINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3567|   146k|  void AssertOnFind([[maybe_unused]] const K& key) {
 3568|   146k|    AssertHashEqConsistent(key);
 3569|   146k|    AssertNotDebugCapacity();
 3570|   146k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE22AssertHashEqConsistentINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3605|   146k|  void AssertHashEqConsistent(const K& key) {
 3606|   146k|#ifdef NDEBUG
 3607|   146k|    return;
 3608|      0|#endif
 3609|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3610|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3610:9): [True: 0, Folded]
  ------------------
 3611|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3611:9): [True: 0, Folded]
  ------------------
 3612|      0|      return;
 3613|      0|    }
 3614|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3614:9): [Folded, False: 0]
  ------------------
 3615|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3615:9): [Folded, False: 0]
  ------------------
 3616|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3616:9): [Folded, False: 0]
  ------------------
 3617|      0|      return;
 3618|      0|    }
 3619|      0|    if (empty()) return;
  ------------------
  |  Branch (3619:9): [True: 0, False: 0]
  ------------------
 3620|       |
 3621|      0|    const size_t hash_of_arg = hash_of(key);
 3622|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3623|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3624|      0|      if (!is_key_equal) return;
 3625|       |
 3626|      0|      [[maybe_unused]] const bool is_hash_equal =
 3627|      0|          hash_of_arg == hash_of(to_slot(slot));
 3628|      0|      assert((!is_key_equal || is_hash_equal) &&
 3629|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3630|      0|             "hash/eq functors are inconsistent.");
 3631|      0|    };
 3632|       |
 3633|      0|    if (is_small()) {
  ------------------
  |  Branch (3633:9): [True: 0, False: 0]
  ------------------
 3634|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3635|      0|      return;
 3636|      0|    }
 3637|       |    // We only do validation for small tables so that it's constant time.
 3638|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3638:9): [True: 0, False: 0]
  ------------------
 3639|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3640|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE28find_or_prepare_insert_smallINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3497|  3.05k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3498|  3.05k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  3.05k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3499|       |    if constexpr (SooEnabled()) {
 3500|       |      return find_or_prepare_insert_soo(key);
 3501|       |    }
 3502|  3.05k|    if (!empty()) {
  ------------------
  |  Branch (3502:9): [True: 2.12k, False: 925]
  ------------------
 3503|  2.12k|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3503:11): [True: 1.24k, False: 888]
  ------------------
 3504|  1.24k|        return {single_iterator(), false};
 3505|  1.24k|      }
 3506|  2.12k|    }
 3507|  1.81k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3508|  1.81k|                common(), GetPolicyFunctions(),
 3509|  1.81k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3510|  1.81k|            true};
 3511|  3.05k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8equal_toINS4_17basic_string_viewIcS7_EEEEbRKT_PNS1_13map_slot_typeISA_mEE:
 3344|  62.7k|                                             slot_type* slot) const {
 3345|  62.7k|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3346|  62.7k|                               PolicyTraits::element(slot));
 3347|  62.7k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE6eq_refEv:
 3771|  62.7k|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE15single_iteratorEv:
 3757|  1.30k|  iterator single_iterator() {
 3758|  1.30k|    return {SooControl(), single_slot(), common().generation_ptr()};
 3759|  1.30k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeISA_mEEPKh:
 2236|   146k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2237|   146k|          ctrl_(ctrl),
 2238|   146k|          slot_(slot) {
 2239|       |      // This assumption helps the compiler know that any non-end iterator is
 2240|       |      // not equal to any end iterator.
 2241|   146k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|   146k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2242|   146k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3678|  1.81k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3679|  1.81k|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3680|  1.81k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7to_slotEPv:
 3361|  12.4k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3362|  12.4k|    return static_cast<slot_type*>(buf);
 3363|  12.4k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE18GetPolicyFunctionsEv:
 3851|  93.3k|  static const PolicyFunctions& GetPolicyFunctions() {
 3852|  93.3k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3853|  93.3k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3854|  93.3k|                  "or use absl::node_hash_{map,set}.");
 3855|  93.3k|    static_assert(alignof(slot_type) <=
 3856|  93.3k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3857|  93.3k|    static_assert(sizeof(key_type) <=
 3858|  93.3k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3859|  93.3k|    static_assert(sizeof(value_type) <=
 3860|  93.3k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3861|  93.3k|    static constexpr size_t kBackingArrayAlignment =
 3862|  93.3k|        BackingArrayAlignment(alignof(slot_type));
 3863|  93.3k|    static constexpr PolicyFunctions value = {
 3864|  93.3k|        static_cast<uint32_t>(sizeof(key_type)),
 3865|  93.3k|        static_cast<uint32_t>(sizeof(value_type)),
 3866|  93.3k|        static_cast<uint32_t>(sizeof(slot_type)),
 3867|  93.3k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3868|  93.3k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3869|       |        // TODO(b/328722020): try to type erase
 3870|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3871|  93.3k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3871:9): [True: 0, Folded]
  ------------------
 3872|  93.3k|                                : &raw_hash_set::get_hash_ref_fn,
 3873|  93.3k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3874|  93.3k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3874:9): [Folded, False: 93.3k]
  ------------------
 3875|  93.3k|            ? TransferNRelocatable<sizeof(slot_type)>
 3876|  93.3k|            : &raw_hash_set::transfer_n_slots_fn,
 3877|  93.3k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3877:9): [True: 0, Folded]
  ------------------
 3878|  93.3k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3879|  93.3k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3880|  93.3k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3881|  93.3k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3882|  93.3k|    return value;
 3883|  93.3k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE19transfer_n_slots_fnEPvSD_SD_m:
 3787|  3.52k|                                  size_t count) {
 3788|  3.52k|    auto* src_slot = to_slot(src);
 3789|  3.52k|    auto* dst_slot = to_slot(dst);
 3790|       |
 3791|  3.52k|    auto* h = static_cast<raw_hash_set*>(set);
 3792|  12.6k|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3792:12): [True: 9.09k, False: 3.52k]
  ------------------
 3793|  9.09k|      h->transfer(dst_slot, src_slot);
 3794|  9.09k|    }
 3795|  3.52k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8transferEPNS1_13map_slot_typeISA_mEESF_:
 3217|   138k|  inline void transfer(slot_type* to, slot_type* from) {
 3218|   138k|    common().RunWithReentrancyGuard([&] {
 3219|   138k|      allocator_type alloc(char_alloc_ref());
 3220|   138k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   138k|    });
 3222|   138k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEmEEJEE8transferEPNS1_13map_slot_typeISC_mEESH_EUlvE_EEvT_:
 1322|   138k|  void RunWithReentrancyGuard(F f) {
 1323|   138k|#ifdef NDEBUG
 1324|   138k|    f();
 1325|   138k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8transferEPNS1_13map_slot_typeISA_mEESF_ENKUlvE_clEv:
 3218|   138k|    common().RunWithReentrancyGuard([&] {
 3219|   138k|      allocator_type alloc(char_alloc_ref());
 3220|   138k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   138k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3804|  1.87k|                                    size_t source_offset, size_t h1)) {
 3805|  1.87k|    const size_t new_capacity = common.capacity();
 3806|  1.87k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3807|  1.87k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  271|  1.87k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3808|  1.87k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  271|  1.87k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3809|       |
 3810|  1.87k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3811|  1.87k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3812|  1.87k|    ctrl_t* new_ctrl = common.control();
 3813|  1.87k|    slot_type* new_slots = set->slot_array();
 3814|       |
 3815|  11.1k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3815:34): [True: 9.32k, False: 1.87k]
  ------------------
 3816|  9.32k|         group_index += Group::kWidth) {
 3817|  9.32k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3818|  9.32k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3819|  9.32k|                  Group::kWidth);
 3820|  9.32k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3821|  9.32k|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3822|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3823|       |      // We will share a lot of code in expense of one function call per group.
 3824|   130k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3824:38): [True: 130k, False: 9.32k]
  ------------------
 3825|   130k|        size_t old_index = group_index + in_fixed_group_index;
 3826|   130k|        slot_type* old_slot = old_slots_ptr + old_index;
 3827|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3828|       |        // only one new bit of h1.
 3829|   130k|        size_t hash = set->hash_of(old_slot);
 3830|   130k|        size_t h1 = H1(hash);
 3831|   130k|        h2_t h2 = H2(hash);
 3832|   130k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3833|   130k|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3834|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3835|       |        // till and included the old_index.
 3836|   130k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  190|   130k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 1.16k, False: 129k]
  |  |  |  Branch (190:49): [Folded, False: 130k]
  |  |  |  Branch (190:58): [True: 1.16k, False: 129k]
  |  |  ------------------
  ------------------
 3837|  1.16k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3838|  1.16k|          continue;
 3839|  1.16k|        }
 3840|   129k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  256|   129k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3841|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  256|   129k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3842|   129k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3843|   129k|        auto* new_slot = new_slots + new_index;
 3844|   129k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3845|   129k|        set->transfer(new_slot, old_slot);
 3846|   129k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3847|   129k|      }
 3848|  9.32k|    }
 3849|  1.87k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7hash_ofEPNS1_13map_slot_typeISA_mEE:
 3353|   130k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3354|   130k|    return PolicyTraits::apply(
 3355|   130k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3356|   130k|        PolicyTraits::element(slot));
 3357|   130k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8hash_refEv:
 3769|   274k|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8hash_refEv:
 3768|  1.81k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE28find_or_prepare_insert_largeINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_:
 3514|   143k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3515|   143k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   143k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3516|   143k|    prefetch_heap_block();
 3517|   143k|    const size_t hash = hash_of(key);
 3518|   143k|    auto seq = probe(common(), hash);
 3519|   143k|    const h2_t h2 = H2(hash);
 3520|   143k|    const ctrl_t* ctrl = control();
 3521|   143k|    size_t index;
 3522|   143k|    bool inserted;
 3523|       |    // We use a lambda function to be able to exit from the nested loop without
 3524|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3525|   143k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   143k|      while (true) {
 3527|   143k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   143k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   143k|#endif
 3530|   143k|        Group g{ctrl + seq.offset()};
 3531|   143k|        for (uint32_t i : g.Match(h2)) {
 3532|   143k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3533|   143k|            index = seq.offset(i);
 3534|   143k|            inserted = false;
 3535|   143k|            return;
 3536|   143k|          }
 3537|   143k|        }
 3538|   143k|        auto mask_empty = g.MaskEmpty();
 3539|   143k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3540|   143k|          size_t target_group_offset = seq.offset();
 3541|   143k|          index = SwisstableGenerationsEnabled()
 3542|   143k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|   143k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|   143k|                            FindInfo{target_group_offset, seq.index()},
 3545|   143k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   143k|                      : PrepareInsertLarge(
 3547|   143k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   143k|                            FindInfo{target_group_offset, seq.index()});
 3549|   143k|          inserted = true;
 3550|   143k|          return;
 3551|   143k|        }
 3552|   143k|        seq.next();
 3553|   143k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3554|   143k|      }
 3555|   143k|    }();
 3556|   143k|    return {iterator_at(index), inserted};
 3557|   143k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE19prefetch_heap_blockEv:
 3711|   143k|  void prefetch_heap_block() const {
 3712|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   143k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3713|   143k|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3714|   143k|    __builtin_prefetch(control(), 0, 1);
 3715|   143k|#endif
 3716|   143k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE7hash_ofINS4_17basic_string_viewIcS7_EEEEmRKT_:
 3349|   143k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3350|   143k|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3351|   143k|                                               common().seed().seed()}(key);
 3352|   143k|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE28find_or_prepare_insert_largeINS4_17basic_string_viewIcS7_EEEENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3525|   143k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   151k|      while (true) {
  ------------------
  |  Branch (3526:14): [True: 151k, Folded]
  ------------------
 3527|   151k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   151k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   151k|#endif
 3530|   151k|        Group g{ctrl + seq.offset()};
 3531|   151k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3531:25): [True: 60.5k, False: 99.4k]
  ------------------
 3532|  60.5k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  191|  60.5k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 52.1k, False: 8.48k]
  |  |  |  Branch (191:48): [Folded, False: 60.5k]
  |  |  |  Branch (191:57): [True: 52.1k, False: 8.48k]
  |  |  ------------------
  ------------------
 3533|  52.1k|            index = seq.offset(i);
 3534|  52.1k|            inserted = false;
 3535|  52.1k|            return;
 3536|  52.1k|          }
 3537|  60.5k|        }
 3538|  99.4k|        auto mask_empty = g.MaskEmpty();
 3539|  99.4k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|  99.4k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 91.4k, False: 7.92k]
  |  |  |  Branch (191:48): [Folded, False: 99.4k]
  |  |  |  Branch (191:57): [True: 91.4k, False: 7.92k]
  |  |  ------------------
  ------------------
 3540|  91.4k|          size_t target_group_offset = seq.offset();
 3541|  91.4k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3541:19): [Folded, False: 91.4k]
  ------------------
 3542|  91.4k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|      0|                            FindInfo{target_group_offset, seq.index()},
 3545|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|  91.4k|                      : PrepareInsertLarge(
 3547|  91.4k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|  91.4k|                            FindInfo{target_group_offset, seq.index()});
 3549|  91.4k|          inserted = true;
 3550|  91.4k|          return;
 3551|  91.4k|        }
 3552|  7.92k|        seq.next();
 3553|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  7.92k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3554|  7.92k|      }
 3555|   143k|    }();
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE11iterator_atEm:
 3671|   143k|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3672|   143k|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3673|   143k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3661|  93.3k|  void emplace_at(iterator iter, Args&&... args) {
 3662|  93.3k|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|  93.3k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|  93.3k|           "constructed value does not match the lookup key");
 3669|  93.3k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_mEEDpOT_:
 3205|  93.3k|  inline void construct(slot_type* slot, Args&&... args) {
 3206|  93.3k|    common().RunWithReentrancyGuard([&] {
 3207|  93.3k|      allocator_type alloc(char_alloc_ref());
 3208|  93.3k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|  93.3k|    });
 3210|  93.3k|  }
_ZN4absl12lts_2026052618container_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_:
 1322|  93.3k|  void RunWithReentrancyGuard(F f) {
 1323|  93.3k|#ifdef NDEBUG
 1324|  93.3k|    f();
 1325|  93.3k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKNS4_17basic_string_viewIcS7_EEEEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_mEEDpOT_ENKUlvE_clEv:
 3206|  93.3k|    common().RunWithReentrancyGuard([&] {
 3207|  93.3k|      allocator_type alloc(char_alloc_ref());
 3208|  93.3k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|  93.3k|    });
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iterator4slotEv:
 2285|  93.3k|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE5beginEv:
 2568|  1.82k|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2569|  1.82k|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  190|  1.82k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 6, False: 1.82k]
  |  |  |  Branch (190:49): [Folded, False: 1.82k]
  |  |  |  Branch (190:58): [True: 6, False: 1.82k]
  |  |  ------------------
  ------------------
 2570|  1.82k|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2570:9): [True: 66, False: 1.75k]
  ------------------
 2571|  1.75k|    iterator it = {control(), common().slots_union(),
 2572|  1.75k|                   common().generation_ptr()};
 2573|  1.75k|    it.skip_empty_or_deleted();
 2574|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  256|  1.75k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2575|  1.75k|    return it;
 2576|  1.82k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2248|  1.75k|        : HashSetIteratorGenerationInfo(generation_ptr),
 2249|  1.75k|          ctrl_(ctrl),
 2250|  1.75k|          slot_(to_slot(slot.get())) {
 2251|       |      // This assumption helps the compiler know that any non-end iterator is
 2252|       |      // not equal to any end iterator.
 2253|  1.75k|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|  1.75k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2254|  1.75k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iterator21skip_empty_or_deletedEv:
 2265|   280k|    void skip_empty_or_deleted() {
 2266|   479k|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2266:14): [True: 199k, False: 280k]
  ------------------
 2267|   199k|        ++ctrl_;
 2268|   199k|        ++slot_;
 2269|   199k|      }
 2270|   280k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE3endEv:
 2577|  1.83k|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2578|  1.83k|    AssertNotDebugCapacity();
 2579|  1.83k|    return iterator(common().generation_ptr());
 2580|  1.83k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorC2EPKh:
 2257|  1.83k|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026052618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorESF_:
 2229|  93.7k|    friend bool operator!=(const iterator& a, const iterator& b) {
 2230|  93.7k|      return !(a == b);
 2231|  93.7k|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorESF_:
 2222|   281k|    friend bool operator==(const iterator& a, const iterator& b) {
 2223|   281k|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 2224|   281k|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 2225|   281k|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 2226|   281k|                          a.generation_ptr(), b.generation_ptr());
 2227|   281k|      return a.ctrl_ == b.ctrl_;
 2228|   281k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratorppEv:
 2207|   278k|    iterator& operator++() {
 2208|   278k|      assert_is_full("operator++");
 2209|   278k|      ++ctrl_;
 2210|   278k|      ++slot_;
 2211|   278k|      skip_empty_or_deleted();
 2212|   278k|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  190|   278k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2.73k, False: 275k]
  |  |  |  Branch (190:49): [Folded, False: 278k]
  |  |  |  Branch (190:58): [True: 2.73k, False: 275k]
  |  |  ------------------
  ------------------
 2213|   278k|      return *this;
 2214|   278k|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iterator14assert_is_fullEPKc:
 2259|   464k|    void assert_is_full(const char* operation) const {
 2260|   464k|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2261|   464k|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE8iteratordeEv:
 2195|   185k|    reference operator*() const {
 2196|   185k|      assert_is_full("operator*()");
 2197|   185k|      return unchecked_deref();
 2198|   185k|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE5beginEv:
 2582|    913|  const_iterator begin() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2583|    913|    return const_cast<raw_hash_set*>(this)->begin();
 2584|    913|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14const_iteratorC2ENSC_8iteratorE:
 2312|  1.82k|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE3endEv:
 2585|    913|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2586|    913|    return const_cast<raw_hash_set*>(this)->end();
 2587|    913|  }
_ZN4absl12lts_2026052618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14const_iteratorESF_:
 2326|   187k|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2327|   187k|      return !(a == b);
 2328|   187k|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14const_iteratorESF_:
 2323|   187k|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2324|   187k|      return a.inner_ == b.inner_;
 2325|   187k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14const_iteratorppEv:
 2317|   185k|    const_iterator& operator++() {
 2318|   185k|      ++inner_;
 2319|   185k|      return *this;
 2320|   185k|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmEEJEE14const_iteratordeEv:
 2314|  92.8k|    reference operator*() const { return *inner_; }
_ZN4absl12lts_2026052618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iteratorES8_:
 2229|  33.5k|    friend bool operator!=(const iterator& a, const iterator& b) {
 2230|  33.5k|      return !(a == b);
 2231|  33.5k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEED2Ev:
 2561|  1.44k|  ~raw_hash_set() {
 2562|  1.44k|    destructor_impl();
 2563|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2564|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 2565|       |    }
 2566|  1.44k|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7destroyEPNS1_13map_slot_typeImS8_EEENKUlvE_clEv:
 3212|  47.5k|    common().RunWithReentrancyGuard([&] {
 3213|  47.5k|      allocator_type alloc(char_alloc_ref());
 3214|  47.5k|      PolicyTraits::destroy(&alloc, slot);
 3215|  47.5k|    });
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE14const_iteratorptEv:
 2315|  1.07M|    pointer operator->() const { return inner_.operator->(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDilEEJEE8iteratorptEv:
 2201|  1.07M|    pointer operator->() const {
 2202|  1.07M|      assert_is_full("operator->");
 2203|  1.07M|      return &operator*();
 2204|  1.07M|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE4findImEENSA_8iteratorERKm:
 3064|  4.56M|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3065|  4.56M|    AssertOnFind(key);
 3066|  4.56M|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (3066:9): [True: 3.06k, False: 4.56M]
  ------------------
 3067|  4.56M|    prefetch_heap_block();
 3068|  4.56M|    return find_large(key, hash_of(key));
 3069|  4.56M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE12AssertOnFindImEEvRKT_:
 3567|  4.85M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3568|  4.85M|    AssertHashEqConsistent(key);
 3569|  4.85M|    AssertNotDebugCapacity();
 3570|  4.85M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE22AssertHashEqConsistentImEEvRKT_:
 3605|  4.85M|  void AssertHashEqConsistent(const K& key) {
 3606|  4.85M|#ifdef NDEBUG
 3607|  4.85M|    return;
 3608|      0|#endif
 3609|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3610|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3610:9): [Folded, False: 0]
  ------------------
 3611|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3611:9): [Folded, False: 0]
  ------------------
 3612|      0|      return;
 3613|      0|    }
 3614|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3614:9): [True: 0, Folded]
  ------------------
 3615|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3615:9): [True: 0, Folded]
  ------------------
 3616|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3616:9): [True: 0, Folded]
  ------------------
 3617|      0|      return;
 3618|      0|    }
 3619|      0|    if (empty()) return;
  ------------------
  |  Branch (3619:9): [True: 0, False: 0]
  ------------------
 3620|       |
 3621|      0|    const size_t hash_of_arg = hash_of(key);
 3622|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3623|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3624|      0|      if (!is_key_equal) return;
 3625|       |
 3626|      0|      [[maybe_unused]] const bool is_hash_equal =
 3627|      0|          hash_of_arg == hash_of(to_slot(slot));
 3628|      0|      assert((!is_key_equal || is_hash_equal) &&
 3629|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3630|      0|             "hash/eq functors are inconsistent.");
 3631|      0|    };
 3632|       |
 3633|      0|    if (is_small()) {
  ------------------
  |  Branch (3633:9): [True: 0, False: 0]
  ------------------
 3634|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3635|      0|      return;
 3636|      0|    }
 3637|       |    // We only do validation for small tables so that it's constant time.
 3638|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3638:9): [True: 0, False: 0]
  ------------------
 3639|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3640|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE10find_smallImEENSA_8iteratorERKm:
 3227|  3.06k|  iterator find_small(const key_arg<K>& key) {
 3228|  3.06k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  3.06k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3229|  3.06k|    return empty() || !equal_to(key, single_slot()) ? end() : single_iterator();
  ------------------
  |  Branch (3229:12): [True: 1.42k, False: 1.64k]
  |  Branch (3229:23): [True: 1.42k, False: 224]
  ------------------
 3230|  3.06k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8equal_toImEEbRKT_PNS1_13map_slot_typeImS8_EE:
 3344|  4.23M|                                             slot_type* slot) const {
 3345|  4.23M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3346|  4.23M|                               PolicyTraits::element(slot));
 3347|  4.23M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE6eq_refEv:
 3771|  4.23M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE15single_iteratorEv:
 3757|  1.64k|  iterator single_iterator() {
 3758|  1.64k|    return {SooControl(), single_slot(), common().generation_ptr()};
 3759|  1.64k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeImS8_EEPKh:
 2236|  4.39M|        : HashSetIteratorGenerationInfo(generation_ptr),
 2237|  4.39M|          ctrl_(ctrl),
 2238|  4.39M|          slot_(slot) {
 2239|       |      // This assumption helps the compiler know that any non-end iterator is
 2240|       |      // not equal to any end iterator.
 2241|  4.39M|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|  4.39M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2242|  4.39M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE19prefetch_heap_blockEv:
 3711|  4.85M|  void prefetch_heap_block() const {
 3712|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  4.85M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3713|  4.85M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3714|  4.85M|    __builtin_prefetch(control(), 0, 1);
 3715|  4.85M|#endif
 3716|  4.85M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE10find_largeImEENSA_8iteratorERKmm:
 3233|  4.56M|  iterator find_large(const key_arg<K>& key, size_t hash) {
 3234|  4.56M|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|  4.56M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3235|  4.56M|    auto seq = probe(common(), hash);
 3236|  4.56M|    const h2_t h2 = H2(hash);
 3237|  4.56M|    const ctrl_t* ctrl = control();
 3238|  4.65M|    while (true) {
  ------------------
  |  Branch (3238:12): [True: 4.65M, Folded]
  ------------------
 3239|  4.65M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3240|  4.65M|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3241|  4.65M|#endif
 3242|  4.65M|      Group g{ctrl + seq.offset()};
 3243|  4.65M|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3243:23): [True: 4.20M, False: 545k]
  ------------------
 3244|  4.20M|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  191|  4.20M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 4.10M, False: 104k]
  |  |  |  Branch (191:48): [Folded, False: 4.20M]
  |  |  |  Branch (191:57): [True: 4.10M, False: 104k]
  |  |  ------------------
  ------------------
 3245|  4.10M|          return iterator_at(seq.offset(i));
 3246|  4.20M|      }
 3247|   545k|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  191|   545k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 457k, False: 87.5k]
  |  |  |  Branch (191:48): [Folded, False: 545k]
  |  |  |  Branch (191:57): [True: 457k, False: 87.5k]
  |  |  ------------------
  ------------------
 3248|  87.5k|      seq.next();
 3249|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  87.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3250|  87.5k|    }
 3251|  4.56M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE11iterator_atEm:
 3671|  4.39M|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3672|  4.39M|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3673|  4.39M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7hash_ofImEEmRKT_:
 3349|  4.85M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3350|  4.85M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3351|  4.85M|                                               common().seed().seed()}(key);
 3352|  4.85M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8hash_refEv:
 3769|  5.22M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE3endEv:
 2577|  5.02M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2578|  5.02M|    AssertNotDebugCapacity();
 2579|  5.02M|    return iterator(common().generation_ptr());
 2580|  5.02M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorC2EPKh:
 2257|  5.02M|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026052618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorESD_:
 2229|  4.51M|    friend bool operator!=(const iterator& a, const iterator& b) {
 2230|  4.51M|      return !(a == b);
 2231|  4.51M|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorESD_:
 2222|  4.56M|    friend bool operator==(const iterator& a, const iterator& b) {
 2223|  4.56M|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 2224|  4.56M|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 2225|  4.56M|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 2226|  4.56M|                          a.generation_ptr(), b.generation_ptr());
 2227|  4.56M|      return a.ctrl_ == b.ctrl_;
 2228|  4.56M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratorptEv:
 2201|  4.05M|    pointer operator->() const {
 2202|  4.05M|      assert_is_full("operator->");
 2203|  4.05M|      return &operator*();
 2204|  4.05M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iterator14assert_is_fullEPKc:
 2259|  8.16M|    void assert_is_full(const char* operation) const {
 2260|  8.16M|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2261|  8.16M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iteratordeEv:
 2195|  4.05M|    reference operator*() const {
 2196|  4.05M|      assert_is_full("operator*()");
 2197|  4.05M|      return unchecked_deref();
 2198|  4.05M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iterator15unchecked_derefEv:
 2282|  4.05M|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE6insertINSt3__14pairIKmS8_EELi0EEENSD_INSA_8iteratorEbEERKT_:
 2684|   293k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2685|   293k|    return emplace(value);
 2686|   293k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7emplaceIJRKNSt3__14pairIKmS8_EEETnNSC_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSD_INSA_8iteratorEbEEDpOSJ_:
 2799|   293k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2800|   293k|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2801|   293k|                               std::forward<Args>(args)...);
 2802|   293k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE19EmplaceDecomposableclImJRKNSt3__121piecewise_construct_tENSD_5tupleIJRKmEEENSH_IJRKS8_EEEEEENSD_4pairINSA_8iteratorEbEERKT_DpOT0_:
 3177|   293k|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 3178|   293k|      auto res = s.find_or_prepare_insert(key);
 3179|   293k|      if (res.second) {
  ------------------
  |  Branch (3179:11): [True: 293k, False: 0]
  ------------------
 3180|   293k|        s.emplace_at(res.first, std::forward<Args>(args)...);
 3181|   293k|      }
 3182|   293k|      return res;
 3183|   293k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE22find_or_prepare_insertImEENSt3__14pairINSA_8iteratorEbEERKT_:
 3646|   293k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3647|   293k|    AssertOnFind(key);
 3648|   293k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3648:9): [True: 2.84k, False: 290k]
  ------------------
 3649|   290k|    return find_or_prepare_insert_large(key);
 3650|   293k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE28find_or_prepare_insert_smallImEENSt3__14pairINSA_8iteratorEbEERKT_:
 3497|  2.84k|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3498|  2.84k|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|  2.84k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3499|  2.84k|    if constexpr (SooEnabled()) {
 3500|  2.84k|      return find_or_prepare_insert_soo(key);
 3501|  2.84k|    }
 3502|  2.84k|    if (!empty()) {
  ------------------
  |  Branch (3502:9): [True: 0, False: 2.84k]
  ------------------
 3503|      0|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3503:11): [True: 0, False: 0]
  ------------------
 3504|      0|        return {single_iterator(), false};
 3505|      0|      }
 3506|      0|    }
 3507|  2.84k|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3508|  2.84k|                common(), GetPolicyFunctions(),
 3509|  2.84k|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3510|  2.84k|            true};
 3511|  2.84k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE26find_or_prepare_insert_sooImEENSt3__14pairINSA_8iteratorEbEERKT_:
 3471|  2.84k|  std::pair<iterator, bool> find_or_prepare_insert_soo(const K& key) {
 3472|  2.84k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  256|  2.84k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3473|  2.84k|    bool force_sampling;
 3474|  2.84k|    if (empty()) {
  ------------------
  |  Branch (3474:9): [True: 1.42k, False: 1.42k]
  ------------------
 3475|  1.42k|      if (!should_sample_soo()) {
  ------------------
  |  Branch (3475:11): [True: 1.42k, False: 0]
  ------------------
 3476|  1.42k|        common().set_full_soo();
 3477|  1.42k|        return {single_iterator(), true};
 3478|  1.42k|      }
 3479|      0|      force_sampling = true;
 3480|  1.42k|    } else if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3480:16): [True: 0, False: 1.42k]
  ------------------
 3481|      0|      return {single_iterator(), false};
 3482|  1.42k|    } else {
 3483|  1.42k|      force_sampling = false;
 3484|  1.42k|    }
 3485|  1.42k|    ABSL_SWISSTABLE_ASSERT(capacity() == 1);
  ------------------
  |  |  256|  1.42k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3486|  1.42k|    constexpr bool kUseMemcpy =
 3487|  1.42k|        PolicyTraits::transfer_uses_memcpy() && SooEnabled();
  ------------------
  |  Branch (3487:9): [True: 0, Folded]
  |  Branch (3487:49): [True: 0, Folded]
  ------------------
 3488|  1.42k|    size_t index = GrowSooTableToNextCapacityAndPrepareInsert<
 3489|  1.42k|        kUseMemcpy ? OptimalMemcpySizeForSooSlotTransfer(sizeof(slot_type)) : 0,
 3490|  1.42k|        kUseMemcpy>(common(), GetPolicyFunctions(),
 3491|  1.42k|                    HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key},
 3492|  1.42k|                    force_sampling);
 3493|  1.42k|    return {iterator_at(index), true};
 3494|  2.84k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE17should_sample_sooEv:
 3259|  1.42k|  bool should_sample_soo() {
 3260|  1.42k|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  256|  1.42k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3261|       |    if constexpr (!ShouldSampleHashtablezInfoForAlloc<CharAlloc>()) {
 3262|       |      return false;
 3263|       |    }
 3264|  1.42k|    if (common().soo_has_tried_sampling()) {
  ------------------
  |  Branch (3264:9): [True: 0, False: 1.42k]
  ------------------
 3265|       |      // Already evaluated sampling on this SOO table; do not re-evaluate
 3266|       |      // sampling each time it transitions from empty to full SOO state.
 3267|      0|      return false;
 3268|      0|    }
 3269|       |    // TODO: b/396049910 -- consider managing this flag on the 1->0 size
 3270|       |    // transition of SOO tables rather than the 0->1 transition.
 3271|  1.42k|    common().set_soo_has_tried_sampling();
 3272|  1.42k|    return ABSL_PREDICT_FALSE(ShouldSampleNextTable());
  ------------------
  |  |  190|  1.42k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:49): [Folded, False: 1.42k]
  |  |  |  Branch (190:58): [True: 0, False: 1.42k]
  |  |  ------------------
  ------------------
 3273|  1.42k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE18GetPolicyFunctionsEv:
 3851|   293k|  static const PolicyFunctions& GetPolicyFunctions() {
 3852|   293k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3853|   293k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3854|   293k|                  "or use absl::node_hash_{map,set}.");
 3855|   293k|    static_assert(alignof(slot_type) <=
 3856|   293k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3857|   293k|    static_assert(sizeof(key_type) <=
 3858|   293k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3859|   293k|    static_assert(sizeof(value_type) <=
 3860|   293k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3861|   293k|    static constexpr size_t kBackingArrayAlignment =
 3862|   293k|        BackingArrayAlignment(alignof(slot_type));
 3863|   293k|    static constexpr PolicyFunctions value = {
 3864|   293k|        static_cast<uint32_t>(sizeof(key_type)),
 3865|   293k|        static_cast<uint32_t>(sizeof(value_type)),
 3866|   293k|        static_cast<uint32_t>(sizeof(slot_type)),
 3867|   293k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3868|   293k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3869|       |        // TODO(b/328722020): try to type erase
 3870|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3871|   293k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3871:9): [True: 0, Folded]
  ------------------
 3872|   293k|                                : &raw_hash_set::get_hash_ref_fn,
 3873|   293k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3874|   293k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3874:9): [True: 0, Folded]
  ------------------
 3875|   293k|            ? TransferNRelocatable<sizeof(slot_type)>
 3876|   293k|            : &raw_hash_set::transfer_n_slots_fn,
 3877|   293k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3877:9): [True: 0, Folded]
  ------------------
 3878|   293k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3879|   293k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3880|   293k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3881|   293k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3882|   293k|    return value;
 3883|   293k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSG_PFvSG_hmmE:
 3804|  3.92k|                                    size_t source_offset, size_t h1)) {
 3805|  3.92k|    const size_t new_capacity = common.capacity();
 3806|  3.92k|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3807|  3.92k|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  271|  3.92k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3808|  3.92k|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  271|  3.92k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3809|       |
 3810|  3.92k|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3811|  3.92k|    slot_type* old_slots_ptr = to_slot(old_slots);
 3812|  3.92k|    ctrl_t* new_ctrl = common.control();
 3813|  3.92k|    slot_type* new_slots = set->slot_array();
 3814|       |
 3815|  30.6k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3815:34): [True: 26.7k, False: 3.92k]
  ------------------
 3816|  26.7k|         group_index += Group::kWidth) {
 3817|  26.7k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3818|  26.7k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3819|  26.7k|                  Group::kWidth);
 3820|  26.7k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3821|  26.7k|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3822|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3823|       |      // We will share a lot of code in expense of one function call per group.
 3824|   372k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3824:38): [True: 372k, False: 26.7k]
  ------------------
 3825|   372k|        size_t old_index = group_index + in_fixed_group_index;
 3826|   372k|        slot_type* old_slot = old_slots_ptr + old_index;
 3827|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3828|       |        // only one new bit of h1.
 3829|   372k|        size_t hash = set->hash_of(old_slot);
 3830|   372k|        size_t h1 = H1(hash);
 3831|   372k|        h2_t h2 = H2(hash);
 3832|   372k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3833|   372k|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3834|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3835|       |        // till and included the old_index.
 3836|   372k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  190|   372k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 2.47k, False: 370k]
  |  |  |  Branch (190:49): [Folded, False: 372k]
  |  |  |  Branch (190:58): [True: 2.47k, False: 370k]
  |  |  ------------------
  ------------------
 3837|  2.47k|          encode_probed_element(probed_storage, h2, old_index, h1);
 3838|  2.47k|          continue;
 3839|  2.47k|        }
 3840|   370k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  256|   370k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3841|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  256|   370k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3842|   370k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3843|   370k|        auto* new_slot = new_slots + new_index;
 3844|   370k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3845|   370k|        set->transfer(new_slot, old_slot);
 3846|   370k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3847|   370k|      }
 3848|  26.7k|    }
 3849|  3.92k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7to_slotEPv:
 3361|  3.92k|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3362|  3.92k|    return static_cast<slot_type*>(buf);
 3363|  3.92k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE7hash_ofEPNS1_13map_slot_typeImS8_EE:
 3353|   372k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3354|   372k|    return PolicyTraits::apply(
 3355|   372k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3356|   372k|        PolicyTraits::element(slot));
 3357|   372k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8transferEPNS1_13map_slot_typeImS8_EESD_:
 3217|   370k|  inline void transfer(slot_type* to, slot_type* from) {
 3218|   370k|    common().RunWithReentrancyGuard([&] {
 3219|   370k|      allocator_type alloc(char_alloc_ref());
 3220|   370k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   370k|    });
 3222|   370k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8transferEPNS1_13map_slot_typeImSA_EESF_EUlvE_EEvT_:
 1322|   370k|  void RunWithReentrancyGuard(F f) {
 1323|   370k|#ifdef NDEBUG
 1324|   370k|    f();
 1325|   370k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8transferEPNS1_13map_slot_typeImS8_EESD_ENKUlvE_clEv:
 3218|   370k|    common().RunWithReentrancyGuard([&] {
 3219|   370k|      allocator_type alloc(char_alloc_ref());
 3220|   370k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   370k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8hash_refEv:
 3768|  1.42k|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE28find_or_prepare_insert_largeImEENSt3__14pairINSA_8iteratorEbEERKT_:
 3514|   290k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3515|   290k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   290k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3516|   290k|    prefetch_heap_block();
 3517|   290k|    const size_t hash = hash_of(key);
 3518|   290k|    auto seq = probe(common(), hash);
 3519|   290k|    const h2_t h2 = H2(hash);
 3520|   290k|    const ctrl_t* ctrl = control();
 3521|   290k|    size_t index;
 3522|   290k|    bool inserted;
 3523|       |    // We use a lambda function to be able to exit from the nested loop without
 3524|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3525|   290k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   290k|      while (true) {
 3527|   290k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   290k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   290k|#endif
 3530|   290k|        Group g{ctrl + seq.offset()};
 3531|   290k|        for (uint32_t i : g.Match(h2)) {
 3532|   290k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3533|   290k|            index = seq.offset(i);
 3534|   290k|            inserted = false;
 3535|   290k|            return;
 3536|   290k|          }
 3537|   290k|        }
 3538|   290k|        auto mask_empty = g.MaskEmpty();
 3539|   290k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3540|   290k|          size_t target_group_offset = seq.offset();
 3541|   290k|          index = SwisstableGenerationsEnabled()
 3542|   290k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|   290k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|   290k|                            FindInfo{target_group_offset, seq.index()},
 3545|   290k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   290k|                      : PrepareInsertLarge(
 3547|   290k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   290k|                            FindInfo{target_group_offset, seq.index()});
 3549|   290k|          inserted = true;
 3550|   290k|          return;
 3551|   290k|        }
 3552|   290k|        seq.next();
 3553|   290k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3554|   290k|      }
 3555|   290k|    }();
 3556|   290k|    return {iterator_at(index), inserted};
 3557|   290k|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE28find_or_prepare_insert_largeImEENSt3__14pairINSA_8iteratorEbEERKT_ENKUlvE_clEv:
 3525|   290k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   319k|      while (true) {
  ------------------
  |  Branch (3526:14): [True: 319k, Folded]
  ------------------
 3527|   319k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   319k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   319k|#endif
 3530|   319k|        Group g{ctrl + seq.offset()};
 3531|   319k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3531:25): [True: 25.0k, False: 319k]
  ------------------
 3532|  25.0k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  191|  25.0k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 25.0k]
  |  |  |  Branch (191:48): [Folded, False: 25.0k]
  |  |  |  Branch (191:57): [True: 0, False: 25.0k]
  |  |  ------------------
  ------------------
 3533|      0|            index = seq.offset(i);
 3534|      0|            inserted = false;
 3535|      0|            return;
 3536|      0|          }
 3537|  25.0k|        }
 3538|   319k|        auto mask_empty = g.MaskEmpty();
 3539|   319k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|   319k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 290k, False: 28.6k]
  |  |  |  Branch (191:48): [Folded, False: 319k]
  |  |  |  Branch (191:57): [True: 290k, False: 28.6k]
  |  |  ------------------
  ------------------
 3540|   290k|          size_t target_group_offset = seq.offset();
 3541|   290k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3541:19): [Folded, False: 290k]
  ------------------
 3542|   290k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|      0|                            FindInfo{target_group_offset, seq.index()},
 3545|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   290k|                      : PrepareInsertLarge(
 3547|   290k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   290k|                            FindInfo{target_group_offset, seq.index()});
 3549|   290k|          inserted = true;
 3550|   290k|          return;
 3551|   290k|        }
 3552|  28.6k|        seq.next();
 3553|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  28.6k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3554|  28.6k|      }
 3555|   290k|    }();
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE10emplace_atIJRKNSt3__121piecewise_construct_tENSC_5tupleIJRKmEEENSG_IJRKS8_EEEEEEvNSA_8iteratorEDpOT_:
 3661|   293k|  void emplace_at(iterator iter, Args&&... args) {
 3662|   293k|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|   293k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|   293k|           "constructed value does not match the lookup key");
 3669|   293k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSC_5tupleIJRKmEEENSG_IJRKS8_EEEEEEvPNS1_13map_slot_typeImS8_EEDpOT_:
 3205|   293k|  inline void construct(slot_type* slot, Args&&... args) {
 3206|   293k|    common().RunWithReentrancyGuard([&] {
 3207|   293k|      allocator_type alloc(char_alloc_ref());
 3208|   293k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   293k|    });
 3210|   293k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSE_5tupleIJRKmEEENSI_IJRKSA_EEEEEEvPNS1_13map_slot_typeImSA_EEDpOT_EUlvE_EEvT_:
 1322|   293k|  void RunWithReentrancyGuard(F f) {
 1323|   293k|#ifdef NDEBUG
 1324|   293k|    f();
 1325|   293k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSC_5tupleIJRKmEEENSG_IJRKS8_EEEEEEvPNS1_13map_slot_typeImS8_EEDpOT_ENKUlvE_clEv:
 3206|   293k|    common().RunWithReentrancyGuard([&] {
 3207|   293k|      allocator_type alloc(char_alloc_ref());
 3208|   293k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   293k|    });
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iterator4slotEv:
 2285|   340k|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE5eraseImEEmRKm:
 2894|  47.5k|  size_type erase(const key_arg<K>& key) {
 2895|  47.5k|    auto it = find(key);
 2896|  47.5k|    if (it == end()) return 0;
  ------------------
  |  Branch (2896:9): [True: 0, False: 47.5k]
  ------------------
 2897|  47.5k|    erase(it);
 2898|  47.5k|    return 1;
 2899|  47.5k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE5eraseENSA_8iteratorE:
 2909|  47.5k|  void erase(iterator it) {
 2910|       |    ABSL_SWISSTABLE_ASSERT(capacity() > 0);
  ------------------
  |  |  256|  47.5k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2911|  47.5k|    AssertNotDebugCapacity();
 2912|  47.5k|    it.assert_is_full("erase()");
 2913|  47.5k|    destroy(it.slot());
 2914|  47.5k|    erase_meta_only(it);
 2915|  47.5k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE15erase_meta_onlyENSA_14const_iteratorE:
 3328|  47.5k|  void erase_meta_only(const_iterator it) {
 3329|  47.5k|    if (is_small()) {
  ------------------
  |  Branch (3329:9): [True: 0, False: 47.5k]
  ------------------
 3330|      0|      erase_meta_only_small();
 3331|      0|      return;
 3332|      0|    }
 3333|  47.5k|    erase_meta_only_large(it);
 3334|  47.5k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE21erase_meta_only_largeENSA_14const_iteratorE:
 3338|  47.5k|  void erase_meta_only_large(const_iterator it) {
 3339|  47.5k|    EraseMetaOnlyLarge(common(), it.control(), sizeof(slot_type));
 3340|  47.5k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE14const_iterator7controlEv:
 2338|  47.5k|    ctrl_t* control() const { return inner_.control(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE8iterator7controlEv:
 2284|  47.5k|    ctrl_t* control() const { return ctrl_; }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE14const_iteratorC2ENSA_8iteratorE:
 2312|  47.5k|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE5clearEv:
 2614|  2.86k|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2615|  2.86k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (2615:9): [Folded, False: 2.86k]
  |  Branch (2615:9): [Folded, False: 2.86k]
  ------------------
 2616|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (2616:9): [True: 0, False: 0]
  ------------------
 2617|      0|      common().set_capacity(DefaultCapacity());
 2618|      0|    }
 2619|  2.86k|    AssertNotDebugCapacity();
 2620|       |    // Iterating over this container is O(bucket_count()). When bucket_count()
 2621|       |    // is much greater than size(), iteration becomes prohibitively expensive.
 2622|       |    // For clear() it is more important to reuse the allocated array when the
 2623|       |    // container is small because allocation takes comparatively long time
 2624|       |    // compared to destruction of the elements of the container. So we pick the
 2625|       |    // largest bucket_count() threshold for which iteration is still fast and
 2626|       |    // past that we simply deallocate the array.
 2627|  2.86k|    const size_t cap = capacity();
 2628|  2.86k|    if (cap == 0) {
  ------------------
  |  Branch (2628:9): [True: 0, False: 2.86k]
  ------------------
 2629|       |      // Already guaranteed to be empty; so nothing to do.
 2630|  2.86k|    } else if (is_small()) {
  ------------------
  |  Branch (2630:16): [True: 1.44k, False: 1.42k]
  ------------------
 2631|  1.44k|      if (!empty()) {
  ------------------
  |  Branch (2631:11): [True: 0, False: 1.44k]
  ------------------
 2632|      0|        destroy(single_slot());
 2633|      0|        decrement_small_size();
 2634|      0|      }
 2635|  1.44k|    } else {
 2636|  1.42k|      destroy_slots();
 2637|  1.42k|      clear_backing_array(/*reuse=*/cap < 128);
 2638|  1.42k|    }
 2639|  2.86k|    common().set_reserved_growth(0);
 2640|  2.86k|    common().set_reservation_size(0);
 2641|  2.86k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyImPN13sentencepiece3bpe7Trainer6SymbolEEEJEE19clear_backing_arrayEb:
 3275|  1.42k|  void clear_backing_array(bool reuse) {
 3276|       |    ABSL_SWISSTABLE_ASSERT(capacity() > MaxSmallCapacity());
  ------------------
  |  |  256|  1.42k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3277|  1.42k|    ClearBackingArray(common(), GetPolicyFunctions(), &char_alloc_ref(), reuse);
 3278|  1.42k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE6insertEOSA_:
 2707|  47.5k|  {
 2708|  47.5k|    return emplace(std::move(value));
 2709|  47.5k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE7emplaceIJSA_ETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENS4_4pairINSC_8iteratorEbEEDpOSF_:
 2799|  47.5k|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2800|  47.5k|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2801|  47.5k|                               std::forward<Args>(args)...);
 2802|  47.5k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE19EmplaceDecomposableclISA_JSA_EEENS4_4pairINSC_8iteratorEbEERKT_DpOT0_:
 3177|  47.5k|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 3178|  47.5k|      auto res = s.find_or_prepare_insert(key);
 3179|  47.5k|      if (res.second) {
  ------------------
  |  Branch (3179:11): [True: 47.5k, False: 0]
  ------------------
 3180|  47.5k|        s.emplace_at(res.first, std::forward<Args>(args)...);
 3181|  47.5k|      }
 3182|  47.5k|      return res;
 3183|  47.5k|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE10emplace_atIJSA_EEEvNSC_8iteratorEDpOT_:
 3661|  47.5k|  void emplace_at(iterator iter, Args&&... args) {
 3662|  47.5k|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|  47.5k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|  47.5k|           "constructed value does not match the lookup key");
 3669|  47.5k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE9constructIJSA_EEEvPSA_DpOT_:
 3205|  47.5k|  inline void construct(slot_type* slot, Args&&... args) {
 3206|  47.5k|    common().RunWithReentrancyGuard([&] {
 3207|  47.5k|      allocator_type alloc(char_alloc_ref());
 3208|  47.5k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|  47.5k|    });
 3210|  47.5k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEE9constructIJSC_EEEvPSC_DpOT_EUlvE_EEvT_:
 1322|  47.5k|  void RunWithReentrancyGuard(F f) {
 1323|  47.5k|#ifdef NDEBUG
 1324|  47.5k|    f();
 1325|  47.5k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashSetPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEJEE9constructIJSA_EEEvPSA_DpOT_ENKUlvE_clEv:
 3206|  47.5k|    common().RunWithReentrancyGuard([&] {
 3207|  47.5k|      allocator_type alloc(char_alloc_ref());
 3208|  47.5k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|  47.5k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEEC2Ev:
 2352|      1|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE15unchecked_derefENS8_8iteratorE:
 3682|   128k|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iterator15unchecked_derefEv:
 2282|  39.2M|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE22find_or_prepare_insertIDiEENSt3__14pairINS8_8iteratorEbEERKT_:
 3646|   128k|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3647|   128k|    AssertOnFind(key);
 3648|   128k|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3648:9): [True: 2, False: 128k]
  ------------------
 3649|   128k|    return find_or_prepare_insert_large(key);
 3650|   128k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE12AssertOnFindIDiEEvRKT_:
 3567|  40.4M|  void AssertOnFind([[maybe_unused]] const K& key) {
 3568|  40.4M|    AssertHashEqConsistent(key);
 3569|  40.4M|    AssertNotDebugCapacity();
 3570|  40.4M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE22AssertHashEqConsistentIDiEEvRKT_:
 3605|  40.4M|  void AssertHashEqConsistent(const K& key) {
 3606|  40.4M|#ifdef NDEBUG
 3607|  40.4M|    return;
 3608|      0|#endif
 3609|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3610|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3610:9): [Folded, False: 0]
  ------------------
 3611|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3611:9): [Folded, False: 0]
  ------------------
 3612|      0|      return;
 3613|      0|    }
 3614|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3614:9): [True: 0, Folded]
  ------------------
 3615|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3615:9): [True: 0, Folded]
  ------------------
 3616|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3616:9): [True: 0, Folded]
  ------------------
 3617|      0|      return;
 3618|      0|    }
 3619|      0|    if (empty()) return;
  ------------------
  |  Branch (3619:9): [True: 0, False: 0]
  ------------------
 3620|       |
 3621|      0|    const size_t hash_of_arg = hash_of(key);
 3622|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3623|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3624|      0|      if (!is_key_equal) return;
 3625|       |
 3626|      0|      [[maybe_unused]] const bool is_hash_equal =
 3627|      0|          hash_of_arg == hash_of(to_slot(slot));
 3628|      0|      assert((!is_key_equal || is_hash_equal) &&
 3629|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3630|      0|             "hash/eq functors are inconsistent.");
 3631|      0|    };
 3632|       |
 3633|      0|    if (is_small()) {
  ------------------
  |  Branch (3633:9): [True: 0, False: 0]
  ------------------
 3634|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3635|      0|      return;
 3636|      0|    }
 3637|       |    // We only do validation for small tables so that it's constant time.
 3638|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3638:9): [True: 0, False: 0]
  ------------------
 3639|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3640|      0|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE22AssertNotDebugCapacityEv:
 3573|  81.9M|  void AssertNotDebugCapacity() const {
 3574|  81.9M|#ifdef NDEBUG
 3575|  81.9M|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3575:9): [True: 81.9M, Folded]
  ------------------
 3576|  81.9M|      return;
 3577|  81.9M|    }
 3578|      0|#endif
 3579|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 3580|      0|    if (ABSL_PREDICT_TRUE(cap.IsValid())) {
  ------------------
  |  |  191|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 0]
  |  |  |  Branch (191:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3581|      0|      return;
 3582|      0|    }
 3583|      0|    assert(!cap.IsReentrance() &&
 3584|      0|           "Reentrant container access during element construction/destruction "
 3585|      0|           "is not allowed.");
 3586|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3587|       |      if (cap.IsDestroyed()) {
 3588|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3589|       |      }
 3590|       |    }
 3591|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3591:9): [Folded, False: 0]
  ------------------
 3592|      0|        ABSL_PREDICT_FALSE(cap.IsMovedFrom())) {
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 0]
  |  |  |  Branch (190:49): [Folded, False: 0]
  |  |  |  Branch (190:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3593|      0|      if (cap.IsSelfMovedFrom()) {
  ------------------
  |  Branch (3593:11): [True: 0, False: 0]
  ------------------
 3594|       |        // If this log triggers, then a hash table was move-assigned to itself
 3595|       |        // and then used again later without being reinitialized.
 3596|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3597|      0|      }
 3598|      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()
  |  |  |  |  ------------------
  |  |  |  |  |  |  237|      0|  do {                                           \
  |  |  |  |  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  241|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3599|      0|    }
 3600|      0|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8is_smallEv:
 2117|  40.4M|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE6commonEv:
 3719|   320M|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE28find_or_prepare_insert_smallIDiEENSt3__14pairINS8_8iteratorEbEERKT_:
 3497|      2|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3498|      2|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3499|      2|    if constexpr (SooEnabled()) {
 3500|      2|      return find_or_prepare_insert_soo(key);
 3501|      2|    }
 3502|      2|    if (!empty()) {
  ------------------
  |  Branch (3502:9): [True: 0, False: 2]
  ------------------
 3503|      0|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3503:11): [True: 0, False: 0]
  ------------------
 3504|      0|        return {single_iterator(), false};
 3505|      0|      }
 3506|      0|    }
 3507|      2|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3508|      2|                common(), GetPolicyFunctions(),
 3509|      2|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3510|      2|            true};
 3511|      2|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE26find_or_prepare_insert_sooIDiEENSt3__14pairINS8_8iteratorEbEERKT_:
 3471|      2|  std::pair<iterator, bool> find_or_prepare_insert_soo(const K& key) {
 3472|      2|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  256|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3473|      2|    bool force_sampling;
 3474|      2|    if (empty()) {
  ------------------
  |  Branch (3474:9): [True: 1, False: 1]
  ------------------
 3475|      1|      if (!should_sample_soo()) {
  ------------------
  |  Branch (3475:11): [True: 1, False: 0]
  ------------------
 3476|      1|        common().set_full_soo();
 3477|      1|        return {single_iterator(), true};
 3478|      1|      }
 3479|      0|      force_sampling = true;
 3480|      1|    } else if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3480:16): [True: 0, False: 1]
  ------------------
 3481|      0|      return {single_iterator(), false};
 3482|      1|    } else {
 3483|      1|      force_sampling = false;
 3484|      1|    }
 3485|      1|    ABSL_SWISSTABLE_ASSERT(capacity() == 1);
  ------------------
  |  |  256|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3486|      1|    constexpr bool kUseMemcpy =
 3487|      1|        PolicyTraits::transfer_uses_memcpy() && SooEnabled();
  ------------------
  |  Branch (3487:9): [True: 0, Folded]
  |  Branch (3487:49): [True: 0, Folded]
  ------------------
 3488|      1|    size_t index = GrowSooTableToNextCapacityAndPrepareInsert<
 3489|      1|        kUseMemcpy ? OptimalMemcpySizeForSooSlotTransfer(sizeof(slot_type)) : 0,
 3490|      1|        kUseMemcpy>(common(), GetPolicyFunctions(),
 3491|      1|                    HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key},
 3492|      1|                    force_sampling);
 3493|      1|    return {iterator_at(index), true};
 3494|      2|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE5emptyEv:
 2593|      2|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE4sizeEv:
 2594|      2|  size_t size() const {
 2595|      2|    AssertNotDebugCapacity();
 2596|      2|    const size_t size = common().size();
 2597|      2|    [[maybe_unused]] const size_t kMaxValidSize = MaxValidSize();
 2598|      2|    ABSL_ASSUME(size <= kMaxValidSize);
  ------------------
  |  |  271|      2|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2599|      2|    return size;
 2600|      2|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE17should_sample_sooEv:
 3259|      1|  bool should_sample_soo() {
 3260|      1|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  256|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3261|       |    if constexpr (!ShouldSampleHashtablezInfoForAlloc<CharAlloc>()) {
 3262|       |      return false;
 3263|       |    }
 3264|      1|    if (common().soo_has_tried_sampling()) {
  ------------------
  |  Branch (3264:9): [True: 0, False: 1]
  ------------------
 3265|       |      // Already evaluated sampling on this SOO table; do not re-evaluate
 3266|       |      // sampling each time it transitions from empty to full SOO state.
 3267|      0|      return false;
 3268|      0|    }
 3269|       |    // TODO: b/396049910 -- consider managing this flag on the 1->0 size
 3270|       |    // transition of SOO tables rather than the 0->1 transition.
 3271|      1|    common().set_soo_has_tried_sampling();
 3272|      1|    return ABSL_PREDICT_FALSE(ShouldSampleNextTable());
  ------------------
  |  |  190|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:49): [Folded, False: 1]
  |  |  |  Branch (190:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 3273|      1|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE6commonEv:
 3718|   121M|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE15single_iteratorEv:
 3757|      1|  iterator single_iterator() {
 3758|      1|    return {SooControl(), single_slot(), common().generation_ptr()};
 3759|      1|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIDiS6_EEPKh:
 2236|  39.2M|        : HashSetIteratorGenerationInfo(generation_ptr),
 2237|  39.2M|          ctrl_(ctrl),
 2238|  39.2M|          slot_(slot) {
 2239|       |      // This assumption helps the compiler know that any non-end iterator is
 2240|       |      // not equal to any end iterator.
 2241|  39.2M|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  271|  39.2M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2242|  39.2M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8equal_toIDiEEbRKT_PNS1_13map_slot_typeIDiS6_EE:
 3344|  39.1M|                                             slot_type* slot) const {
 3345|  39.1M|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3346|  39.1M|                               PolicyTraits::element(slot));
 3347|  39.1M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE6eq_refEv:
 3771|  39.1M|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE11single_slotEv:
 3743|      2|  slot_type* single_slot() {
 3744|      2|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  256|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3745|      2|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3745:12): [True: 2, Folded]
  ------------------
 3746|      2|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8soo_slotEv:
 3734|      2|  slot_type* soo_slot() {
 3735|      2|    ABSL_SWISSTABLE_ASSERT(is_soo());
  ------------------
  |  |  256|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3736|      2|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(
  ------------------
  |  |  488|      2|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
 3737|      2|        static_cast<slot_type*>(common().soo_data()));
 3738|      2|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE18GetPolicyFunctionsEv:
 3851|   128k|  static const PolicyFunctions& GetPolicyFunctions() {
 3852|   128k|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3853|   128k|                  "Slot size is too large. Use std::unique_ptr for value type "
 3854|   128k|                  "or use absl::node_hash_{map,set}.");
 3855|   128k|    static_assert(alignof(slot_type) <=
 3856|   128k|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3857|   128k|    static_assert(sizeof(key_type) <=
 3858|   128k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3859|   128k|    static_assert(sizeof(value_type) <=
 3860|   128k|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3861|   128k|    static constexpr size_t kBackingArrayAlignment =
 3862|   128k|        BackingArrayAlignment(alignof(slot_type));
 3863|   128k|    static constexpr PolicyFunctions value = {
 3864|   128k|        static_cast<uint32_t>(sizeof(key_type)),
 3865|   128k|        static_cast<uint32_t>(sizeof(value_type)),
 3866|   128k|        static_cast<uint32_t>(sizeof(slot_type)),
 3867|   128k|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3868|   128k|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3869|       |        // TODO(b/328722020): try to type erase
 3870|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3871|   128k|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3871:9): [True: 0, Folded]
  ------------------
 3872|   128k|                                : &raw_hash_set::get_hash_ref_fn,
 3873|   128k|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3874|   128k|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3874:9): [True: 0, Folded]
  ------------------
 3875|   128k|            ? TransferNRelocatable<sizeof(slot_type)>
 3876|   128k|            : &raw_hash_set::transfer_n_slots_fn,
 3877|   128k|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3877:9): [True: 0, Folded]
  ------------------
 3878|   128k|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3879|   128k|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3880|   128k|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3881|   128k|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3882|   128k|    return value;
 3883|   128k|  }
_ZN4absl12lts_2026052618container_internal20TransferNRelocatableILm8EEEvPvS3_S3_m:
 1955|     11|                                                  size_t count) {
 1956|       |  // TODO(b/382423690): Experiment with making specialization for power of 2 and
 1957|       |  // non power of 2. This would require passing the size of the slot.
 1958|     11|  memcpy(dst, src, SizeOfSlot * count);
 1959|     11|}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSE_PFvSE_hmmE:
 3804|     14|                                    size_t source_offset, size_t h1)) {
 3805|     14|    const size_t new_capacity = common.capacity();
 3806|     14|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3807|     14|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  271|     14|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3808|     14|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  271|     14|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3809|       |
 3810|     14|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3811|     14|    slot_type* old_slots_ptr = to_slot(old_slots);
 3812|     14|    ctrl_t* new_ctrl = common.control();
 3813|     14|    slot_type* new_slots = set->slot_array();
 3814|       |
 3815|  16.3k|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3815:34): [True: 16.3k, False: 14]
  ------------------
 3816|  16.3k|         group_index += Group::kWidth) {
 3817|  16.3k|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3818|  16.3k|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3819|  16.3k|                  Group::kWidth);
 3820|  16.3k|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3821|  16.3k|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3822|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3823|       |      // We will share a lot of code in expense of one function call per group.
 3824|   229k|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3824:38): [True: 229k, False: 16.3k]
  ------------------
 3825|   229k|        size_t old_index = group_index + in_fixed_group_index;
 3826|   229k|        slot_type* old_slot = old_slots_ptr + old_index;
 3827|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3828|       |        // only one new bit of h1.
 3829|   229k|        size_t hash = set->hash_of(old_slot);
 3830|   229k|        size_t h1 = H1(hash);
 3831|   229k|        h2_t h2 = H2(hash);
 3832|   229k|        size_t new_index = TryFindNewIndexWithoutProbing(
 3833|   229k|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3834|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3835|       |        // till and included the old_index.
 3836|   229k|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  190|   229k|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 9, False: 229k]
  |  |  |  Branch (190:49): [Folded, False: 229k]
  |  |  |  Branch (190:58): [True: 9, False: 229k]
  |  |  ------------------
  ------------------
 3837|      9|          encode_probed_element(probed_storage, h2, old_index, h1);
 3838|      9|          continue;
 3839|      9|        }
 3840|   229k|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  256|   229k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3841|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  256|   229k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3842|   229k|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3843|   229k|        auto* new_slot = new_slots + new_index;
 3844|   229k|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3845|   229k|        set->transfer(new_slot, old_slot);
 3846|   229k|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3847|   229k|      }
 3848|  16.3k|    }
 3849|     14|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE7to_slotEPv:
 3361|     14|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3362|     14|    return static_cast<slot_type*>(buf);
 3363|     14|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE10slot_arrayEv:
 3730|   118M|  slot_type* slot_array() const {
 3731|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   118M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3732|   118M|    return static_cast<slot_type*>(common().slot_array());
 3733|   118M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE7hash_ofEPNS1_13map_slot_typeIDiS6_EE:
 3353|   229k|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3354|   229k|    return PolicyTraits::apply(
 3355|   229k|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3356|   229k|        PolicyTraits::element(slot));
 3357|   229k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8hash_refEv:
 3769|  40.6M|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8transferEPNS1_13map_slot_typeIDiS6_EESB_:
 3217|   229k|  inline void transfer(slot_type* to, slot_type* from) {
 3218|   229k|    common().RunWithReentrancyGuard([&] {
 3219|   229k|      allocator_type alloc(char_alloc_ref());
 3220|   229k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   229k|    });
 3222|   229k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8transferEPNS1_13map_slot_typeIDiS8_EESD_EUlvE_EEvT_:
 1322|   229k|  void RunWithReentrancyGuard(F f) {
 1323|   229k|#ifdef NDEBUG
 1324|   229k|    f();
 1325|   229k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8transferEPNS1_13map_slot_typeIDiS6_EESB_ENKUlvE_clEv:
 3218|   229k|    common().RunWithReentrancyGuard([&] {
 3219|   229k|      allocator_type alloc(char_alloc_ref());
 3220|   229k|      PolicyTraits::transfer(&alloc, to, from);
 3221|   229k|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE14char_alloc_refEv:
 3772|   357k|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8hash_refEv:
 3768|      1|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE11iterator_atEm:
 3671|  39.2M|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3672|  39.2M|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3673|  39.2M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE7controlEv:
 3726|   120M|  ctrl_t* control() const {
 3727|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   120M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3728|   120M|    return common().control();
 3729|   120M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE28find_or_prepare_insert_largeIDiEENSt3__14pairINS8_8iteratorEbEERKT_:
 3514|   128k|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3515|   128k|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|   128k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3516|   128k|    prefetch_heap_block();
 3517|   128k|    const size_t hash = hash_of(key);
 3518|   128k|    auto seq = probe(common(), hash);
 3519|   128k|    const h2_t h2 = H2(hash);
 3520|   128k|    const ctrl_t* ctrl = control();
 3521|   128k|    size_t index;
 3522|   128k|    bool inserted;
 3523|       |    // We use a lambda function to be able to exit from the nested loop without
 3524|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3525|   128k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   128k|      while (true) {
 3527|   128k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   128k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   128k|#endif
 3530|   128k|        Group g{ctrl + seq.offset()};
 3531|   128k|        for (uint32_t i : g.Match(h2)) {
 3532|   128k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3533|   128k|            index = seq.offset(i);
 3534|   128k|            inserted = false;
 3535|   128k|            return;
 3536|   128k|          }
 3537|   128k|        }
 3538|   128k|        auto mask_empty = g.MaskEmpty();
 3539|   128k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3540|   128k|          size_t target_group_offset = seq.offset();
 3541|   128k|          index = SwisstableGenerationsEnabled()
 3542|   128k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|   128k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|   128k|                            FindInfo{target_group_offset, seq.index()},
 3545|   128k|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   128k|                      : PrepareInsertLarge(
 3547|   128k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   128k|                            FindInfo{target_group_offset, seq.index()});
 3549|   128k|          inserted = true;
 3550|   128k|          return;
 3551|   128k|        }
 3552|   128k|        seq.next();
 3553|   128k|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3554|   128k|      }
 3555|   128k|    }();
 3556|   128k|    return {iterator_at(index), inserted};
 3557|   128k|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE19prefetch_heap_blockEv:
 3711|  40.4M|  void prefetch_heap_block() const {
 3712|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|  40.4M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3713|  40.4M|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3714|  40.4M|    __builtin_prefetch(control(), 0, 1);
 3715|  40.4M|#endif
 3716|  40.4M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE7hash_ofIDiEEmRKT_:
 3349|  40.4M|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3350|  40.4M|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3351|  40.4M|                                               common().seed().seed()}(key);
 3352|  40.4M|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE28find_or_prepare_insert_largeIDiEENSt3__14pairINS8_8iteratorEbEERKT_ENKUlvE_clEv:
 3525|   128k|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3526|   137k|      while (true) {
  ------------------
  |  Branch (3526:14): [True: 137k, Folded]
  ------------------
 3527|   137k|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3528|   137k|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3529|   137k|#endif
 3530|   137k|        Group g{ctrl + seq.offset()};
 3531|   137k|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3531:25): [True: 11.8k, False: 137k]
  ------------------
 3532|  11.8k|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  191|  11.8k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 0, False: 11.8k]
  |  |  |  Branch (191:48): [Folded, False: 11.8k]
  |  |  |  Branch (191:57): [True: 0, False: 11.8k]
  |  |  ------------------
  ------------------
 3533|      0|            index = seq.offset(i);
 3534|      0|            inserted = false;
 3535|      0|            return;
 3536|      0|          }
 3537|  11.8k|        }
 3538|   137k|        auto mask_empty = g.MaskEmpty();
 3539|   137k|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  191|   137k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 128k, False: 9.72k]
  |  |  |  Branch (191:48): [Folded, False: 137k]
  |  |  |  Branch (191:57): [True: 128k, False: 9.72k]
  |  |  ------------------
  ------------------
 3540|   128k|          size_t target_group_offset = seq.offset();
 3541|   128k|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3541:19): [Folded, False: 128k]
  ------------------
 3542|   128k|                      ? PrepareInsertLargeGenerationsEnabled(
 3543|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3544|      0|                            FindInfo{target_group_offset, seq.index()},
 3545|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3546|   128k|                      : PrepareInsertLarge(
 3547|   128k|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3548|   128k|                            FindInfo{target_group_offset, seq.index()});
 3549|   128k|          inserted = true;
 3550|   128k|          return;
 3551|   128k|        }
 3552|  9.72k|        seq.next();
 3553|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|  9.72k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3554|  9.72k|      }
 3555|   128k|    }();
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE10emplace_atIJRKNSt3__121piecewise_construct_tENSA_5tupleIJRKDiEEENSE_IJEEEEEEvNS8_8iteratorEDpOT_:
 3661|   127k|  void emplace_at(iterator iter, Args&&... args) {
 3662|   127k|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|   127k|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|   127k|           "constructed value does not match the lookup key");
 3669|   127k|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSA_5tupleIJRKDiEEENSE_IJEEEEEEvPNS1_13map_slot_typeIDiS6_EEDpOT_:
 3205|   127k|  inline void construct(slot_type* slot, Args&&... args) {
 3206|   127k|    common().RunWithReentrancyGuard([&] {
 3207|   127k|      allocator_type alloc(char_alloc_ref());
 3208|   127k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   127k|    });
 3210|   127k|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSC_5tupleIJRKDiEEENSG_IJEEEEEEvPNS1_13map_slot_typeIDiS8_EEDpOT_EUlvE_EEvT_:
 1322|   127k|  void RunWithReentrancyGuard(F f) {
 1323|   127k|#ifdef NDEBUG
 1324|   127k|    f();
 1325|   127k|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSA_5tupleIJRKDiEEENSE_IJEEEEEEvPNS1_13map_slot_typeIDiS6_EEDpOT_ENKUlvE_clEv:
 3206|   127k|    common().RunWithReentrancyGuard([&] {
 3207|   127k|      allocator_type alloc(char_alloc_ref());
 3208|   127k|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|   127k|    });
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iterator4slotEv:
 2285|   128k|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE10emplace_atIJRKNSt3__121piecewise_construct_tENSA_5tupleIJODiEEENSE_IJEEEEEEvNS8_8iteratorEDpOT_:
 3661|    697|  void emplace_at(iterator iter, Args&&... args) {
 3662|    697|    construct(iter.slot(), std::forward<Args>(args)...);
 3663|       |
 3664|       |    // When is_small, find calls find_small and if size is 0, then it will
 3665|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3666|       |    assert((is_small() ||
 3667|    697|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3668|    697|           "constructed value does not match the lookup key");
 3669|    697|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSA_5tupleIJODiEEENSE_IJEEEEEEvPNS1_13map_slot_typeIDiS6_EEDpOT_:
 3205|    697|  inline void construct(slot_type* slot, Args&&... args) {
 3206|    697|    common().RunWithReentrancyGuard([&] {
 3207|    697|      allocator_type alloc(char_alloc_ref());
 3208|    697|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|    697|    });
 3210|    697|  }
_ZN4absl12lts_2026052618container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSC_5tupleIJODiEEENSG_IJEEEEEEvPNS1_13map_slot_typeIDiS8_EEDpOT_EUlvE_EEvT_:
 1322|    697|  void RunWithReentrancyGuard(F f) {
 1323|    697|#ifdef NDEBUG
 1324|    697|    f();
 1325|    697|    return;
 1326|      0|#endif
 1327|      0|    const HashtableCapacity cap = maybe_invalid_capacity();
 1328|      0|    set_capacity(HashtableCapacity::CreateReentrance());
 1329|      0|    f();
 1330|      0|    set_capacity(cap);
 1331|      0|  }
_ZZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE9constructIJRKNSt3__121piecewise_construct_tENSA_5tupleIJODiEEENSE_IJEEEEEEvPNS1_13map_slot_typeIDiS6_EEDpOT_ENKUlvE_clEv:
 3206|    697|    common().RunWithReentrancyGuard([&] {
 3207|    697|      allocator_type alloc(char_alloc_ref());
 3208|    697|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 3209|    697|    });
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEED2Ev:
 2561|      1|  ~raw_hash_set() {
 2562|      1|    destructor_impl();
 2563|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2564|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 2565|       |    }
 2566|      1|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE15destructor_implEv:
 3307|      1|  void destructor_impl() {
 3308|      1|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3308:9): [Folded, False: 1]
  |  Branch (3308:9): [Folded, False: 1]
  ------------------
 3309|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (3309:9): [True: 0, False: 0]
  ------------------
 3310|      0|      return;
 3311|      0|    }
 3312|      1|    if (capacity() == 0) return;
  ------------------
  |  Branch (3312:9): [True: 0, False: 1]
  ------------------
 3313|      1|    if (is_small()) {
  ------------------
  |  Branch (3313:9): [True: 0, False: 1]
  ------------------
 3314|      0|      if (!empty()) {
  ------------------
  |  Branch (3314:11): [True: 0, False: 0]
  ------------------
 3315|      0|        ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(destroy(single_slot()));
  ------------------
  |  |  487|      0|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED(x) x
  ------------------
 3316|      0|      }
 3317|      0|      if constexpr (SooEnabled()) return;
 3318|      1|    } else {
 3319|      1|      destroy_slots();
 3320|      1|    }
 3321|      0|    dealloc();
 3322|      1|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8capacityEv:
 2601|      3|  size_t capacity() const {
 2602|      3|    const size_t cap = common().capacity();
 2603|       |    // Compiler complains when using functions in ASSUME so use local variables.
 2604|      3|    [[maybe_unused]] const bool kIsValid = IsValidCapacity(cap);
 2605|      3|    [[maybe_unused]] const size_t kDefaultCapacity = DefaultCapacity();
 2606|      3|    [[maybe_unused]] const size_t kMaxValidCapacity = MaxValidCapacity();
 2607|      3|    ABSL_ASSUME(kIsValid || cap == 0);
  ------------------
  |  |  271|      3|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (271:44): [True: 3, False: 0]
  |  |  |  Branch (271:44): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2608|      3|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  271|      3|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2609|      3|    ABSL_ASSUME(cap <= kMaxValidCapacity);
  ------------------
  |  |  271|      3|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2610|      3|    return cap;
 2611|      3|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE13destroy_slotsEv:
 3280|      1|  void destroy_slots() {
 3281|      1|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3282|      1|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (3282:9): [True: 1, Folded]
  ------------------
 3283|      0|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 3284|      0|      this->destroy(static_cast<slot_type*>(slot));
 3285|      0|    };
 3286|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3287|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3288|       |      common().set_capacity(HashtableCapacity::CreateDestroyed());
 3289|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3290|       |      common().set_capacity(common_copy.capacity());
 3291|      0|    } else {
 3292|      0|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3293|      0|    }
 3294|      0|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE7deallocEv:
 3296|      1|  void dealloc() {
 3297|      1|    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  256|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3298|       |    // Unpoison before returning the memory to the allocator.
 3299|      1|    SanitizerUnpoisonMemoryRegion(slot_array(), sizeof(slot_type) * capacity());
 3300|      1|    infoz().Unregister();
 3301|      1|    DeallocateBackingArray<BackingArrayAlignment(alignof(slot_type)),
 3302|      1|                           CharAlloc>(&char_alloc_ref(), capacity(), control(),
 3303|      1|                                      sizeof(slot_type), alignof(slot_type),
 3304|      1|                                      common().has_infoz());
 3305|      1|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE5infozEv:
 3763|      1|  HashtablezInfoHandle infoz() {
 3764|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  256|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3765|      1|    return common().infoz();
 3766|      1|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE4findIDiEENS8_14const_iteratorERKDi:
 3079|  40.3M|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3080|  40.3M|    return const_cast<raw_hash_set*>(this)->find(key);
 3081|  40.3M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE4findIDiEENS8_8iteratorERKDi:
 3064|  40.3M|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3065|  40.3M|    AssertOnFind(key);
 3066|  40.3M|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (3066:9): [True: 0, False: 40.3M]
  ------------------
 3067|  40.3M|    prefetch_heap_block();
 3068|  40.3M|    return find_large(key, hash_of(key));
 3069|  40.3M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE3endEv:
 2577|  41.5M|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2578|  41.5M|    AssertNotDebugCapacity();
 2579|  41.5M|    return iterator(common().generation_ptr());
 2580|  41.5M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iteratorC2EPKh:
 2257|  41.5M|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE10find_largeIDiEENS8_8iteratorERKDim:
 3233|  40.3M|  iterator find_large(const key_arg<K>& key, size_t hash) {
 3234|  40.3M|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  256|  40.3M|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3235|  40.3M|    auto seq = probe(common(), hash);
 3236|  40.3M|    const h2_t h2 = H2(hash);
 3237|  40.3M|    const ctrl_t* ctrl = control();
 3238|  40.3M|    while (true) {
  ------------------
  |  Branch (3238:12): [True: 40.3M, Folded]
  ------------------
 3239|  40.3M|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3240|  40.3M|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3241|  40.3M|#endif
 3242|  40.3M|      Group g{ctrl + seq.offset()};
 3243|  40.3M|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3243:23): [True: 39.1M, False: 1.21M]
  ------------------
 3244|  39.1M|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  191|  39.1M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 39.1M, False: 31.7k]
  |  |  |  Branch (191:48): [Folded, False: 39.1M]
  |  |  |  Branch (191:57): [True: 39.1M, False: 31.7k]
  |  |  ------------------
  ------------------
 3245|  39.1M|          return iterator_at(seq.offset(i));
 3246|  39.1M|      }
 3247|  1.21M|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  191|  1.21M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1.21M, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 1.21M]
  |  |  |  Branch (191:57): [True: 1.21M, False: 0]
  |  |  ------------------
  ------------------
 3248|      0|      seq.next();
 3249|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  256|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3250|      0|    }
 3251|  40.3M|  }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE14const_iteratorC2ENS8_8iteratorE:
 2312|  80.6M|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZN4absl12lts_2026052618container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE14const_iteratorESB_:
 2326|  40.3M|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2327|  40.3M|      return !(a == b);
 2328|  40.3M|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE14const_iteratorESB_:
 2323|  40.3M|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2324|  40.3M|      return a.inner_ == b.inner_;
 2325|  40.3M|    }
_ZN4absl12lts_2026052618container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iteratorESB_:
 2222|  40.3M|    friend bool operator==(const iterator& a, const iterator& b) {
 2223|  40.3M|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 2224|  40.3M|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 2225|  40.3M|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 2226|  40.3M|                          a.generation_ptr(), b.generation_ptr());
 2227|  40.3M|      return a.ctrl_ == b.ctrl_;
 2228|  40.3M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE3endEv:
 2585|  40.3M|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2586|  40.3M|    return const_cast<raw_hash_set*>(this)->end();
 2587|  40.3M|  }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE14const_iteratorptEv:
 2315|  39.1M|    pointer operator->() const { return inner_.operator->(); }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iteratorptEv:
 2201|  39.1M|    pointer operator->() const {
 2202|  39.1M|      assert_is_full("operator->");
 2203|  39.1M|      return &operator*();
 2204|  39.1M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iterator14assert_is_fullEPKc:
 2259|  78.2M|    void assert_is_full(const char* operation) const {
 2260|  78.2M|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2261|  78.2M|    }
_ZNK4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyIDiN13sentencepiece14unicode_script10ScriptTypeEEEJEE8iteratordeEv:
 2195|  39.1M|    reference operator*() const {
 2196|  39.1M|      assert_is_full("operator*()");
 2197|  39.1M|      return unchecked_deref();
 2198|  39.1M|    }
_ZN4absl12lts_2026052618container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5clearEv:
 2614|  47.1k|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2615|  47.1k|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (2615:9): [Folded, False: 47.1k]
  |  Branch (2615:9): [Folded, False: 47.1k]
  ------------------
 2616|      0|        maybe_invalid_capacity().IsMovedFrom()) {
  ------------------
  |  Branch (2616:9): [True: 0, False: 0]
  ------------------
 2617|      0|      common().set_capacity(DefaultCapacity());
 2618|      0|    }
 2619|  47.1k|    AssertNotDebugCapacity();
 2620|       |    // Iterating over this container is O(bucket_count()). When bucket_count()
 2621|       |    // is much greater than size(), iteration becomes prohibitively expensive.
 2622|       |    // For clear() it is more important to reuse the allocated array when the
 2623|       |    // container is small because allocation takes comparatively long time
 2624|       |    // compared to destruction of the elements of the container. So we pick the
 2625|       |    // largest bucket_count() threshold for which iteration is still fast and
 2626|       |    // past that we simply deallocate the array.
 2627|  47.1k|    const size_t cap = capacity();
 2628|  47.1k|    if (cap == 0) {
  ------------------
  |  Branch (2628:9): [True: 47.1k, False: 0]
  ------------------
 2629|       |      // Already guaranteed to be empty; so nothing to do.
 2630|  47.1k|    } else if (is_small()) {
  ------------------
  |  Branch (2630:16): [True: 0, False: 0]
  ------------------
 2631|      0|      if (!empty()) {
  ------------------
  |  Branch (2631:11): [True: 0, False: 0]
  ------------------
 2632|      0|        destroy(single_slot());
 2633|      0|        decrement_small_size();
 2634|      0|      }
 2635|      0|    } else {
 2636|      0|      destroy_slots();
 2637|      0|      clear_backing_array(/*reuse=*/cap < 128);
 2638|      0|    }
 2639|  47.1k|    common().set_reserved_growth(0);
 2640|  47.1k|    common().set_reservation_size(0);
 2641|  47.1k|  }

_ZN4absl12lts_2026052612AnyInvocableIFvvEEC2EOS3_:
  187|  99.6k|  AnyInvocable(AnyInvocable&& /*f*/) noexcept = default;
_ZN4absl12lts_2026052612AnyInvocableIFvvEEC2Ev:
  181|  99.6k|  AnyInvocable() noexcept = default;
_ZN4absl12lts_2026052612AnyInvocableIFvvEEaSEOS3_:
  236|  99.6k|  AnyInvocable& operator=(AnyInvocable&& /*f*/) noexcept = default;
_ZN4absl12lts_20260526eqERKNS0_12AnyInvocableIFvvEEEDn:
  302|  99.6k|  friend bool operator==(const AnyInvocable& f, std::nullptr_t) noexcept {
  303|  99.6k|    return !f.HasValue();
  304|  99.6k|  }
_ZN4absl12lts_2026052612AnyInvocableIFvvEEC2EDn:
  182|  49.8k|  AnyInvocable(std::nullptr_t) noexcept {}  // NOLINT
_ZN4absl12lts_2026052612AnyInvocableIFvvEEC2INSt3__18functionIS2_EEvEEOT_:
  197|  49.8k|      : Impl(internal_any_invocable::ConversionConstruct(),
  198|  49.8k|             std::forward<F>(f)) {}

_ZN4absl12lts_2026052611FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEElEEJEE13destroy_slotsEvEUlS5_S6_E_vEEOT_:
  112|  18.4k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026052611FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEElEEJEE13destroy_slotsEvEUlS5_S6_E_EENSC_10in_place_tEOT_:
  100|  18.4k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  18.4k|    absl::functional_internal::AssertNonNull(f);
  102|  18.4k|    ptr_.obj = &f;
  103|  18.4k|  }
_ZN4absl12lts_2026052611FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashSetPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJEE13destroy_slotsEvEUlS5_S6_E_vEEOT_:
  112|  9.82k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026052611FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashSetPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEEEJEE13destroy_slotsEvEUlS5_S6_E_EENSC_10in_place_tEOT_:
  100|  9.82k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  9.82k|    absl::functional_internal::AssertNonNull(f);
  102|  9.82k|    ptr_.obj = &f;
  103|  9.82k|  }
_ZN4absl12lts_2026052611FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS0_13hash_internal4HashIDiEEDiLb1EEEvEEOT_:
  112|  25.3k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026052611FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS0_13hash_internal4HashIDiEEDiLb1EEEEENSt3__110in_place_tEOT_:
  100|  25.3k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  25.3k|    absl::functional_internal::AssertNonNull(f);
  102|  25.3k|    ptr_.obj = &f;
  103|  25.3k|  }
_ZN4absl12lts_2026052611FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEELb1EEEvEEOT_:
  112|  12.7k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026052611FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__117basic_string_viewIcNS8_11char_traitsIcEEEELb1EEEEENS8_10in_place_tEOT_:
  100|  12.7k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  12.7k|    absl::functional_internal::AssertNonNull(f);
  102|  12.7k|    ptr_.obj = &f;
  103|  12.7k|  }
_ZN4absl12lts_2026052611FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEELb1EEEvEEOT_:
  112|  53.3k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026052611FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS5_10StringHashENSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEELb1EEEEENS8_10in_place_tEOT_:
  100|  53.3k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  53.3k|    absl::functional_internal::AssertNonNull(f);
  102|  53.3k|    ptr_.obj = &f;
  103|  53.3k|  }
_ZN4absl12lts_2026052611FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEfEEJEE13destroy_slotsEvEUlS5_S6_E_vEEOT_:
  112|  11.5k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026052611FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEfEEJEE13destroy_slotsEvEUlS5_S6_E_EENSC_10in_place_tEOT_:
  100|  11.5k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  11.5k|    absl::functional_internal::AssertNonNull(f);
  102|  11.5k|    ptr_.obj = &f;
  103|  11.5k|  }
_ZN4absl12lts_2026052611FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEmEEJEE13destroy_slotsEvEUlS5_S6_E_vEEOT_:
  112|    888|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026052611FunctionRefIFvPKNS0_18container_internal6ctrl_tEPvEEC2IRZNS2_12raw_hash_setINS2_17FlatHashMapPolicyINSt3__112basic_stringIcNSC_11char_traitsIcEENSC_9allocatorIcEEEEmEEJEE13destroy_slotsEvEUlS5_S6_E_EENSC_10in_place_tEOT_:
  100|    888|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|    888|    absl::functional_internal::AssertNonNull(f);
  102|    888|    ptr_.obj = &f;
  103|    888|  }
_ZN4absl12lts_2026052611FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEEvEEOT_:
  112|  1.42k|      : FunctionRef(std::in_place, std::forward<F>(f)) {}
_ZN4absl12lts_2026052611FunctionRefIFmmEEC2INS0_18container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEEEENSt3__110in_place_tEOT_:
  100|  1.42k|      : invoker_(&absl::functional_internal::InvokeObject<F&, R, Args...>) {
  101|  1.42k|    absl::functional_internal::AssertNonNull(f);
  102|  1.42k|    ptr_.obj = &f;
  103|  1.42k|  }

_ZN4absl12lts_2026052622internal_any_invocable12EmptyManagerENS1_14FunctionToCallEPNS1_15TypeErasedStateES4_:
  213|   448k|                         TypeErasedState* /*to*/) noexcept {}
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEEC2EOS3_:
  471|  99.6k|  CoreImpl(CoreImpl&& other) noexcept {
  472|  99.6k|    other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
  473|  99.6k|    manager_ = other.manager_;
  474|  99.6k|    invoker_ = other.invoker_;
  475|  99.6k|    other.manager_ = EmptyManager;
  476|  99.6k|    other.invoker_ = nullptr;
  477|  99.6k|  }
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEED2Ev:
  499|   298k|  ~CoreImpl() { manager_(FunctionToCall::dispose, &state_, &state_); }
_ZN4absl12lts_2026052622internal_any_invocable4ImplIFvvEEC2Ev:
  712|   149k|    Impl() = default;                                                          \
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEEC2Ev:
  411|   149k|  CoreImpl() noexcept : manager_(EmptyManager), invoker_(nullptr) {}
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEEaSEOS3_:
  479|  99.6k|  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|  99.6k|    Clear();
  488|       |
  489|       |    // Perform the actual move/destroy operation on the target function.
  490|  99.6k|    other.manager_(FunctionToCall::relocate_from_to, &other.state_, &state_);
  491|  99.6k|    manager_ = other.manager_;
  492|  99.6k|    invoker_ = other.invoker_;
  493|  99.6k|    other.manager_ = EmptyManager;
  494|  99.6k|    other.invoker_ = nullptr;
  495|       |
  496|  99.6k|    return *this;
  497|  99.6k|  }
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEE5ClearEv:
  505|  99.6k|  void Clear() {
  506|  99.6k|    manager_(FunctionToCall::dispose, &state_, &state_);
  507|  99.6k|    manager_ = EmptyManager;
  508|  99.6k|    invoker_ = nullptr;
  509|  99.6k|  }
_ZNK4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEE8HasValueEv:
  502|  99.6k|  bool HasValue() const { return invoker_ != nullptr; }
_ZN4absl12lts_2026052622internal_any_invocable4ImplIFvvEE14ExtractInvokerEv:
  736|  49.8k|    InvokerType<noex, ReturnType, P...>* ExtractInvoker() cv {                 \
  737|  49.8k|      using QualifiedTestType = int cv ref;                                    \
  738|  49.8k|      auto* invoker = this->invoker_;                                          \
  739|  49.8k|      if (!std::is_const<QualifiedTestType>::value &&                          \
  ------------------
  |  Branch (739:11): [True: 0, Folded]
  ------------------
  740|  49.8k|          std::is_rvalue_reference<QualifiedTestType>::value) {                \
  ------------------
  |  Branch (740:11): [Folded, False: 0]
  ------------------
  741|      0|        ABSL_ASSERT([this]() {                                                 \
  ------------------
  |  |  127|      0|#define ABSL_ASSERT(expr) ABSL_INTERNAL_UNEVALUATED((expr) ? void() : void())
  |  |  ------------------
  |  |  |  |   87|      0|#define ABSL_INTERNAL_UNEVALUATED(expr) (false ? (void)(expr) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (87:42): [Folded, False: 0]
  |  |  |  |  |  Branch (87:57): [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|  49.8k|      return invoker;                                                          \
  748|  49.8k|    }                                                                          \
_ZN4absl12lts_2026052622internal_any_invocable4ImplIFvvEEC2INSt3__18functionIS3_EEEENS1_19ConversionConstructEOT_:
  719|  49.8k|        : Core(TypedConversionConstruct<                                       \
  720|  49.8k|                   typename std::decay<F>::type inv_quals>(),                  \
  721|  49.8k|               std::forward<F>(f)) {}                                          \
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEEC2IRNSt3__18functionIFvvEEES8_EENS1_24TypedConversionConstructIT_EEOT0_:
  417|  49.8k|  explicit CoreImpl(TypedConversionConstruct<QualDecayedTRef>, F&& f) {
  418|  49.8k|    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|  49.8k|    } else {
  459|  49.8k|      InitializeStorage<QualDecayedTRef>(std::forward<F>(f));
  460|  49.8k|    }
  461|  49.8k|  }
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEE17InitializeStorageIRNSt3__18functionIFvvEEEJS8_EEEvDpOT0_:
  513|  49.8k|  void InitializeStorage(Args&&... args) {
  514|  49.8k|    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|  49.8k|    } else {
  526|  49.8k|      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|  49.8k|      invoker_ = RemoteInvoker<SigIsNoexcept, ReturnType, QualTRef, P...>;
  530|  49.8k|    }
  531|  49.8k|  }
_ZN4absl12lts_2026052622internal_any_invocable8CoreImplILb0EvJEE23InitializeRemoteManagerINSt3__18functionIFvvEEEJS8_EEEvDpOT0_:
  534|  49.8k|  void InitializeRemoteManager(Args&&... args) {
  535|       |    if constexpr (std::is_trivially_destructible_v<T> &&
  536|       |                  alignof(T) <= ABSL_INTERNAL_DEFAULT_NEW_ALIGNMENT) {
  537|       |      // unique_ptr is used for exception-safety in case construction throws.
  538|       |      std::unique_ptr<void, TrivialDeleter> uninitialized_target(
  539|       |          ::operator new(sizeof(T)), TrivialDeleter(sizeof(T)));
  540|       |      ::new (uninitialized_target.get()) T(std::forward<Args>(args)...);
  541|       |      state_.remote.target = uninitialized_target.release();
  542|       |      state_.remote.size = sizeof(T);
  543|       |      manager_ = RemoteManagerTrivial;
  544|  49.8k|    } else {
  545|  49.8k|      state_.remote.target = ::new T(std::forward<Args>(args)...);
  546|  49.8k|      manager_ = RemoteManagerNontrivial<T>;
  547|  49.8k|    }
  548|  49.8k|  }
_ZN4absl12lts_2026052622internal_any_invocable23RemoteManagerNontrivialINSt3__18functionIFvvEEEEEvNS1_14FunctionToCallEPNS1_15TypeErasedStateES9_:
  309|   149k|                             TypeErasedState* const to) noexcept {
  310|   149k|  static_assert(!IsStoredLocally<T>(),
  311|   149k|                "Remote storage must only be used for types that do not "
  312|   149k|                "qualify for local storage.");
  313|       |
  314|   149k|  switch (operation) {
  ------------------
  |  Branch (314:11): [True: 149k, False: 0]
  ------------------
  315|  99.6k|    case FunctionToCall::relocate_from_to:
  ------------------
  |  Branch (315:5): [True: 99.6k, False: 49.8k]
  ------------------
  316|  99.6k|    case FunctionToCall::relocate_from_to_and_query_rust:
  ------------------
  |  Branch (316:5): [True: 0, False: 149k]
  ------------------
  317|       |      // NOTE: Requires that the left-hand operand is already empty.
  318|  99.6k|      to->remote.target = from->remote.target;
  319|  99.6k|      return;
  320|  49.8k|    case FunctionToCall::dispose:
  ------------------
  |  Branch (320:5): [True: 49.8k, False: 99.6k]
  ------------------
  321|  49.8k|      ::delete static_cast<T*>(from->remote.target);  // Must not throw.
  322|  49.8k|      return;
  323|   149k|  }
  324|      0|  ABSL_UNREACHABLE();
  ------------------
  |  |  237|      0|  do {                                           \
  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  ------------------
  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  ------------------
  |  |  241|      0|  } while (false)
  |  |  ------------------
  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  325|      0|}
_ZN4absl12lts_2026052622internal_any_invocable13RemoteInvokerILb0EvRNSt3__18functionIFvvEEEJEEET0_PNS1_15TypeErasedStateEDpNS1_18ForwardedParameterIT2_E4typeE:
  331|  49.8k|    ForwardedParameterType<P>... args) noexcept(SigIsNoexcept) {
  332|  49.8k|  using RawT = RemoveCVRef<QualTRef>;
  333|  49.8k|  static_assert(!IsStoredLocally<RawT>(),
  334|  49.8k|                "Target object must be in remote storage in order to be "
  335|  49.8k|                "invoked from it.");
  336|       |
  337|  49.8k|  auto& f = *static_cast<RawT*>(state->remote.target);
  338|  49.8k|  return (InvokeR<ReturnType>)(static_cast<QualTRef>(f),
  339|  49.8k|                               static_cast<ForwardedParameterType<P>>(args)...);
  340|  49.8k|}
_ZN4absl12lts_2026052622internal_any_invocable7InvokeRIvRNSt3__18functionIFvvEEEJEEET_OT0_DpOT1_:
  119|  49.8k|ReturnType InvokeR(F&& f, P&&... args) {
  120|  49.8k|  if constexpr (std::is_void_v<ReturnType>) {
  121|  49.8k|    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|  49.8k|}

_ZN4absl12lts_2026052619functional_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_2026052619functional_internal13AssertNonNullIZNS0_18container_internal12raw_hash_setINS3_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEElEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_EEvRKT_:
  136|  18.4k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026052619functional_internal12InvokeObjectIRZNS0_18container_internal12raw_hash_setINS3_17FlatHashSetPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_vJSH_SI_EEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|   421k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|   421k|  using T = std::remove_reference_t<Obj>;
   76|   421k|  return static_cast<R>(std::invoke(
   77|   421k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|   421k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|   421k|}
_ZN4absl12lts_2026052619functional_internal13AssertNonNullIZNS0_18container_internal12raw_hash_setINS3_17FlatHashSetPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_EEvRKT_:
  136|  9.82k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026052619functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS0_13hash_internal4HashIDiEEDiLb1EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|  16.8k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|  16.8k|  using T = std::remove_reference_t<Obj>;
   76|  16.8k|  return static_cast<R>(std::invoke(
   77|  16.8k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|  16.8k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|  16.8k|}
_ZN4absl12lts_2026052619functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS0_13hash_internal4HashIDiEEDiLb1EEEEEvRKT_:
  136|  25.3k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026052619functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS3_10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEELb1EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|  5.50k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|  5.50k|  using T = std::remove_reference_t<Obj>;
   76|  5.50k|  return static_cast<R>(std::invoke(
   77|  5.50k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|  5.50k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|  5.50k|}
_ZN4absl12lts_2026052619functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS3_10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEELb1EEEEEvRKT_:
  136|  12.7k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026052619functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS3_10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEELb1EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|  26.4k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|  26.4k|  using T = std::remove_reference_t<Obj>;
   76|  26.4k|  return static_cast<R>(std::invoke(
   77|  26.4k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|  26.4k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|  26.4k|}
_ZN4absl12lts_2026052619functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS3_10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEELb1EEEEEvRKT_:
  136|  53.3k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026052619functional_internal12InvokeObjectIRZNS0_18container_internal12raw_hash_setINS3_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_vJSH_SI_EEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|   457k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|   457k|  using T = std::remove_reference_t<Obj>;
   76|   457k|  return static_cast<R>(std::invoke(
   77|   457k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|   457k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|   457k|}
_ZN4absl12lts_2026052619functional_internal13AssertNonNullIZNS0_18container_internal12raw_hash_setINS3_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEfEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_EEvRKT_:
  136|  11.5k|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026052619functional_internal12InvokeObjectIRZNS0_18container_internal12raw_hash_setINS3_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEmEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_vJSH_SI_EEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|  93.2k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|  93.2k|  using T = std::remove_reference_t<Obj>;
   76|  93.2k|  return static_cast<R>(std::invoke(
   77|  93.2k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|  93.2k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|  93.2k|}
_ZN4absl12lts_2026052619functional_internal13AssertNonNullIZNS0_18container_internal12raw_hash_setINS3_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEmEEJEE13destroy_slotsEvEUlPKNS3_6ctrl_tEPvE_EEvRKT_:
  136|    888|void AssertNonNull(const F&) {}
_ZN4absl12lts_2026052619functional_internal12InvokeObjectIRNS0_18container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEEmJmEEET0_NS1_7VoidPtrEDpNS1_8ForwardTIT1_E4typeE:
   74|  1.42k|R InvokeObject(VoidPtr ptr, typename ForwardT<Args>::type... args) {
   75|  1.42k|  using T = std::remove_reference_t<Obj>;
   76|  1.42k|  return static_cast<R>(std::invoke(
   77|  1.42k|      std::forward<Obj>(*const_cast<T*>(static_cast<const T*>(ptr.obj))),
   78|  1.42k|      std::forward<typename ForwardT<Args>::type>(args)...));
   79|  1.42k|}
_ZN4absl12lts_2026052619functional_internal13AssertNonNullINS0_18container_internal7HashKeyINS0_13hash_internal4HashImEEmLb1EEEEEvRKT_:
  136|  1.42k|void AssertNonNull(const F&) {}

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

_ZN4absl12lts_2026052613hash_internal15MixingHashState18combine_contiguousES2_PKhm:
 1399|  19.9M|                                            size_t size) {
 1400|  19.9M|    return MixingHashState(
 1401|  19.9M|        CombineContiguousImpl(hash_state.state_, first, size,
 1402|  19.9M|                              std::integral_constant<int, sizeof(size_t)>{}));
 1403|  19.9M|  }
_ZN4absl12lts_2026052613hash_internal15MixingHashStateC2Em:
 1450|  50.1M|  explicit MixingHashState(uint64_t state) : state_(state) {}
_ZN4absl12lts_2026052613hash_internal15MixingHashState11combine_rawES2_m:
 1456|  6.82M|                                     uint64_t value) {
 1457|  6.82M|    return MixingHashState(CombineRawImpl(hash_state.state_, value));
 1458|  6.82M|  }
_ZN4absl12lts_2026052613hash_internal15MixingHashState4SeedEv:
 1502|  3.41M|  ABSL_ATTRIBUTE_ALWAYS_INLINE static size_t Seed() {
 1503|  3.41M|#if (!defined(__clang__) || __clang_major__ > 11) && \
 1504|  3.41M|    (!defined(__apple_build_version__) ||            \
 1505|  3.41M|     __apple_build_version__ >= 19558921)  // Xcode 12
 1506|  3.41M|    return static_cast<size_t>(reinterpret_cast<uintptr_t>(&kSeed));
 1507|       |#else
 1508|       |    // Workaround the absence of
 1509|       |    // https://github.com/llvm/llvm-project/commit/bc15bf66dcca76cc06fe71fca35b74dc4d521021.
 1510|       |    return static_cast<size_t>(reinterpret_cast<uintptr_t>(kSeed));
 1511|       |#endif
 1512|  3.41M|  }
_ZN4absl12lts_2026052613hash_internal19PrecombineLengthMixEmm:
 1005|  19.5M|inline uint64_t PrecombineLengthMix(uint64_t state, size_t len) {
 1006|  19.5M|  ABSL_ASSUME(len + sizeof(uint64_t) <= sizeof(kStaticRandomData));
  ------------------
  |  |  271|  19.5M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1007|  19.5M|  uint64_t data = absl::base_internal::UnalignedLoad64(
 1008|  19.5M|      reinterpret_cast<const unsigned char*>(&kStaticRandomData[0]) + len);
 1009|  19.5M|  return state ^ data;
 1010|  19.5M|}
_ZN4absl12lts_2026052613hash_internal3MixEmm:
 1012|  95.5M|ABSL_ATTRIBUTE_ALWAYS_INLINE inline uint64_t Mix(uint64_t lhs, uint64_t rhs) {
 1013|       |  // Though the 128-bit product needs multiple instructions on non-x86-64
 1014|       |  // platforms, it is still a good balance between speed and hash quality.
 1015|  95.5M|  absl::uint128 m = lhs;
 1016|  95.5M|  m *= rhs;
 1017|  95.5M|  return Uint128High64(m) ^ Uint128Low64(m);
 1018|  95.5M|}
_ZN4absl12lts_2026052613hash_internal5Read8EPKh:
 1028|  14.9M|inline uint64_t Read8(const unsigned char* p) {
 1029|  14.9M|  return absl::base_internal::UnalignedLoad64(p);
 1030|  14.9M|}
_ZN4absl12lts_2026052613hash_internal9Read9To16EPKhm:
 1039|  4.70M|                                               size_t len) {
 1040|  4.70M|  return {Read8(p), Read8(p + len - 8)};
 1041|  4.70M|}
_ZN4absl12lts_2026052613hash_internal8Read4To8EPKhm:
 1045|  4.33M|inline uint64_t Read4To8(const unsigned char* p, size_t len) {
 1046|       |  // If `len < 8`, we duplicate bytes. We always put low memory at the end.
 1047|       |  // E.g., on little endian platforms:
 1048|       |  // `ABCD` will be read as `ABCDABCD`.
 1049|       |  // `ABCDE` will be read as `BCDEABCD`.
 1050|       |  // `ABCDEF` will be read as `CDEFABCD`.
 1051|       |  // `ABCDEFG` will be read as `DEFGABCD`.
 1052|       |  // `ABCDEFGH` will be read as `EFGHABCD`.
 1053|       |  // We also do not care about endianness. On big-endian platforms, bytes will
 1054|       |  // be permuted differently. We always shift low memory by 32, because that
 1055|       |  // can be pipelined earlier. Reading high memory requires computing
 1056|       |  // `p + len - 4`.
 1057|  4.33M|  uint64_t most_significant =
 1058|  4.33M|      static_cast<uint64_t>(absl::base_internal::UnalignedLoad32(p)) << 32;
 1059|  4.33M|  uint64_t least_significant =
 1060|  4.33M|      absl::base_internal::UnalignedLoad32(p + len - 4);
 1061|  4.33M|  return most_significant | least_significant;
 1062|  4.33M|}
_ZN4absl12lts_2026052613hash_internal8Read1To3EPKhm:
 1065|  9.16M|inline uint32_t Read1To3(const unsigned char* p, size_t len) {
 1066|       |  // The trick used by this implementation is to avoid branches.
 1067|       |  // We always read three bytes by duplicating.
 1068|       |  // E.g.,
 1069|       |  // `A` is read as `AAA`.
 1070|       |  // `AB` is read as `ABB`.
 1071|       |  // `ABC` is read as `ABC`.
 1072|       |  // We always shift `p[0]` so that it can be pipelined better.
 1073|       |  // Other bytes require extra computation to find indices.
 1074|  9.16M|  uint32_t mem0 = (static_cast<uint32_t>(p[0]) << 16) | p[len - 1];
 1075|  9.16M|  uint32_t mem1 = static_cast<uint32_t>(p[len / 2]) << 8;
 1076|  9.16M|  return mem0 | mem1;
 1077|  9.16M|}
_ZN4absl12lts_2026052613hash_internal14CombineRawImplEmm:
 1120|  85.8M|                                                            uint64_t value) {
 1121|  85.8M|  return Mix(state ^ value, kMul);
 1122|  85.8M|}
_ZN4absl12lts_2026052613hash_internal26CombineSmallContiguousImplEmPKhm:
 1136|  13.4M|    uint64_t state, const unsigned char* first, size_t len) {
 1137|  13.4M|  ABSL_ASSUME(len <= 8);
  ------------------
  |  |  271|  13.4M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1138|  13.4M|  uint64_t v;
 1139|  13.4M|  if (len >= 4) {
  ------------------
  |  Branch (1139:7): [True: 4.33M, False: 9.16M]
  ------------------
 1140|  4.33M|    v = Read4To8(first, len);
 1141|  9.16M|  } else if (len > 0) {
  ------------------
  |  Branch (1141:14): [True: 9.16M, False: 0]
  ------------------
 1142|  9.16M|    v = Read1To3(first, len);
 1143|  9.16M|  } else {
 1144|       |    // Empty string must modify the state.
 1145|      0|    v = 0x57;
 1146|      0|  }
 1147|  13.4M|  return CombineRawImpl(state, v);
 1148|  13.4M|}
_ZN4absl12lts_2026052613hash_internal26CombineContiguousImpl9to16EmPKhm:
 1151|  4.70M|    uint64_t state, const unsigned char* first, size_t len) {
 1152|  4.70M|  ABSL_ASSUME(len >= 9);
  ------------------
  |  |  271|  4.70M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1153|  4.70M|  ABSL_ASSUME(len <= 16);
  ------------------
  |  |  271|  4.70M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1154|       |  // Note: any time one half of the mix function becomes zero it will fail to
 1155|       |  // incorporate any bits from the other half. However, there is exactly 1 in
 1156|       |  // 2^64 values for each side that achieve this, and only when the size is
 1157|       |  // exactly 16 -- for smaller sizes there is an overlapping byte that makes
 1158|       |  // this impossible unless the seed is *also* incredibly unlucky.
 1159|  4.70M|  auto p = Read9To16(first, len);
 1160|  4.70M|  return Mix(state ^ p.first, kMul ^ p.second);
 1161|  4.70M|}
_ZN4absl12lts_2026052613hash_internal27CombineContiguousImpl17to32EmPKhm:
 1164|  1.38M|    uint64_t state, const unsigned char* first, size_t len) {
 1165|  1.38M|  ABSL_ASSUME(len >= 17);
  ------------------
  |  |  271|  1.38M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1166|  1.38M|  ABSL_ASSUME(len <= 32);
  ------------------
  |  |  271|  1.38M|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1167|       |  // Do two mixes of overlapping 16-byte ranges in parallel to minimize
 1168|       |  // latency.
 1169|  1.38M|  const uint64_t m0 =
 1170|  1.38M|      Mix(Read8(first) ^ kStaticRandomData[1], Read8(first + 8) ^ state);
 1171|       |
 1172|  1.38M|  const unsigned char* tail_16b_ptr = first + (len - 16);
 1173|  1.38M|  const uint64_t m1 = Mix(Read8(tail_16b_ptr) ^ kStaticRandomData[3],
 1174|  1.38M|                          Read8(tail_16b_ptr + 8) ^ state);
 1175|  1.38M|  return m0 ^ m1;
 1176|  1.38M|}
_ZN4absl12lts_2026052613hash_internal21CombineContiguousImplEmPKhmNSt3__117integral_constantIiLi8EEE:
 1260|  19.9M|    std::integral_constant<int, 8> /* sizeof_size_t */) {
 1261|       |  // For large values we use LowLevelHash or CityHash depending on the platform,
 1262|       |  // for small ones we use custom low latency hash.
 1263|  19.9M|  if (len <= 8) {
  ------------------
  |  Branch (1263:7): [True: 13.4M, False: 6.48M]
  ------------------
 1264|  13.4M|    return CombineSmallContiguousImpl(PrecombineLengthMix(state, len), first,
 1265|  13.4M|                                      len);
 1266|  13.4M|  }
 1267|  6.48M|  if (len <= 16) {
  ------------------
  |  Branch (1267:7): [True: 4.70M, False: 1.78M]
  ------------------
 1268|  4.70M|    return CombineContiguousImpl9to16(PrecombineLengthMix(state, len), first,
 1269|  4.70M|                                      len);
 1270|  4.70M|  }
 1271|  1.78M|  if (len <= 32) {
  ------------------
  |  Branch (1271:7): [True: 1.38M, False: 394k]
  ------------------
 1272|  1.38M|    return CombineContiguousImpl17to32(PrecombineLengthMix(state, len), first,
 1273|  1.38M|                                       len);
 1274|  1.38M|  }
 1275|       |  // We must not mix length into the state here because calling
 1276|       |  // CombineContiguousImpl twice with PiecewiseChunkSize() must be equivalent
 1277|       |  // to calling CombineLargeContiguousImpl once with 2 * PiecewiseChunkSize().
 1278|   394k|  return CombineLargeContiguousImplOn64BitLengthGt32(state, first, len);
 1279|  1.78M|}
_ZN4absl12lts_2026052613hash_internal15MixingHashState14hash_with_seedINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETnNS4_9enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSA_m:
 1423|  19.9M|  static size_t hash_with_seed(const T& value, size_t seed) {
 1424|  19.9M|    return static_cast<size_t>(combine(MixingHashState{seed}, value).state_);
 1425|  19.9M|  }
_ZN4absl12lts_2026052613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEES3_S3_RKT_DpRKT0_:
 1548|  19.9M|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1549|  19.9M|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1550|  19.9M|                        std::move(state), value),
 1551|  19.9M|                    values...);
 1552|  19.9M|}
_ZN4absl12lts_2026052613hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEENS6_9enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESC_E4typeESC_RKT0_:
 1326|  19.9M|        H> {
 1327|  19.9M|      return AbslHashValue(std::move(state), value);
 1328|  19.9M|    }
_ZN4absl12lts_2026052613hash_internal13AbslHashValueINS1_15MixingHashStateEEET_S4_NSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  661|  19.9M|H AbslHashValue(H hash_state, absl::string_view str) {
  662|  19.9M|  return H::combine_contiguous(std::move(hash_state), str.data(), str.size());
  663|  19.9M|}
_ZN4absl12lts_2026052613hash_internal13HashStateBaseINS1_15MixingHashStateEE18combine_contiguousIcEES3_S3_PKT_m:
 1556|  19.9M|H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
 1557|  19.9M|  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
 1558|  19.9M|}
_ZN4absl12lts_2026052613hash_internal19hash_range_or_bytesINS1_15MixingHashStateEcEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES7_PKS6_m:
  978|  19.9M|hash_range_or_bytes(H hash_state, const T* data, size_t size) {
  979|  19.9M|  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
  980|  19.9M|  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
  981|  19.9M|}
_ZN4absl12lts_2026052613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineES3_:
  299|  26.8M|  static H combine(H state) { return state; }
_ZNK4absl12lts_2026052613hash_internal12HashWithSeed4hashINS1_4HashINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEES9_EEmRKT_RKT0_m:
  412|  19.9M|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  413|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  414|  19.9M|    return hasher.hash_with_seed(value, seed);
  415|  19.9M|  }
_ZNK4absl12lts_2026052613hash_internal8HashImplINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE14hash_with_seedERKS7_m:
 1537|  19.9M|  size_t hash_with_seed(const T& value, size_t seed) const {
 1538|  19.9M|    return MixingHashState::hash_with_seed(value, seed);
 1539|  19.9M|  }
_ZNK4absl12lts_2026052613hash_internal12HashWithSeed4hashINS1_4HashIDiEEDiEEmRKT_RKT0_m:
  412|  60.2M|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  413|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  414|  60.2M|    return hasher.hash_with_seed(value, seed);
  415|  60.2M|  }
_ZNK4absl12lts_2026052613hash_internal8HashImplIDiE14hash_with_seedERKDim:
 1537|  60.2M|  size_t hash_with_seed(const T& value, size_t seed) const {
 1538|  60.2M|    return MixingHashState::hash_with_seed(value, seed);
 1539|  60.2M|  }
_ZN4absl12lts_2026052613hash_internal15MixingHashState14hash_with_seedIDiTnNSt3__19enable_ifIXsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmS6_m:
 1417|  60.2M|  static size_t hash_with_seed(T value, size_t seed) {
 1418|  60.2M|    return static_cast<size_t>(
 1419|  60.2M|        CombineRawImpl(seed, static_cast<std::make_unsigned_t<T>>(value)));
 1420|  60.2M|  }
_ZNK4absl12lts_2026052613hash_internal12HashWithSeed4hashINS0_18container_internal10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEmRKT_RKT0_m:
  412|  19.5M|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  413|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  414|  19.5M|    return hasher.hash_with_seed(value, seed);
  415|  19.5M|  }
_ZNK4absl12lts_2026052613hash_internal12HashWithSeed4hashINS0_18container_internal10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEmRKT_RKT0_m:
  412|   433k|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  413|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  414|   433k|    return hasher.hash_with_seed(value, seed);
  415|   433k|  }
_ZNK4absl12lts_2026052613hash_internal12HashWithSeed4hashINS1_4HashImEEmEEmRKT_RKT0_m:
  412|  5.23M|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  413|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  414|  5.23M|    return hasher.hash_with_seed(value, seed);
  415|  5.23M|  }
_ZNK4absl12lts_2026052613hash_internal8HashImplImE14hash_with_seedERKmm:
 1537|  5.23M|  size_t hash_with_seed(const T& value, size_t seed) const {
 1538|  5.23M|    return MixingHashState::hash_with_seed(value, seed);
 1539|  5.23M|  }
_ZN4absl12lts_2026052613hash_internal15MixingHashState14hash_with_seedImTnNSt3__19enable_ifIXsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmS6_m:
 1417|  5.23M|  static size_t hash_with_seed(T value, size_t seed) {
 1418|  5.23M|    return static_cast<size_t>(
 1419|  5.23M|        CombineRawImpl(seed, static_cast<std::make_unsigned_t<T>>(value)));
 1420|  5.23M|  }
_ZNK4absl12lts_2026052613hash_internal8HashImplINSt3__15tupleIJRKmS6_EEEEclERKS7_:
 1530|  3.41M|  size_t operator()(const T& value) const {
 1531|  3.41M|    return MixingHashState::hash(value);
 1532|  3.41M|  }
_ZN4absl12lts_2026052613hash_internal15MixingHashState4hashINSt3__15tupleIJRKmS7_EEEEEmRKT_:
 1407|  3.41M|  static size_t hash(const T& value) {
 1408|  3.41M|    return hash_with_seed(value, Seed());
 1409|  3.41M|  }
_ZN4absl12lts_2026052613hash_internal15MixingHashState14hash_with_seedINSt3__15tupleIJRKmS7_EEETnNS4_9enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSA_m:
 1423|  3.41M|  static size_t hash_with_seed(const T& value, size_t seed) {
 1424|  3.41M|    return static_cast<size_t>(combine(MixingHashState{seed}, value).state_);
 1425|  3.41M|  }
_ZN4absl12lts_2026052613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__15tupleIJRKmS9_EEEJEEES3_S3_RKT_DpRKT0_:
 1548|  3.41M|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1549|  3.41M|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1550|  3.41M|                        std::move(state), value),
 1551|  3.41M|                    values...);
 1552|  3.41M|}
_ZN4absl12lts_2026052613hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__15tupleIJRKmS9_EEEEENS6_9enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESC_E4typeESC_RKT0_:
 1326|  3.41M|        H> {
 1327|  3.41M|      return AbslHashValue(std::move(state), value);
 1328|  3.41M|    }
_ZN4absl12lts_2026052613hash_internal13AbslHashValueINS1_15MixingHashStateEJRKmS5_EEENSt3__19enable_ifIXsr3std11conjunctionIDpNS1_11is_hashableIT0_EEEE5valueET_E4typeESC_RKNS6_5tupleIJDpS9_EEE:
  620|  3.41M|AbslHashValue(H hash_state, const std::tuple<Ts...>& t) {
  621|  3.41M|  return hash_internal::hash_tuple(std::move(hash_state), t,
  622|  3.41M|                                   std::make_index_sequence<sizeof...(Ts)>());
  623|  3.41M|}
_ZN4absl12lts_2026052613hash_internal10hash_tupleINS1_15MixingHashStateENSt3__15tupleIJRKmS7_EEEJLm0ELm1EEEET_S9_RKT0_NS4_16integer_sequenceImJXspT1_EEEE:
  607|  3.41M|H hash_tuple(H hash_state, const Tuple& t, std::index_sequence<Is...>) {
  608|  3.41M|  return H::combine(std::move(hash_state), std::get<Is>(t)...);
  609|  3.41M|}
_ZN4absl12lts_2026052613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineImJmEEES3_S3_RKT_DpRKT0_:
 1548|  3.41M|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1549|  3.41M|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1550|  3.41M|                        std::move(state), value),
 1551|  3.41M|                    values...);
 1552|  3.41M|}
_ZN4absl12lts_2026052613hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineImJEEES3_S3_RKT_DpRKT0_:
 1548|  3.41M|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1549|  3.41M|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1550|  3.41M|                        std::move(state), value),
 1551|  3.41M|                    values...);
 1552|  3.41M|}
_ZN4absl12lts_2026052613hash_internal10HashSelect24UniquelyRepresentedProbe6InvokeINS1_15MixingHashStateEmEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES9_RKS8_:
 1316|  6.82M|        -> std::enable_if_t<is_uniquely_represented<T>::value, H> {
 1317|  6.82M|      return hash_internal::hash_bytes(std::move(state), value);
 1318|  6.82M|    }
_ZN4absl12lts_2026052613hash_internal10hash_bytesINS1_15MixingHashStateEmTnNSt3__19enable_ifIXsr12FitsIn64BitsIT0_EE5valueEiE4typeELi0EEET_S9_RKS6_:
  422|  6.82M|H hash_bytes(H hash_state, const T& value) {
  423|  6.82M|  const unsigned char* start = reinterpret_cast<const unsigned char*>(&value);
  424|  6.82M|  uint64_t v;
  425|       |  if constexpr (sizeof(T) == 1) {
  426|       |    v = *start;
  427|       |  } else if constexpr (sizeof(T) == 2) {
  428|       |    v = absl::base_internal::UnalignedLoad16(start);
  429|       |  } else if constexpr (sizeof(T) == 4) {
  430|       |    v = absl::base_internal::UnalignedLoad32(start);
  431|  6.82M|  } else {
  432|  6.82M|    static_assert(sizeof(T) == 8);
  433|  6.82M|    v = absl::base_internal::UnalignedLoad64(start);
  434|  6.82M|  }
  435|  6.82M|  return CombineRaw()(std::move(hash_state), v);
  436|  6.82M|}
_ZNK4absl12lts_2026052613hash_internal10CombineRawclINS1_15MixingHashStateEEET_S5_m:
  404|  6.82M|  H operator()(H state, uint64_t value) const {
  405|  6.82M|    return H::combine_raw(std::move(state), value);
  406|  6.82M|  }

_ZN4absl12lts_2026052612log_internal12Check_EQImplIiiEEPKcRKT_RKT0_S4_:
  489|  5.83k|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  5.83k|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  5.83k|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  5.83k|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  191|  5.83k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 5.83k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 5.83k]
  |  |  |  Branch (191:57): [True: 5.83k, False: 0]
  |  |  ------------------
  ------------------
  493|  5.83k|               ? nullptr                                                   \
  494|  5.83k|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  5.83k|                                                        U2(v2), exprtext); \
  496|  5.83k|  }                                                                        \
_ZN4absl12lts_2026052612log_internal12Check_GEImplIiiEEPKcRKT_RKT0_S4_:
  489|  4.19M|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  4.19M|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  4.19M|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  4.19M|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  191|  4.19M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 4.19M, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 4.19M]
  |  |  |  Branch (191:57): [True: 4.19M, False: 0]
  |  |  ------------------
  ------------------
  493|  4.19M|               ? nullptr                                                   \
  494|  4.19M|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  4.19M|                                                        U2(v2), exprtext); \
  496|  4.19M|  }                                                                        \
_ZN4absl12lts_2026052612log_internal12Check_GTImplIiiEEPKcRKT_RKT0_S4_:
  489|  5.83k|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  5.83k|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  5.83k|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  5.83k|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  191|  5.83k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 5.83k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 5.83k]
  |  |  |  Branch (191:57): [True: 5.83k, False: 0]
  |  |  ------------------
  ------------------
  493|  5.83k|               ? nullptr                                                   \
  494|  5.83k|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  5.83k|                                                        U2(v2), exprtext); \
  496|  5.83k|  }                                                                        \
_ZN4absl12lts_2026052612log_internal12Check_EQImplEiiPKc:
  498|  5.83k|      int v1, int v2, const char* absl_nonnull exprtext) {                 \
  499|  5.83k|    return name##Impl<int, int>(v1, v2, exprtext);                         \
  500|  5.83k|  }
_ZN4absl12lts_2026052612log_internal12Check_GEImplEiiPKc:
  498|  4.19M|      int v1, int v2, const char* absl_nonnull exprtext) {                 \
  499|  4.19M|    return name##Impl<int, int>(v1, v2, exprtext);                         \
  500|  4.19M|  }
_ZN4absl12lts_2026052612log_internal12Check_GTImplEiiPKc:
  498|  5.83k|      int v1, int v2, const char* absl_nonnull exprtext) {                 \
  499|  5.83k|    return name##Impl<int, int>(v1, v2, exprtext);                         \
  500|  5.83k|  }
_ZN4absl12lts_2026052612log_internal21GetReferenceableValueEt:
  542|  4.19M|inline constexpr unsigned short GetReferenceableValue(unsigned short t) {
  543|  4.19M|  return t;
  544|  4.19M|}
_ZN4absl12lts_2026052612log_internal21GetReferenceableValueEi:
  545|  13.7M|inline constexpr int GetReferenceableValue(int t) { return t; }
_ZN4absl12lts_2026052612log_internal21GetReferenceableValueEm:
  550|  1.18M|inline constexpr unsigned long GetReferenceableValue(unsigned long t) {
  551|  1.18M|  return t;
  552|  1.18M|}
_ZN4absl12lts_2026052612log_internal12Check_LEImplIitEEPKcRKT_RKT0_S4_:
  489|  4.19M|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  4.19M|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  4.19M|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  4.19M|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  191|  4.19M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 4.19M, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 4.19M]
  |  |  |  Branch (191:57): [True: 4.19M, False: 0]
  |  |  ------------------
  ------------------
  493|  4.19M|               ? nullptr                                                   \
  494|  4.19M|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  4.19M|                                                        U2(v2), exprtext); \
  496|  4.19M|  }                                                                        \
_ZN4absl12lts_2026052612log_internal12Check_EQImplImmEEPKcRKT_RKT0_S4_:
  489|  31.4k|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  31.4k|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  31.4k|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  31.4k|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  191|  31.4k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 31.4k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 31.4k]
  |  |  |  Branch (191:57): [True: 31.4k, False: 0]
  |  |  ------------------
  ------------------
  493|  31.4k|               ? nullptr                                                   \
  494|  31.4k|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  31.4k|                                                        U2(v2), exprtext); \
  496|  31.4k|  }                                                                        \
_ZN4absl12lts_2026052612log_internal12Check_LEImplImmEEPKcRKT_RKT0_S4_:
  489|  5.83k|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  5.83k|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  5.83k|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  5.83k|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  191|  5.83k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 5.83k, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 5.83k]
  |  |  |  Branch (191:57): [True: 5.83k, False: 0]
  |  |  ------------------
  ------------------
  493|  5.83k|               ? nullptr                                                   \
  494|  5.83k|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  5.83k|                                                        U2(v2), exprtext); \
  496|  5.83k|  }                                                                        \
_ZN4absl12lts_2026052612log_internal12Check_GTImplImiEEPKcRKT_RKT0_S4_:
  489|  1.10M|      const T1& v1, const T2& v2, const char* absl_nonnull exprtext) {     \
  490|  1.10M|    using U1 = CheckOpStreamType<T1, T2>;                                  \
  491|  1.10M|    using U2 = CheckOpStreamType<T2, T1>;                                  \
  492|  1.10M|    return ABSL_PREDICT_TRUE(v1 op v2)                                     \
  ------------------
  |  |  191|  1.10M|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:30): [True: 1.10M, False: 0]
  |  |  |  Branch (191:48): [Folded, False: 1.10M]
  |  |  |  Branch (191:57): [True: 1.10M, False: 0]
  |  |  ------------------
  ------------------
  493|  1.10M|               ? nullptr                                                   \
  494|  1.10M|               : ABSL_LOG_INTERNAL_CHECK_OP_IMPL_RESULT(U1, U2, U1(v1),    \
  ------------------
  |  |  479|      0|  MakeCheckOpString<U1, U2>(v1, v2, exprtext)
  ------------------
  495|  1.10M|                                                        U2(v2), exprtext); \
  496|  1.10M|  }                                                                        \

_ZN4absl12lts_2026052612log_internal10LogMessage14InternalStreamEv:
  124|   612k|  LogMessage& InternalStream() { return *this; }
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi25EEERS2_RAT__Kc:
  364|  17.0k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  17.0k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  17.0k|  return *this;
  367|  17.0k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi18EEERS2_RAT__Kc:
  364|  8.54k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  8.54k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  8.54k|  return *this;
  367|  8.54k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsIPKcEERS2_RKT_:
  351|  8.54k|LogMessage& LogMessage::operator<<(const T& v) {
  352|       |  if constexpr (absl::HasAbslStringify<T>::value) {
  353|       |    StringifySink sink(*this);
  354|       |    // Replace with public API.
  355|       |    AbslStringify(sink, v);
  356|  8.54k|  } else {
  357|  8.54k|    OstreamView view(*data_);
  358|  8.54k|    view.stream() << log_internal::NullGuard<T>().Guard(v);
  359|  8.54k|  }
  360|  8.54k|  return *this;
  361|  8.54k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsEi:
  139|  68.6k|  LogMessage& operator<<(signed int v) { return operator<< <signed int>(v); }
_ZN4absl12lts_2026052612log_internal10LogMessagelsEl:
  140|  39.9k|  LogMessage& operator<<(signed long v) {
  141|  39.9k|    return operator<< <signed long>(v);
  142|  39.9k|  }
_ZN4absl12lts_2026052612log_internal10LogMessagelsEm:
  152|  57.5k|  LogMessage& operator<<(unsigned long v) {
  153|  57.5k|    return operator<< <unsigned long>(v);
  154|  57.5k|  }
_ZN4absl12lts_2026052612log_internal10LogMessagelsEf:
  164|  31.4k|  LogMessage& operator<<(float v) { return operator<< <float>(v); }
_ZN4absl12lts_2026052612log_internal10LogMessagelsEd:
  165|  42.1k|  LogMessage& operator<<(double v) { return operator<< <double>(v); }
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi26EEERS2_RAT__Kc:
  364|  10.7k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  10.7k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  10.7k|  return *this;
  367|  10.7k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi23EEERS2_RAT__Kc:
  364|  5.83k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  5.83k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  5.83k|  return *this;
  367|  5.83k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi21EEERS2_RAT__Kc:
  364|  5.83k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  5.83k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  5.83k|  return *this;
  367|  5.83k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi17EEERS2_RAT__Kc:
  364|  8.52k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  8.52k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  8.52k|  return *this;
  367|  8.52k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi60EEERS2_RAT__Kc:
  364|    498|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|    498|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|    498|  return *this;
  367|    498|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi7EEERS2_RAT__Kc:
  364|  48.1k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  48.1k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  48.1k|  return *this;
  367|  48.1k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi8EEERS2_RAT__Kc:
  364|  1.79k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  1.79k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  1.79k|  return *this;
  367|  1.79k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi22EEERS2_RAT__Kc:
  364|    542|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|    542|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|    542|  return *this;
  367|    542|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi36EEERS2_RAT__Kc:
  364|    270|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|    270|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|    270|  return *this;
  367|    270|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi12EEERS2_RAT__Kc:
  364|  16.9k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  16.9k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  16.9k|  return *this;
  367|  16.9k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi11EEERS2_RAT__Kc:
  364|  8.53k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  8.53k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  8.53k|  return *this;
  367|  8.53k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi9EEERS2_RAT__Kc:
  364|  1.79k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  1.79k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  1.79k|  return *this;
  367|  1.79k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi20EEERS2_RAT__Kc:
  364|  51.4k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  51.4k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  51.4k|  return *this;
  367|  51.4k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi59EEERS2_RAT__Kc:
  364|   428k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|   428k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|   428k|  return *this;
  367|   428k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi15EEERS2_RAT__Kc:
  364|  8.52k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  8.52k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  8.52k|  return *this;
  367|  8.52k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi45EEERS2_RAT__Kc:
  364|  12.1k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  12.1k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  12.1k|  return *this;
  367|  12.1k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi27EEERS2_RAT__Kc:
  364|  5.83k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  5.83k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  5.83k|  return *this;
  367|  5.83k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi13EEERS2_RAT__Kc:
  364|  70.4k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  70.4k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  70.4k|  return *this;
  367|  70.4k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi6EEERS2_RAT__Kc:
  364|  33.2k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  33.2k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  33.2k|  return *this;
  367|  33.2k|}
_ZN4absl12lts_2026052612log_internal10LogMessagelsILi19EEERS2_RAT__Kc:
  364|  31.4k|LogMessage& LogMessage::operator<<(const char (&buf)[SIZE]) {
  365|  31.4k|  CopyToEncodedBuffer<StringType::kLiteral>(buf);
  366|  31.4k|  return *this;
  367|  31.4k|}

_ZN4absl12lts_2026052612log_internal9NullGuardIPKcE5GuardES4_:
   53|  8.54k|  static const char* Guard(const char* v) { return v ? v : kCharNull.data(); }
  ------------------
  |  Branch (53:52): [True: 8.54k, False: 0]
  ------------------
_ZN4absl12lts_2026052612log_internal9NullGuardImE5GuardERKm:
   45|  57.5k|  static const T& Guard(const T& v) { return v; }
_ZN4absl12lts_2026052612log_internal9NullGuardIlE5GuardERKl:
   45|  39.9k|  static const T& Guard(const T& v) { return v; }

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

_ZN4absl12lts_2026052611countl_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  108|  19.6k|    countl_zero(T x) noexcept {
  109|  19.6k|  return numeric_internal::CountLeadingZeroes(x);
  110|  19.6k|}
_ZN4absl12lts_2026052611countr_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  123|  2.22M|    countr_zero(T x) noexcept {
  124|  2.22M|  return numeric_internal::CountTrailingZeroes(x);
  125|  2.22M|}
_ZN4absl12lts_2026052611countr_zeroIjEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  123|  85.6M|    countr_zero(T x) noexcept {
  124|  85.6M|  return numeric_internal::CountTrailingZeroes(x);
  125|  85.6M|}

_ZN4absl12lts_202605267uint128mLES1_:
  646|  95.5M|inline uint128& uint128::operator*=(uint128 other) {
  647|  95.5M|  *this = *this * other;
  648|  95.5M|  return *this;
  649|  95.5M|}
_ZN4absl12lts_2026052612Uint128Low64ENS0_7uint128E:
  661|  95.5M|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl12lts_2026052613Uint128High64ENS0_7uint128E:
  663|  95.5M|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZNK4absl12lts_202605267uint128cvmEv:
  777|     31|constexpr uint128::operator unsigned long() const {  // NOLINT(runtime/int)
  778|     31|  return static_cast<unsigned long>(lo_);            // NOLINT(runtime/int)
  779|     31|}
_ZNK4absl12lts_202605267uint128cvoEv:
  794|   191M|constexpr uint128::operator unsigned __int128() const {
  795|   191M|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  796|   191M|}
_ZN4absl12lts_20260526rsENS0_7uint128Ei:
  974|     62|constexpr uint128 operator>>(uint128 lhs, int amount) {
  975|     62|#ifdef ABSL_HAVE_INTRINSIC_INT128
  976|     62|  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|     62|}
_ZN4absl12lts_20260526mlENS0_7uint128ES1_:
 1059|  95.5M|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|  95.5M|  return static_cast<unsigned __int128>(lhs) *
 1063|  95.5M|         static_cast<unsigned __int128>(rhs);
 1064|  95.5M|}
_ZN4absl12lts_202605267uint128C2Eo:
  692|  95.5M|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  693|  95.5M|      hi_{static_cast<uint64_t>(v >> 64)} {}
_ZN4absl12lts_202605267uint128C2Em:
  683|   191M|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}

_ZN4absl12lts_2026052616numeric_internal20CountLeadingZeroes64Em:
  214|  19.6k|CountLeadingZeroes64(uint64_t x) {
  215|  19.6k|#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|  19.6k|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  221|  19.6k|                "__builtin_clzll does not take 64-bit arg");
  222|       |
  223|       |  // Handle 0 as a special case because __builtin_clzll(0) is undefined.
  224|  19.6k|  return x == 0 ? 64 : __builtin_clzll(x);
  ------------------
  |  Branch (224:10): [True: 0, False: 19.6k]
  ------------------
  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|  19.6k|}
_ZN4absl12lts_2026052616numeric_internal28CountTrailingZeroesNonzero32Ej:
  285|  85.6M|CountTrailingZeroesNonzero32(uint32_t x) {
  286|  85.6M|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctz)
  287|  85.6M|  static_assert(sizeof(unsigned int) == sizeof(x),
  288|  85.6M|                "__builtin_ctz does not take 32-bit arg");
  289|  85.6M|  return __builtin_ctz(x);
  290|       |#elif defined(_MSC_VER) && !defined(__clang__)
  291|       |  unsigned long result = 0;  // NOLINT(runtime/int)
  292|       |  _BitScanForward(&result, x);
  293|       |  return result;
  294|       |#else
  295|       |  int c = 31;
  296|       |  x &= ~x + 1;
  297|       |  if (x & 0x0000FFFF) c -= 16;
  298|       |  if (x & 0x00FF00FF) c -= 8;
  299|       |  if (x & 0x0F0F0F0F) c -= 4;
  300|       |  if (x & 0x33333333) c -= 2;
  301|       |  if (x & 0x55555555) c -= 1;
  302|       |  return c;
  303|       |#endif
  304|  85.6M|}
_ZN4absl12lts_2026052616numeric_internal28CountTrailingZeroesNonzero64Em:
  307|  2.22M|CountTrailingZeroesNonzero64(uint64_t x) {
  308|  2.22M|#if ABSL_NUMERIC_INTERNAL_HAVE_BUILTIN_OR_GCC(__builtin_ctzll)
  309|  2.22M|  static_assert(sizeof(unsigned long long) == sizeof(x),  // NOLINT(runtime/int)
  310|  2.22M|                "__builtin_ctzll does not take 64-bit arg");
  311|  2.22M|  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|  2.22M|}
_ZN4absl12lts_2026052616numeric_internal18CountLeadingZeroesImEEiT_:
  268|  19.6k|CountLeadingZeroes(T x) {
  269|  19.6k|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  270|  19.6k|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  271|  19.6k|                "T must have a power-of-2 size");
  272|  19.6k|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  273|  19.6k|  return sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (273:10): [Folded, False: 19.6k]
  ------------------
  274|  19.6k|             ? CountLeadingZeroes16(static_cast<uint16_t>(x)) -
  275|      0|                   (std::numeric_limits<uint16_t>::digits -
  276|      0|                    std::numeric_limits<T>::digits)
  277|  19.6k|             : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (277:17): [Folded, False: 19.6k]
  ------------------
  278|  19.6k|                    ? CountLeadingZeroes32(static_cast<uint32_t>(x)) -
  279|      0|                          (std::numeric_limits<uint32_t>::digits -
  280|      0|                           std::numeric_limits<T>::digits)
  281|  19.6k|                    : CountLeadingZeroes64(x));
  282|  19.6k|}
_ZN4absl12lts_2026052616numeric_internal19CountTrailingZeroesImEEiT_:
  353|  2.22M|CountTrailingZeroes(T x) noexcept {
  354|  2.22M|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  355|  2.22M|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  356|  2.22M|                "T must have a power-of-2 size");
  357|  2.22M|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  358|  2.22M|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (358:10): [True: 0, False: 2.22M]
  ------------------
  359|  2.22M|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (359:20): [Folded, False: 2.22M]
  ------------------
  360|  2.22M|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  361|  2.22M|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (361:27): [Folded, False: 2.22M]
  ------------------
  362|  2.22M|                              ? CountTrailingZeroesNonzero32(
  363|      0|                                    static_cast<uint32_t>(x))
  364|  2.22M|                              : CountTrailingZeroesNonzero64(x)));
  365|  2.22M|}
_ZN4absl12lts_2026052616numeric_internal19CountTrailingZeroesIjEEiT_:
  353|  85.6M|CountTrailingZeroes(T x) noexcept {
  354|  85.6M|  static_assert(std::is_unsigned<T>::value, "T must be unsigned");
  355|  85.6M|  static_assert(IsPowerOf2(std::numeric_limits<T>::digits),
  356|  85.6M|                "T must have a power-of-2 size");
  357|  85.6M|  static_assert(sizeof(T) <= sizeof(uint64_t), "T too large");
  358|  85.6M|  return x == 0 ? std::numeric_limits<T>::digits
  ------------------
  |  Branch (358:10): [True: 0, False: 85.6M]
  ------------------
  359|  85.6M|                : (sizeof(T) <= sizeof(uint16_t)
  ------------------
  |  Branch (359:20): [Folded, False: 85.6M]
  ------------------
  360|  85.6M|                       ? CountTrailingZeroesNonzero16(static_cast<uint16_t>(x))
  361|  85.6M|                       : (sizeof(T) <= sizeof(uint32_t)
  ------------------
  |  Branch (361:27): [True: 85.6M, Folded]
  ------------------
  362|  85.6M|                              ? CountTrailingZeroesNonzero32(
  363|  85.6M|                                    static_cast<uint32_t>(x))
  364|  85.6M|                              : CountTrailingZeroesNonzero64(x)));
  365|  85.6M|}

_ZN4absl12lts_2026052615random_internal17RandenPoolSeedSeq4sizeEv:
   66|  8.53k|  size_t size() { return 0; }
_ZN4absl12lts_2026052615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEC2INSt3__18seed_seqEvEEOT_:
  112|  1.25k|      : urbg_(ConstructURBG(std::forward<SSeq>(seq))) {}
_ZN4absl12lts_2026052615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEE13ConstructURBGINSt3__18seed_seqEEES4_OT_:
  147|  1.25k|  static URBG ConstructURBG(SSeq&& seq) {  // NOLINT(runtime/references)
  148|  1.25k|    auto salted_seq =
  149|  1.25k|        random_internal::MakeSaltedSeedSeq(std::forward<SSeq>(seq));
  150|  1.25k|    return URBG(salted_seq);
  151|  1.25k|  }
_ZN4absl12lts_2026052615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEEC2Ev:
  100|  8.53k|  NonsecureURBGBase() : urbg_(ConstructURBG()) {}
_ZN4absl12lts_2026052615random_internal17NonsecureURBGBaseINS1_13randen_engineImEENS1_17RandenPoolSeedSeqEE13ConstructURBGEv:
  141|  8.53k|  static URBG ConstructURBG() {
  142|  8.53k|    Seeder seeder;
  143|  8.53k|    return URBG(seeder);
  144|  8.53k|  }
_ZN4absl12lts_2026052615random_internal17RandenPoolSeedSeq8generateIPjEEvT_S5_:
   72|  8.53k|  void generate(RandomAccessIterator begin, RandomAccessIterator end) {
   73|       |    // RandomAccessIterator must be assignable from uint32_t
   74|  8.53k|    if (begin != end) {
  ------------------
  |  Branch (74:9): [True: 8.53k, False: 0]
  ------------------
   75|  8.53k|      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|  8.53k|      using TagType = std::conditional_t<
   82|  8.53k|          (std::is_pointer<RandomAccessIterator>::value ||
   83|  8.53k|           std::is_same<RandomAccessIterator,
   84|  8.53k|                        typename std::vector<U>::iterator>::value),
   85|  8.53k|          ContiguousTag, BufferTag>;
   86|       |
   87|  8.53k|      generate_impl(TagType{}, begin, end);
   88|  8.53k|    }
   89|  8.53k|  }
_ZN4absl12lts_2026052615random_internal17RandenPoolSeedSeq13generate_implIPjEEvNS2_13ContiguousTagET_S6_:
   46|  8.53k|  void generate_impl(ContiguousTag, Contiguous begin, Contiguous end) {
   47|  8.53k|    const size_t n = static_cast<size_t>(std::distance(begin, end));
   48|  8.53k|    auto* a = &(*begin);
   49|  8.53k|    GetEntropyFromRandenPool(a, sizeof(*a) * n);
   50|  8.53k|  }

_ZNK4absl12lts_2026052615random_internal6Randen8GenerateEPv:
   47|  1.13k|  inline void Generate(void* state) const {
   48|  1.13k|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   49|       |    // HW AES Dispatch.
   50|  1.13k|    if (has_crypto_) {
  ------------------
  |  Branch (50:9): [True: 0, False: 1.13k]
  ------------------
   51|      0|      RandenHwAes::Generate(keys_, state);
   52|  1.13k|    } else {
   53|  1.13k|      RandenSlow::Generate(keys_, state);
   54|  1.13k|    }
   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.13k|  }
_ZNK4absl12lts_2026052615random_internal6Randen6AbsorbEPKvPv:
   68|  9.79k|  inline void Absorb(const void* seed, void* state) const {
   69|  9.79k|#if ABSL_RANDOM_INTERNAL_AES_DISPATCH
   70|       |    // HW AES Dispatch.
   71|  9.79k|    if (has_crypto_) {
  ------------------
  |  Branch (71:9): [True: 0, False: 9.79k]
  ------------------
   72|      0|      RandenHwAes::Absorb(seed, state);
   73|  9.79k|    } else {
   74|  9.79k|      RandenSlow::Absorb(seed, state);
   75|  9.79k|    }
   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|  9.79k|  }

_ZN4absl12lts_2026052615random_internal13randen_engineImEC2IRNS1_13SaltedSeedSeqINSt3__18seed_seqEEEvEEOT_:
   68|  1.25k|  explicit randen_engine(SeedSequence&& seq) {
   69|  1.25k|    seed(seq);
   70|  1.25k|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImE4seedIRNS1_13SaltedSeedSeqINSt3__18seed_seqEEEEENS6_9enable_ifIXntsr3std14is_convertibleIT_mEE5valueEvE4typeEOSB_:
   98|  1.25k|  seed(SeedSequence&& seq) {
   99|       |    // Zeroes the state.
  100|  1.25k|    seed();
  101|  1.25k|    reseed(seq);
  102|  1.25k|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImE4seedEm:
  104|  9.79k|  void seed(result_type seed_value = 0) {
  105|  9.79k|    next_ = kStateSizeT;
  106|       |    // Zeroes the inner state and fills the outer state with seed_value to
  107|       |    // mimic the behaviour of reseed
  108|  9.79k|    auto* begin = state();
  109|  9.79k|    std::fill(begin, begin + kCapacityT, 0);
  110|  9.79k|    std::fill(begin + kCapacityT, begin + kStateSizeT, seed_value);
  111|  9.79k|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImE5stateEv:
  245|  19.5k|  result_type* state() {
  246|  19.5k|    return reinterpret_cast<result_type*>(
  247|  19.5k|        (reinterpret_cast<uintptr_t>(&raw_state_) & 0xf) ? (raw_state_ + 8)
  ------------------
  |  Branch (247:9): [True: 0, False: 19.5k]
  ------------------
  248|  19.5k|                                                         : raw_state_);
  249|  19.5k|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImE6reseedINS1_13SaltedSeedSeqINSt3__18seed_seqEEEEEvRT_:
  117|  1.25k|  void reseed(SeedSequence& seq) {
  118|  1.25k|    using sequence_result_type = typename SeedSequence::result_type;
  119|  1.25k|    static_assert(sizeof(sequence_result_type) == 4,
  120|  1.25k|                  "SeedSequence::result_type must be 32-bit");
  121|  1.25k|    constexpr size_t kBufferSize =
  122|  1.25k|        Randen::kSeedBytes / sizeof(sequence_result_type);
  123|  1.25k|    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.25k|    const size_t entropy_size = seq.size();
  131|  1.25k|    if (entropy_size < kBufferSize) {
  ------------------
  |  Branch (131:9): [True: 1.25k, False: 0]
  ------------------
  132|       |      // ... and only request that many values, or 256-bits, when unspecified.
  133|  1.25k|      const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
  ------------------
  |  Branch (133:40): [True: 0, False: 1.25k]
  ------------------
  134|  1.25k|      std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
  135|  1.25k|      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.25k|      size_t dst = kBufferSize;
  150|  10.0k|      while (dst > 7) {
  ------------------
  |  Branch (150:14): [True: 8.80k, False: 1.25k]
  ------------------
  151|       |        // leave the odd bucket as-is.
  152|  8.80k|        dst -= 4;
  153|  8.80k|        size_t src = dst >> 1;
  154|       |        // swap 128-bits into the even bucket
  155|  8.80k|        std::swap(buffer[--dst], buffer[--src]);
  156|  8.80k|        std::swap(buffer[--dst], buffer[--src]);
  157|  8.80k|        std::swap(buffer[--dst], buffer[--src]);
  158|  8.80k|        std::swap(buffer[--dst], buffer[--src]);
  159|  8.80k|      }
  160|  1.25k|    } else {
  161|      0|      seq.generate(buffer, buffer + kBufferSize);
  162|      0|    }
  163|  1.25k|    impl_.Absorb(buffer, state());
  164|       |
  165|       |    // Generate will be called when operator() is called
  166|  1.25k|    next_ = kStateSizeT;
  167|  1.25k|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImEC2IRNS1_17RandenPoolSeedSeqEvEEOT_:
   68|  8.53k|  explicit randen_engine(SeedSequence&& seq) {
   69|  8.53k|    seed(seq);
   70|  8.53k|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImE4seedIRNS1_17RandenPoolSeedSeqEEENSt3__19enable_ifIXntsr3std14is_convertibleIT_mEE5valueEvE4typeEOS9_:
   98|  8.53k|  seed(SeedSequence&& seq) {
   99|       |    // Zeroes the state.
  100|  8.53k|    seed();
  101|  8.53k|    reseed(seq);
  102|  8.53k|  }
_ZN4absl12lts_2026052615random_internal13randen_engineImE6reseedINS1_17RandenPoolSeedSeqEEEvRT_:
  117|  8.53k|  void reseed(SeedSequence& seq) {
  118|  8.53k|    using sequence_result_type = typename SeedSequence::result_type;
  119|  8.53k|    static_assert(sizeof(sequence_result_type) == 4,
  120|  8.53k|                  "SeedSequence::result_type must be 32-bit");
  121|  8.53k|    constexpr size_t kBufferSize =
  122|  8.53k|        Randen::kSeedBytes / sizeof(sequence_result_type);
  123|  8.53k|    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|  8.53k|    const size_t entropy_size = seq.size();
  131|  8.53k|    if (entropy_size < kBufferSize) {
  ------------------
  |  Branch (131:9): [True: 8.53k, False: 0]
  ------------------
  132|       |      // ... and only request that many values, or 256-bits, when unspecified.
  133|  8.53k|      const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
  ------------------
  |  Branch (133:40): [True: 8.53k, False: 0]
  ------------------
  134|  8.53k|      std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
  135|  8.53k|      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|  8.53k|      size_t dst = kBufferSize;
  150|  68.3k|      while (dst > 7) {
  ------------------
  |  Branch (150:14): [True: 59.7k, False: 8.53k]
  ------------------
  151|       |        // leave the odd bucket as-is.
  152|  59.7k|        dst -= 4;
  153|  59.7k|        size_t src = dst >> 1;
  154|       |        // swap 128-bits into the even bucket
  155|  59.7k|        std::swap(buffer[--dst], buffer[--src]);
  156|  59.7k|        std::swap(buffer[--dst], buffer[--src]);
  157|  59.7k|        std::swap(buffer[--dst], buffer[--src]);
  158|  59.7k|        std::swap(buffer[--dst], buffer[--src]);
  159|  59.7k|      }
  160|  8.53k|    } else {
  161|      0|      seq.generate(buffer, buffer + kBufferSize);
  162|      0|    }
  163|  8.53k|    impl_.Absorb(buffer, state());
  164|       |
  165|       |    // Generate will be called when operator() is called
  166|  8.53k|    next_ = kStateSizeT;
  167|  8.53k|  }

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

_ZNK4absl12lts_2026052615status_internal9StatusRep3RefEv:
   92|     11|  void Ref() const { ref_.fetch_add(1, std::memory_order_relaxed); }

_ZN4absl12lts_202605266StatusC2Em:
  714|   804k|  explicit Status(uintptr_t rep) : rep_(rep) {}
_ZN4absl12lts_202605266StatusaSEOS1_:
  918|  34.1k|inline Status& Status::operator=(Status&& x) noexcept {
  919|  34.1k|  uintptr_t old_rep = rep_;
  920|  34.1k|  if (x.rep_ != old_rep) {
  ------------------
  |  Branch (920:7): [True: 11, False: 34.1k]
  ------------------
  921|     11|    rep_ = x.rep_;
  922|     11|    x.rep_ = MovedFromRep();
  923|     11|    Unref(old_rep);
  924|     11|  }
  925|  34.1k|  return *this;
  926|  34.1k|}
_ZNK4absl12lts_202605266Status2okEv:
  942|   447k|inline bool Status::ok() const {
  943|   447k|  return rep_ == CodeToInlinedRep(absl::StatusCode::kOk);
  944|   447k|}
_ZNK4absl12lts_202605266Status7messageEv:
  955|  4.23k|inline absl::string_view Status::message() const {
  956|  4.23k|  return !IsInlined(rep_)
  ------------------
  |  Branch (956:10): [True: 0, False: 4.23k]
  ------------------
  957|  4.23k|             ? RepToPointer(rep_)->message()
  958|  4.23k|             : (IsMovedFrom(rep_) ? absl::string_view(kMovedFromString)
  ------------------
  |  Branch (958:17): [True: 0, False: 4.23k]
  ------------------
  959|  4.23k|                                  : absl::string_view());
  960|  4.23k|}
_ZNK4absl12lts_202605266Status11IgnoreErrorEv:
  977|  58.9k|inline void Status::IgnoreError() const {
  978|       |  // no-op
  979|  58.9k|}
_ZN4absl12lts_202605266Status11IsMovedFromEm:
 1016|  4.23k|constexpr bool Status::IsMovedFrom(uintptr_t rep) { return (rep & 2) != 0; }
_ZN4absl12lts_202605266Status16CodeToInlinedRepENS0_10StatusCodeE:
 1018|  1.05M|constexpr uintptr_t Status::CodeToInlinedRep(absl::StatusCode code) {
 1019|  1.05M|  return (static_cast<uintptr_t>(code) << 2) + 1;
 1020|  1.05M|}
_ZN4absl12lts_202605266Status12MovedFromRepEv:
 1027|   317k|constexpr uintptr_t Status::MovedFromRep() {
 1028|   317k|  return CodeToInlinedRep(absl::StatusCode::kInternal) | 2;
 1029|   317k|}
_ZN4absl12lts_202605266Status3RefEm:
 1042|   193k|inline void Status::Ref(uintptr_t rep) {
 1043|   193k|  if (!IsInlined(rep)) RepToPointer(rep)->Ref();
  ------------------
  |  Branch (1043:7): [True: 11, False: 193k]
  ------------------
 1044|   193k|}
_ZN4absl12lts_202605268OkStatusEv:
 1050|   271k|inline Status OkStatus() { return Status(); }
_ZN4absl12lts_2026052613InternalErrorENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEENS0_14SourceLocationE:
 1129|      5|                            absl::SourceLocation loc) {
 1130|      5|  return status_internal::MakeError<StatusCode::kInternal>(message, loc);
 1131|      5|}
_ZN4absl12lts_2026052615status_internal9MakeErrorILNS0_10StatusCodeE13EEENS0_6StatusENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS0_14SourceLocationE:
 1090|      5|Status MakeError(string_view message, SourceLocation loc) {
 1091|      5|  Status out = MakeErrorImpl<static_cast<int>(error_code)>(message, loc);
 1092|       |  // -Wassume warning complains about potential side effects of `ok()`, so use a
 1093|       |  // local to avoid that.
 1094|      5|  ABSL_ATTRIBUTE_UNUSED bool ok = out.ok();
  ------------------
  |  |  582|      5|#define ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))
  ------------------
 1095|      5|  ABSL_ASSUME(!ok);
  ------------------
  |  |  271|      5|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1096|      5|  return out;
 1097|      5|}
_ZN4absl12lts_202605266StatusC2EOS1_:
  914|   317k|inline Status::Status(Status&& x) noexcept : Status(x.rep_) {
  915|   317k|  x.rep_ = MovedFromRep();
  916|   317k|}
_ZN4absl12lts_202605266StatusC2ENS0_10StatusCodeENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS0_14SourceLocationE:
  900|  4.23k|    : Status(MakeRep(CodeToInlinedRep(code), msg, loc)) {}
_ZN4absl12lts_202605266StatusC2Ev:
  894|   285k|inline Status::Status() : Status(absl::StatusCode::kOk) {}
_ZN4absl12lts_202605266StatusC2ENS0_10StatusCodeE:
  896|   285k|inline Status::Status(absl::StatusCode code) : Status(CodeToInlinedRep(code)) {}
_ZN4absl12lts_202605266StatusC2ERKS1_:
  902|   193k|inline Status::Status(const Status& x) : Status(x.rep_) { Ref(rep_); }

_ZN4absl12lts_2026052613StatusBuilderC2ENS0_10StatusCodeENS0_14SourceLocationE:
  765|  4.23k|    : loc_(location), rep_(InitRep(absl::Status(code, ""))) {}
_ZN4absl12lts_2026052613StatusBuilder7InitRepEONS0_6StatusE:
  672|  12.6k|  static Rep* InitRep(absl::Status&& s) {
  673|  12.6k|    if (s.ok()) {
  ------------------
  |  Branch (673:9): [True: 0, False: 12.6k]
  ------------------
  674|      0|      return nullptr;
  675|  12.6k|    } else {
  676|  12.6k|      Rep* rep = InitRepImpl(std::move(s));
  677|  12.6k|      ABSL_ASSUME(rep != nullptr);
  ------------------
  |  |  271|  12.6k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  678|  12.6k|      return rep;
  679|  12.6k|    }
  680|  12.6k|  }
_ZNO4absl12lts_2026052613StatusBuildercvNS0_6StatusEEv:
  946|  12.6k|inline StatusBuilder::operator absl::Status() && {
  947|       |  // Tell the compiler that the `ok()` path will return an `Ok` status, but do
  948|       |  // it only if the compiler can determine it at compile time.
  949|       |  // When it can't, we delegate this check into the out of line function.
  950|  12.6k|  if (IsKnownToBeEmpty()) {
  ------------------
  |  Branch (950:7): [True: 0, False: 12.6k]
  ------------------
  951|      0|    return absl::OkStatus();
  952|      0|  }
  953|  12.6k|  absl::Status result = CreateStatusAndConditionallyLog(loc_, std::move(rep_));
  954|       |  // Tell the compiler that `rep_` was not filled again even if `this` escaped.
  955|  12.6k|  AssumeEmpty();
  956|  12.6k|  return result;
  957|  12.6k|}
_ZNK4absl12lts_2026052613StatusBuilder16IsKnownToBeEmptyEv:
  570|  25.3k|  ABSL_ATTRIBUTE_ALWAYS_INLINE bool IsKnownToBeEmpty() const {
  571|  25.3k|#if ABSL_HAVE_BUILTIN(__builtin_constant_p)
  572|       |    // __builtin_constant_p does not like it when it has non trivial expressions
  573|       |    // in it, and `rep_==nullptr` is a user-defined operator.
  574|       |    // Do it out of the builtin and pass the bool instead.
  575|  25.3k|    bool is_empty = rep_ == nullptr;
  576|  25.3k|    return __builtin_constant_p(is_empty) && is_empty;
  ------------------
  |  Branch (576:12): [True: 4.22k, False: 21.1k]
  |  Branch (576:46): [True: 4.22k, False: 0]
  ------------------
  577|       |#else
  578|       |    return false;
  579|       |#endif
  580|  25.3k|  }
_ZNK4absl12lts_2026052613StatusBuilder11AssumeEmptyEv:
  584|  21.1k|  void AssumeEmpty() const {
  585|  21.1k|    if (rep_ != nullptr) ABSL_UNREACHABLE();
  ------------------
  |  |  237|      0|  do {                                           \
  |  |  238|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  239|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  240|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  ------------------
  |  |  |  |  215|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  ------------------
  |  |  241|      0|  } while (false)
  |  |  ------------------
  |  |  |  Branch (241:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  |  Branch (585:9): [True: 0, False: 21.1k]
  ------------------
  586|  21.1k|  }
_ZN4absl12lts_2026052613StatusBuilderD2Ev:
  777|  12.6k|inline StatusBuilder::~StatusBuilder() {
  778|  12.6k|  if (IsKnownToBeEmpty()) {
  ------------------
  |  Branch (778:7): [True: 4.22k, False: 8.44k]
  ------------------
  779|       |    // Nothing to do.
  780|  4.22k|    return;
  781|  4.22k|  }
  782|       |  // We will run the destructor logic, so move it out of line.
  783|       |  // The destructor of the unique_ptr runs ~Rep() and then ::operator delete.
  784|       |  // We don't want that bloat on the caller.
  785|  8.44k|  Destroy(std::move(rep_));
  786|       |  // Tell the compiler that `rep_` was not filled again even if `this` escaped.
  787|  8.44k|  AssumeEmpty();
  788|  8.44k|}
_ZN4absl12lts_2026052613StatusBuilderC2EONS0_6StatusENS0_14SourceLocationE:
  775|  8.43k|    : loc_(location), rep_(InitRep(std::move(original_status))) {}
_ZNO4absl12lts_2026052613StatusBuilderlsIA2_cEEOS1_RKT_:
  921|  4.23k|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|  4.23k|  return std::move(operator<<(value));
  923|  4.23k|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA2_cEERS1_RKT_:
  911|  4.23k|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|  4.23k|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 4.23k]
  ------------------
  913|  4.23k|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 4.23k]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|  4.23k|  *rep_->stream << value;
  917|  4.23k|  return *this;
  918|  4.23k|}
_ZN4absl12lts_2026052615status_internallsIA2_cEERNS1_6StreamES5_RKT_:
   60|  4.23k|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|  4.23k|    stream.absl_stringify_stream_ << t;
   62|  4.23k|    return stream;
   63|  4.23k|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIiEEOS1_RKT_:
  921|  4.30k|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|  4.30k|  return std::move(operator<<(value));
  923|  4.30k|}
_ZNR4absl12lts_2026052613StatusBuilderlsIiEERS1_RKT_:
  911|  4.30k|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|  4.30k|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 4.30k]
  ------------------
  913|  4.30k|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 4.30k]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|  4.30k|  *rep_->stream << value;
  917|  4.30k|  return *this;
  918|  4.30k|}
_ZN4absl12lts_2026052615status_internallsIiEERNS1_6StreamES4_RKT_:
   60|  4.30k|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|  4.30k|    stream.absl_stringify_stream_ << t;
   62|  4.30k|    return stream;
   63|  4.30k|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIA4_cEEOS1_RKT_:
  921|  4.23k|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|  4.23k|  return std::move(operator<<(value));
  923|  4.23k|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA4_cEERS1_RKT_:
  911|  4.23k|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|  4.23k|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 4.23k]
  ------------------
  913|  4.23k|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 4.23k]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|  4.23k|  *rep_->stream << value;
  917|  4.23k|  return *this;
  918|  4.23k|}
_ZN4absl12lts_2026052615status_internallsIA4_cEERNS1_6StreamES5_RKT_:
   60|  4.23k|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|  4.23k|    stream.absl_stringify_stream_ << t;
   62|  4.23k|    return stream;
   63|  4.23k|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIA3_cEEOS1_RKT_:
  921|  4.30k|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|  4.30k|  return std::move(operator<<(value));
  923|  4.30k|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA3_cEERS1_RKT_:
  911|  4.30k|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|  4.30k|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 4.30k]
  ------------------
  913|  4.30k|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 4.30k]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|  4.30k|  *rep_->stream << value;
  917|  4.30k|  return *this;
  918|  4.30k|}
_ZN4absl12lts_2026052615status_internallsIA3_cEERNS1_6StreamES5_RKT_:
   60|  4.30k|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|  4.30k|    stream.absl_stringify_stream_ << t;
   62|  4.30k|    return stream;
   63|  4.30k|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIA29_cEEOS1_RKT_:
  921|     81|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|     81|  return std::move(operator<<(value));
  923|     81|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA29_cEERS1_RKT_:
  911|     81|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|     81|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 81]
  ------------------
  913|     81|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 11, False: 70]
  ------------------
  914|     11|    rep_->InitStream();
  915|     11|  }
  916|     81|  *rep_->stream << value;
  917|     81|  return *this;
  918|     81|}
_ZN4absl12lts_2026052615status_internallsIA29_cEERNS1_6StreamES5_RKT_:
   60|     81|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|     81|    stream.absl_stringify_stream_ << t;
   62|     81|    return stream;
   63|     81|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIA20_cEEOS1_RKT_:
  921|     39|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|     39|  return std::move(operator<<(value));
  923|     39|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA20_cEERS1_RKT_:
  911|     39|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|     39|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 39]
  ------------------
  913|     39|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 39]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|     39|  *rep_->stream << value;
  917|     39|  return *this;
  918|     39|}
_ZN4absl12lts_2026052615status_internallsIA20_cEERNS1_6StreamES5_RKT_:
   60|     39|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|     39|    stream.absl_stringify_stream_ << t;
   62|     39|    return stream;
   63|     39|  }
_ZNR4absl12lts_2026052613StatusBuilderlsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERS1_RKT_:
  911|  4.10k|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|  4.10k|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 4.10k]
  ------------------
  913|  4.10k|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 4.10k]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|  4.10k|  *rep_->stream << value;
  917|  4.10k|  return *this;
  918|  4.10k|}
_ZN4absl12lts_2026052615status_internallsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERNS1_6StreamESB_RKT_:
   60|  4.10k|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|  4.10k|    stream.absl_stringify_stream_ << t;
   62|  4.10k|    return stream;
   63|  4.10k|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIA26_cEEOS1_RKT_:
  921|     29|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|     29|  return std::move(operator<<(value));
  923|     29|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA26_cEERS1_RKT_:
  911|     29|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|     29|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 29]
  ------------------
  913|     29|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 29, False: 0]
  ------------------
  914|     29|    rep_->InitStream();
  915|     29|  }
  916|     29|  *rep_->stream << value;
  917|     29|  return *this;
  918|     29|}
_ZN4absl12lts_2026052615status_internallsIA26_cEERNS1_6StreamES5_RKT_:
   60|     29|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|     29|    stream.absl_stringify_stream_ << t;
   62|     29|    return stream;
   63|     29|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIA5_cEEOS1_RKT_:
  921|     70|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|     70|  return std::move(operator<<(value));
  923|     70|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA5_cEERS1_RKT_:
  911|     70|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|     70|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 70]
  ------------------
  913|     70|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 70]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|     70|  *rep_->stream << value;
  917|     70|  return *this;
  918|     70|}
_ZN4absl12lts_2026052615status_internallsIA5_cEERNS1_6StreamES5_RKT_:
   60|     70|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|     70|    stream.absl_stringify_stream_ << t;
   62|     70|    return stream;
   63|     70|  }
_ZNO4absl12lts_2026052613StatusBuilderlsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEOS1_RKT_:
  921|  4.10k|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|  4.10k|  return std::move(operator<<(value));
  923|  4.10k|}
_ZNO4absl12lts_2026052613StatusBuilderlsIA84_cEEOS1_RKT_:
  921|      6|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|      6|  return std::move(operator<<(value));
  923|      6|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA84_cEERS1_RKT_:
  911|      6|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|      6|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 6]
  ------------------
  913|      6|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 6]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|      6|  *rep_->stream << value;
  917|      6|  return *this;
  918|      6|}
_ZN4absl12lts_2026052615status_internallsIA84_cEERNS1_6StreamES5_RKT_:
   60|      6|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|      6|    stream.absl_stringify_stream_ << t;
   62|      6|    return stream;
   63|      6|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIA25_cEEOS1_RKT_:
  921|  4.20k|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|  4.20k|  return std::move(operator<<(value));
  923|  4.20k|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA25_cEERS1_RKT_:
  911|  4.20k|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|  4.20k|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 4.20k]
  ------------------
  913|  4.20k|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 4.19k, False: 11]
  ------------------
  914|  4.19k|    rep_->InitStream();
  915|  4.19k|  }
  916|  4.20k|  *rep_->stream << value;
  917|  4.20k|  return *this;
  918|  4.20k|}
_ZN4absl12lts_2026052615status_internallsIA25_cEERNS1_6StreamES5_RKT_:
   60|  4.20k|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|  4.20k|    stream.absl_stringify_stream_ << t;
   62|  4.20k|    return stream;
   63|  4.20k|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIA61_cEEOS1_RKT_:
  921|  4.10k|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|  4.10k|  return std::move(operator<<(value));
  923|  4.10k|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA61_cEERS1_RKT_:
  911|  4.10k|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|  4.10k|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 4.10k]
  ------------------
  913|  4.10k|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 4.10k]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|  4.10k|  *rep_->stream << value;
  917|  4.10k|  return *this;
  918|  4.10k|}
_ZN4absl12lts_2026052615status_internallsIA61_cEERNS1_6StreamES5_RKT_:
   60|  4.10k|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|  4.10k|    stream.absl_stringify_stream_ << t;
   62|  4.10k|    return stream;
   63|  4.10k|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIA49_cEEOS1_RKT_:
  921|     70|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|     70|  return std::move(operator<<(value));
  923|     70|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA49_cEERS1_RKT_:
  911|     70|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|     70|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 70]
  ------------------
  913|     70|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 70]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|     70|  *rep_->stream << value;
  917|     70|  return *this;
  918|     70|}
_ZN4absl12lts_2026052615status_internallsIA49_cEERNS1_6StreamES5_RKT_:
   60|     70|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|     70|    stream.absl_stringify_stream_ << t;
   62|     70|    return stream;
   63|     70|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIA97_cEEOS1_RKT_:
  921|     70|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|     70|  return std::move(operator<<(value));
  923|     70|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA97_cEERS1_RKT_:
  911|     70|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|     70|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 70]
  ------------------
  913|     70|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 70]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|     70|  *rep_->stream << value;
  917|     70|  return *this;
  918|     70|}
_ZN4absl12lts_2026052615status_internallsIA97_cEERNS1_6StreamES5_RKT_:
   60|     70|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|     70|    stream.absl_stringify_stream_ << t;
   62|     70|    return stream;
   63|     70|  }
_ZNO4absl12lts_2026052613StatusBuilderlsImEEOS1_RKT_:
  921|     70|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|     70|  return std::move(operator<<(value));
  923|     70|}
_ZNR4absl12lts_2026052613StatusBuilderlsImEERS1_RKT_:
  911|     70|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|     70|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 70]
  ------------------
  913|     70|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 70]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|     70|  *rep_->stream << value;
  917|     70|  return *this;
  918|     70|}
_ZN4absl12lts_2026052615status_internallsImEERNS1_6StreamES4_RKT_:
   60|     70|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|     70|    stream.absl_stringify_stream_ << t;
   62|     70|    return stream;
   63|     70|  }
_ZNO4absl12lts_2026052613StatusBuilderlsIA57_cEEOS1_RKT_:
  921|     70|StatusBuilder&& StatusBuilder::operator<<(const T& value) && {
  922|     70|  return std::move(operator<<(value));
  923|     70|}
_ZNR4absl12lts_2026052613StatusBuilderlsIA57_cEERS1_RKT_:
  911|     70|StatusBuilder& StatusBuilder::operator<<(const T& value) & {
  912|     70|  if (rep_ == nullptr) return *this;
  ------------------
  |  Branch (912:7): [True: 0, False: 70]
  ------------------
  913|     70|  if (!rep_->stream.has_value()) {
  ------------------
  |  Branch (913:7): [True: 0, False: 70]
  ------------------
  914|      0|    rep_->InitStream();
  915|      0|  }
  916|     70|  *rep_->stream << value;
  917|     70|  return *this;
  918|     70|}
_ZN4absl12lts_2026052615status_internallsIA57_cEERNS1_6StreamES5_RKT_:
   60|     70|  friend Stream& operator<<(Stream& stream, const T& t) {
   61|     70|    stream.absl_stringify_stream_ << t;
   62|     70|    return stream;
   63|     70|  }

_ZN4absl12lts_2026052621status_macro_internal12MacroAdaptorEONS0_6StatusENS0_14SourceLocationE:
  444|   270k|                                         absl::SourceLocation loc) {
  445|   270k|  return ReturnIfErrorAdaptor(std::move(s), loc);
  446|   270k|}
_ZN4absl12lts_2026052621status_macro_internal20ReturnIfErrorAdaptorC2EONS0_6StatusENS0_14SourceLocationE:
  404|   270k|      : status_(std::move(status)), loc_(loc) {}
_ZNK4absl12lts_2026052621status_macro_internal20ReturnIfErrorAdaptorcvbEv:
  420|   270k|  explicit operator bool() const { return ABSL_PREDICT_TRUE(status_.ok()); }
  ------------------
  |  |  191|   270k|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (191:48): [Folded, False: 270k]
  |  |  |  Branch (191:57): [True: 262k, False: 8.43k]
  |  |  ------------------
  ------------------
_ZN4absl12lts_2026052621status_macro_internal20ReturnIfErrorAdaptor7ConsumeEv:
  422|  8.43k|  StatusBuilder Consume() { return StatusBuilder(std::move(status_), loc_); }
_ZN4absl12lts_2026052621status_macro_internal20ReturnIfErrorAdaptorD2Ev:
  406|   270k|  ~ReturnIfErrorAdaptor() {
  407|       |    // WARNING! WARNING! WARNING!
  408|       |    //
  409|       |    // We play fast and loose here and avoid destroying status_. This should be
  410|       |    // safe because status_ will never own memory at destruction time. The two
  411|       |    // cases to consider are:
  412|       |    //  (1) OK: OkStatus() representation needs no cleanup
  413|       |    //  (2) Not-OK: we take the else branch in ABSL_RETURN_IF_ERROR and move
  414|       |    //      status_ into StatusBuilder which leaves status_ with a MovedFromRep
  415|       |    //      that needs no cleanup.
  416|       |    // If the absl::Status implementation changes, leaks should be caught by
  417|       |    // the various tests we have when run under lsan or debug leak checker.
  418|   270k|  }

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

_ZN4absl12lts_2026052619str_format_internal14ExtractCharSetILNS0_23FormatConversionCharSetE655355EEES3_NS1_16ArgConvertResultIXT_EEE:
  206|  1.84M|constexpr FormatConversionCharSet ExtractCharSet(ArgConvertResult<C>) {
  207|  1.84M|  return C;
  208|  1.84M|}
_ZN4absl12lts_2026052619str_format_internal13FormatArgImplC2IiEERKT_:
  494|  1.84M|  explicit FormatArgImpl(const T& value) {
  495|  1.84M|    using D = typename DecayType<T>::type;
  496|  1.84M|    static_assert(
  497|  1.84M|        std::is_same<D, const T&>::value || storage_policy<D>::value == ByValue,
  498|  1.84M|        "Decayed types must be stored by value");
  499|  1.84M|    Init(static_cast<D>(value));
  500|  1.84M|  }
_ZN4absl12lts_2026052619str_format_internal13FormatArgImpl4InitIiEEvRKT_:
  547|  1.84M|  void Init(const T& value) {
  548|  1.84M|    data_ = Manager<T>::SetValue(value);
  549|  1.84M|    dispatcher_ = &Dispatch<T>;
  550|  1.84M|  }
_ZN4absl12lts_2026052619str_format_internal13FormatArgImpl7ManagerIiLNS2_13StoragePolicyE2EE8SetValueERKi:
  533|  1.84M|    static Data SetValue(const T& value) {
  534|  1.84M|      Data data;
  535|  1.84M|      memcpy(data.buf, &value, sizeof(value));
  536|  1.84M|      return data;
  537|  1.84M|    }
_ZN4absl12lts_2026052619str_format_internal13FormatArgImpl8DispatchIiEEbNS2_4DataENS1_24FormatConversionSpecImplEPv:
  588|  1.84M|  static bool Dispatch(Data arg, FormatConversionSpecImpl spec, void* out) {
  589|       |    // A `none` conv indicates that we want the `int` conversion.
  590|  1.84M|    if (ABSL_PREDICT_FALSE(spec.conversion_char() ==
  ------------------
  |  |  190|  1.84M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.84M]
  |  |  |  Branch (190:49): [Folded, False: 1.84M]
  |  |  |  Branch (190:58): [True: 0, False: 1.84M]
  |  |  ------------------
  ------------------
  591|  1.84M|                           FormatConversionCharInternal::kNone)) {
  592|      0|      return ToInt<T>(arg, static_cast<int*>(out), std::is_integral<T>(),
  593|      0|                      std::is_enum<T>());
  594|      0|    }
  595|  1.84M|    if (ABSL_PREDICT_FALSE(
  ------------------
  |  |  190|  1.84M|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (190:31): [True: 0, False: 1.84M]
  |  |  |  Branch (190:49): [Folded, False: 1.84M]
  |  |  |  Branch (190:58): [True: 0, False: 1.84M]
  |  |  ------------------
  ------------------
  596|  1.84M|            !Contains(ArgumentToConv<T>(), spec.conversion_char()))) {
  597|      0|      return false;
  598|      0|    }
  599|  1.84M|    return str_format_internal::FormatConvertImpl(
  600|  1.84M|               Manager<T>::Value(arg), spec, static_cast<FormatSinkImpl*>(out))
  601|  1.84M|        .value;
  602|  1.84M|  }
_ZN4absl12lts_2026052619str_format_internal14ArgumentToConvIiEENS0_23FormatConversionCharSetEv:
  420|  1.84M|constexpr FormatConversionCharSet ArgumentToConv() {
  421|  1.84M|  using ConvResult = decltype(str_format_internal::FormatConvertImpl(
  422|  1.84M|      std::declval<const Arg&>(),
  423|  1.84M|      std::declval<const FormatConversionSpecImpl&>(),
  424|  1.84M|      std::declval<FormatSinkImpl*>()));
  425|  1.84M|  return absl::str_format_internal::ExtractCharSet(ConvResult{});
  426|  1.84M|}
_ZN4absl12lts_2026052619str_format_internal13FormatArgImpl7ManagerIiLNS2_13StoragePolicyE2EE5ValueENS2_4DataE:
  539|  1.84M|    static T Value(Data arg) {
  540|  1.84M|      T value;
  541|  1.84M|      memcpy(&value, arg.buf, sizeof(T));
  542|  1.84M|      return value;
  543|  1.84M|    }

_ZN4absl12lts_2026052619str_format_internal21UntypedFormatSpecImplC2ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   56|   617k|      : data_(s.data()), size_(s.size()) {}
_ZN4absl12lts_2026052619str_format_internal21UntypedFormatSpecImpl7ExtractINS1_18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE655355EEEEEERKS2_RKT_:
   73|    256|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|    256|    return s.spec_;
   75|    256|  }
_ZN4absl12lts_2026052619str_format_internal18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE655355EEEC2EUa9enable_ifIXclL_ZNS1_15ValidFormatImplIJLS3_655355EEEEbNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEfL0p_EEEPKc:
  159|    256|      : Base(s) {}
_ZN4absl12lts_2026052619str_format_internal21UntypedFormatSpecImpl7ExtractINS1_18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE655355ELS5_655355EEEEEERKS2_RKT_:
   73|  4.10k|  static const UntypedFormatSpecImpl& Extract(const T& s) {
   74|  4.10k|    return s.spec_;
   75|  4.10k|  }
_ZN4absl12lts_2026052619str_format_internal18FormatSpecTemplateIJLNS0_23FormatConversionCharSetE655355ELS3_655355EEEC2EUa9enable_ifIXclL_ZNS1_15ValidFormatImplIJLS3_655355ELS3_655355EEEEbNSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEfL0p_EEEPKc:
  159|  4.10k|      : Base(s) {}

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

_ZN4absl12lts_2026052616strings_internal23ConvertibleToStringViewC2ENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   69|  8.54k|      : value_(s) {}
_ZNK4absl12lts_2026052616strings_internal23ConvertibleToStringView5valueEv:
   77|  8.54k|  absl::string_view value() const { return value_; }
_ZN4absl12lts_2026052616strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEC2ES9_S3_S4_:
  295|  8.54k|      : text_(std::move(input_text)),
  296|  8.54k|        delimiter_(std::move(d)),
  297|  8.54k|        predicate_(std::move(p)) {}
_ZNK4absl12lts_2026052616strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE5beginEv:
  306|  8.54k|  const_iterator begin() const { return {const_iterator::kInitState, this}; }
_ZN4absl12lts_2026052616strings_internal13SplitIteratorINS1_8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEC2ENSC_5StateEPKSB_:
  100|  17.0k|      : pos_(0),
  101|  17.0k|        state_(state),
  102|  17.0k|        splitter_(splitter),
  103|  17.0k|        delimiter_(splitter->delimiter()),
  104|  17.0k|        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|  17.0k|    if (splitter_->text().data() == nullptr) {
  ------------------
  |  Branch (114:9): [True: 0, False: 17.0k]
  ------------------
  115|      0|      state_ = kEndState;
  116|      0|      pos_ = splitter_->text().size();
  117|      0|      return;
  118|      0|    }
  119|       |
  120|  17.0k|    if (state_ == kEndState) {
  ------------------
  |  Branch (120:9): [True: 8.54k, False: 8.54k]
  ------------------
  121|  8.54k|      pos_ = splitter_->text().size();
  122|  8.54k|    } else {
  123|  8.54k|      ++(*this);
  124|  8.54k|    }
  125|  17.0k|  }
_ZNK4absl12lts_2026052616strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE9delimiterEv:
  300|  17.0k|  const Delimiter& delimiter() const { return delimiter_; }
_ZNK4absl12lts_2026052616strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE9predicateEv:
  301|  17.0k|  const Predicate& predicate() const { return predicate_; }
_ZNK4absl12lts_2026052616strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE4textEv:
  299|  66.4k|  absl::string_view text() const { return text_; }
_ZNK4absl12lts_2026052616strings_internal8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEE3endEv:
  307|  8.54k|  const_iterator end() const { return {const_iterator::kEndState, this}; }
_ZN4absl12lts_2026052616strings_internalneERKNS1_13SplitIteratorINS1_8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEESE_:
  158|  49.3k|  friend bool operator!=(const SplitIterator& a, const SplitIterator& b) {
  159|  49.3k|    return !(a == b);
  160|  49.3k|  }
_ZN4absl12lts_2026052616strings_internaleqERKNS1_13SplitIteratorINS1_8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEESE_:
  154|  49.3k|  friend bool operator==(const SplitIterator& a, const SplitIterator& b) {
  155|  49.3k|    return a.state_ == b.state_ && a.pos_ == b.pos_;
  ------------------
  |  Branch (155:12): [True: 8.54k, False: 40.8k]
  |  Branch (155:36): [True: 8.54k, False: 0]
  ------------------
  156|  49.3k|  }
_ZN4absl12lts_2026052616strings_internal13SplitIteratorINS1_8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEppEv:
  132|  49.3k|  SplitIterator& operator++() {
  133|  49.3k|    do {
  134|  49.3k|      if (state_ == kLastState) {
  ------------------
  |  Branch (134:11): [True: 8.54k, False: 40.8k]
  ------------------
  135|  8.54k|        state_ = kEndState;
  136|  8.54k|        return *this;
  137|  8.54k|      }
  138|  40.8k|      const absl::string_view text = splitter_->text();
  139|  40.8k|      const absl::string_view d = delimiter_.Find(text, pos_);
  140|  40.8k|      if (d.data() == text.data() + text.size()) state_ = kLastState;
  ------------------
  |  Branch (140:11): [True: 8.54k, False: 32.2k]
  ------------------
  141|  40.8k|      curr_ = text.substr(pos_,
  142|  40.8k|                          static_cast<size_t>(d.data() - (text.data() + pos_)));
  143|  40.8k|      pos_ += curr_.size() + d.size();
  144|  40.8k|    } while (!predicate_(curr_));
  ------------------
  |  Branch (144:14): [True: 0, False: 40.8k]
  ------------------
  145|  40.8k|    return *this;
  146|  49.3k|  }
_ZNK4absl12lts_2026052616strings_internal13SplitIteratorINS1_8SplitterINS0_8ByStringENS0_10AllowEmptyENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEEdeEv:
  129|  40.8k|  reference operator*() const { return curr_; }

_ZN4absl12lts_2026052616strings_internallsIA2_cEERNS1_15StringifyStreamES5_RKT_:
   69|  4.23k|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|  4.23k|    if constexpr (HasStreamInsertion<T>::value) {
   71|  4.23k|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|  4.23k|    return stream;
   76|  4.23k|  }
_ZN4absl12lts_2026052616strings_internallsIiEERNS1_15StringifyStreamES4_RKT_:
   69|  4.30k|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|  4.30k|    if constexpr (HasStreamInsertion<T>::value) {
   71|  4.30k|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|  4.30k|    return stream;
   76|  4.30k|  }
_ZN4absl12lts_2026052616strings_internallsIA4_cEERNS1_15StringifyStreamES5_RKT_:
   69|  4.23k|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|  4.23k|    if constexpr (HasStreamInsertion<T>::value) {
   71|  4.23k|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|  4.23k|    return stream;
   76|  4.23k|  }
_ZN4absl12lts_2026052616strings_internallsIA3_cEERNS1_15StringifyStreamES5_RKT_:
   69|  4.30k|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|  4.30k|    if constexpr (HasStreamInsertion<T>::value) {
   71|  4.30k|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|  4.30k|    return stream;
   76|  4.30k|  }
_ZN4absl12lts_2026052616strings_internallsIA29_cEERNS1_15StringifyStreamES5_RKT_:
   69|     81|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|     81|    if constexpr (HasStreamInsertion<T>::value) {
   71|     81|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|     81|    return stream;
   76|     81|  }
_ZN4absl12lts_2026052616strings_internallsIA20_cEERNS1_15StringifyStreamES5_RKT_:
   69|     39|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|     39|    if constexpr (HasStreamInsertion<T>::value) {
   71|     39|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|     39|    return stream;
   76|     39|  }
_ZN4absl12lts_2026052616strings_internallsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERNS1_15StringifyStreamESB_RKT_:
   69|  4.10k|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|  4.10k|    if constexpr (HasStreamInsertion<T>::value) {
   71|  4.10k|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|  4.10k|    return stream;
   76|  4.10k|  }
_ZN4absl12lts_2026052616strings_internallsIA26_cEERNS1_15StringifyStreamES5_RKT_:
   69|     29|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|     29|    if constexpr (HasStreamInsertion<T>::value) {
   71|     29|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|     29|    return stream;
   76|     29|  }
_ZN4absl12lts_2026052616strings_internallsIA5_cEERNS1_15StringifyStreamES5_RKT_:
   69|     70|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|     70|    if constexpr (HasStreamInsertion<T>::value) {
   71|     70|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|     70|    return stream;
   76|     70|  }
_ZN4absl12lts_2026052616strings_internallsIA84_cEERNS1_15StringifyStreamES5_RKT_:
   69|      6|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|      6|    if constexpr (HasStreamInsertion<T>::value) {
   71|      6|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|      6|    return stream;
   76|      6|  }
_ZN4absl12lts_2026052616strings_internallsIA25_cEERNS1_15StringifyStreamES5_RKT_:
   69|  4.20k|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|  4.20k|    if constexpr (HasStreamInsertion<T>::value) {
   71|  4.20k|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|  4.20k|    return stream;
   76|  4.20k|  }
_ZN4absl12lts_2026052616strings_internallsIA61_cEERNS1_15StringifyStreamES5_RKT_:
   69|  4.10k|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|  4.10k|    if constexpr (HasStreamInsertion<T>::value) {
   71|  4.10k|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|  4.10k|    return stream;
   76|  4.10k|  }
_ZN4absl12lts_2026052616strings_internallsIA49_cEERNS1_15StringifyStreamES5_RKT_:
   69|     70|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|     70|    if constexpr (HasStreamInsertion<T>::value) {
   71|     70|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|     70|    return stream;
   76|     70|  }
_ZN4absl12lts_2026052616strings_internallsIA97_cEERNS1_15StringifyStreamES5_RKT_:
   69|     70|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|     70|    if constexpr (HasStreamInsertion<T>::value) {
   71|     70|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|     70|    return stream;
   76|     70|  }
_ZN4absl12lts_2026052616strings_internallsImEERNS1_15StringifyStreamES4_RKT_:
   69|     70|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|     70|    if constexpr (HasStreamInsertion<T>::value) {
   71|     70|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|     70|    return stream;
   76|     70|  }
_ZN4absl12lts_2026052616strings_internallsIA57_cEERNS1_15StringifyStreamES5_RKT_:
   69|     70|  friend StringifyStream& operator<<(StringifyStream& stream, const T& t) {
   70|     70|    if constexpr (HasStreamInsertion<T>::value) {
   71|     70|      stream.sink_.os << t;
   72|       |    } else {
   73|       |      AbslStringify(stream.sink_, t);
   74|       |    }
   75|     70|    return stream;
   76|     70|  }

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

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

_ZN4absl12lts_2026052624StringResizeAndOverwriteINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEZNS0_15AsciiStrToUpperENS2_17basic_string_viewIcS5_EEEUlPcmE_EEvRT_NSD_9size_typeET0_:
  186|  8.54k|void StringResizeAndOverwrite(T& str, typename T::size_type n, Op op) {
  187|  8.54k|  strings_internal::StringResizeAndOverwriteImpl(str, n, std::move(op));
  188|       |#if defined(ABSL_HAVE_MEMORY_SANITIZER)
  189|       |  __msan_check_mem_is_initialized(str.data(), str.size());
  190|       |#endif
  191|  8.54k|}
_ZN4absl12lts_2026052616strings_internal28StringResizeAndOverwriteImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEZNS0_15AsciiStrToUpperENS3_17basic_string_viewIcS6_EEEUlPcmE_EEvRT_NSE_9size_typeET0_:
  149|  8.54k|void StringResizeAndOverwriteImpl(T& str, typename T::size_type n, Op op) {
  150|       |#ifdef ABSL_INTERNAL_HAS_RESIZE_AND_OVERWRITE
  151|       |  str.resize_and_overwrite(n, std::move(op));
  152|       |#else
  153|       |  if constexpr (strings_internal::
  154|       |                    has__google_nonstandard_backport_resize_and_overwrite<
  155|       |                        T>::value) {
  156|       |    str.__google_nonstandard_backport_resize_and_overwrite(n, std::move(op));
  157|       |  } else if constexpr (strings_internal::has__resize_and_overwrite<T>::value) {
  158|       |    str.__resize_and_overwrite(n, std::move(op));
  159|  8.54k|  } else if constexpr (strings_internal::has__resize_default_init<T>::value) {
  160|  8.54k|    str.__resize_default_init(n);
  161|  8.54k|    str.__resize_default_init(
  162|  8.54k|        static_cast<typename T::size_type>(std::move(op)(str.data(), n)));
  163|       |  } else if constexpr (strings_internal::has_Resize_and_overwrite<T>::value) {
  164|       |    str._Resize_and_overwrite(n, std::move(op));
  165|       |  } else {
  166|       |    strings_internal::StringResizeAndOverwriteFallback(str, n, std::move(op));
  167|       |  }
  168|  8.54k|#endif
  169|  8.54k|}

_ZN4absl12lts_202605268AlphaNumC2INSt3__19allocatorIcEEEERKNS3_12basic_stringIcNS3_11char_traitsIcEET_EE:
  422|  17.0k|      : piece_(str) {}

_ZN4absl12lts_2026052617UntypedFormatSpecC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  111|   617k|  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
_ZN4absl12lts_202605269StrFormatIJiiEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSB_:
  363|  4.10k|                                    const Args&... args) {
  364|  4.10k|  return str_format_internal::FormatPack(
  365|  4.10k|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  366|  4.10k|      {str_format_internal::FormatArgImpl(args)...});
  367|  4.10k|}
_ZN4absl12lts_202605269StrFormatIJiEEENSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_19str_format_internal18FormatSpecTemplateIJXspclsr19str_format_internalE14ArgumentToConvIT_EEEEEEDpRKSB_:
  363|    256|                                    const Args&... args) {
  364|    256|  return str_format_internal::FormatPack(
  365|    256|      str_format_internal::UntypedFormatSpecImpl::Extract(format),
  366|    256|      {str_format_internal::FormatArgImpl(args)...});
  367|    256|}

_ZN4absl12lts_202605268StrSplitIPKcEENS0_16strings_internal8SplitterINS4_15SelectDelimiterIT_E4typeENS0_10AllowEmptyENSt3__117basic_string_viewIcNSB_11char_traitsIcEEEEEENS4_23ConvertibleToStringViewES7_:
  539|  8.54k|StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
  540|  8.54k|  using DelimiterType =
  541|  8.54k|      typename strings_internal::SelectDelimiter<Delimiter>::type;
  542|  8.54k|  return strings_internal::Splitter<DelimiterType, AllowEmpty,
  543|  8.54k|                                    absl::string_view>(
  544|  8.54k|      text.value(), DelimiterType(d), AllowEmpty());
  545|  8.54k|}
_ZNK4absl12lts_2026052610AllowEmptyclENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  348|  40.8k|  bool operator()(absl::string_view) const { return true; }

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

_ZN4absl12lts_2026052624synchronization_internal13KernelTimeoutC2Ev:
   51|  99.6k|  constexpr KernelTimeout() : rep_(kNoTimeout) {}
_ZN4absl12lts_2026052624synchronization_internal13KernelTimeout5NeverEv:
   55|  99.6k|  static constexpr KernelTimeout Never() { return KernelTimeout(); }

_ZN4absl12lts_202605265Mutex5AwaitERKNS0_9ConditionE:
  364|  99.6k|  void Await(const Condition& cond) {
  365|  99.6k|    AwaitCommon(cond, synchronization_internal::KernelTimeout::Never());
  366|  99.6k|  }
_ZN4absl12lts_202605269MutexLockC2ERNS0_5MutexE:
  626|   199k|      : mu_(mu) {
  627|   199k|    this->mu_.lock();
  628|   199k|  }
_ZN4absl12lts_202605269MutexLockD2Ev:
  658|   199k|  ~MutexLock() ABSL_UNLOCK_FUNCTION() { this->mu_.unlock(); }
_ZN4absl12lts_202605265Mutex4DtorEv:
 1205|  49.8k|inline void Mutex::Dtor() {}
_ZN4absl12lts_202605265MutexC2Ev:
 1186|  49.8k|inline Mutex::Mutex() : mu_(0) {
 1187|  49.8k|  ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
 1188|  49.8k|}
_ZN4absl12lts_202605265MutexD2Ev:
 1194|  49.8k|inline Mutex::~Mutex() { Dtor(); }
_ZN4absl12lts_202605269ConditionC2IN13sentencepiece10ThreadPool4ImplEEEPKT_MNS0_13type_identityIS6_E4typeEKFbvE:
 1262|  99.6k|    : eval_(&CastAndCallMethod<const T, decltype(method)>),
 1263|  99.6k|      arg_(reinterpret_cast<void*>(const_cast<T*>(object))) {
 1264|  99.6k|  StoreCallback(method);
 1265|  99.6k|}
_ZN4absl12lts_202605269Condition17CastAndCallMethodIKN13sentencepiece10ThreadPool4ImplEMS5_KFbvEEEbPKS1_:
 1212|  99.6k|bool Condition::CastAndCallMethod(const Condition* absl_nonnull c) {
 1213|  99.6k|  T* object = static_cast<T*>(c->arg_);
 1214|  99.6k|  ConditionMethodPtr condition_method_pointer;
 1215|  99.6k|  c->ReadCallback(&condition_method_pointer);
 1216|  99.6k|  return (object->*condition_method_pointer)();
 1217|  99.6k|}
_ZNK4absl12lts_202605269Condition12ReadCallbackIMN13sentencepiece10ThreadPool4ImplEKFbvEEEvPT_:
  975|  99.6k|  inline void ReadCallback(T* absl_nonnull callback) const {
  976|  99.6k|    std::memcpy(callback, callback_, sizeof(*callback));
  977|  99.6k|  }
_ZN4absl12lts_202605269Condition13StoreCallbackIMN13sentencepiece10ThreadPool4ImplEKFbvEEEvT_:
  967|  99.6k|  inline void StoreCallback(T callback) {
  968|  99.6k|    static_assert(
  969|  99.6k|        sizeof(callback) <= sizeof(callback_),
  970|  99.6k|        "An overlarge pointer was passed as a callback to Condition.");
  971|  99.6k|    std::memcpy(callback_, &callback, sizeof(callback));
  972|  99.6k|  }

_ZN4absl12lts_202605268DurationC2Elj:
  248|  2.38M|  constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
_ZN4absl12lts_202605268Duration5HiRepC2El:
  268|  3.01M|          lo_(0),
  269|  3.01M|          hi_(0)
  270|       |#endif
  271|  3.01M|    {
  272|  3.01M|      *this = value;
  273|  3.01M|    }
_ZNK4absl12lts_202605268Duration5HiRep3GetEv:
  275|  1.22M|    constexpr int64_t Get() const {
  276|  1.22M|      const uint64_t unsigned_value =
  277|  1.22M|          (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.22M|      static_assert(
  285|  1.22M|          (static_cast<int64_t>((std::numeric_limits<uint64_t>::max)()) ==
  286|  1.22M|           int64_t{-1}) &&
  287|  1.22M|              (static_cast<int64_t>(static_cast<uint64_t>(
  288|  1.22M|                                        (std::numeric_limits<int64_t>::max)()) +
  289|  1.22M|                                    1) ==
  290|  1.22M|               (std::numeric_limits<int64_t>::min)()),
  291|  1.22M|          "static_cast<int64_t>(uint64_t) does not have c++20 semantics");
  292|  1.22M|      return static_cast<int64_t>(unsigned_value);
  293|  1.22M|    }
_ZN4absl12lts_202605268Duration5HiRepaSEl:
  295|  3.01M|    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|  3.01M|      const auto unsigned_value = static_cast<uint64_t>(value);
  301|  3.01M|      hi_ = static_cast<uint32_t>(unsigned_value >> 32);
  302|  3.01M|      lo_ = static_cast<uint32_t>(unsigned_value);
  303|  3.01M|      return *this;
  304|  3.01M|    }
_ZN4absl12lts_2026052613time_internal12MakeDurationElj:
 1598|  2.38M|                                                              uint32_t lo = 0) {
 1599|  2.38M|  return Duration(hi, lo);
 1600|  2.38M|}
_ZN4absl12lts_2026052613time_internal12MakeDurationEll:
 1603|  2.38M|                                                              int64_t lo) {
 1604|  2.38M|  return MakeDuration(hi, static_cast<uint32_t>(lo));
 1605|  2.38M|}
_ZN4absl12lts_2026052613time_internal22MakeNormalizedDurationEll:
 1624|     43|    int64_t sec, int64_t ticks) {
 1625|     43|  return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond)
  ------------------
  |  Branch (1625:10): [True: 0, False: 43]
  ------------------
 1626|     43|                     : MakeDuration(sec, ticks);
 1627|     43|}
_ZN4absl12lts_2026052613time_internal8GetRepHiENS0_8DurationE:
 1630|  1.22M|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr int64_t GetRepHi(Duration d) {
 1631|  1.22M|  return d.rep_hi_.Get();
 1632|  1.22M|}
_ZN4absl12lts_2026052613time_internal8GetRepLoENS0_8DurationE:
 1633|  1.83M|ABSL_ATTRIBUTE_CONST_FUNCTION constexpr uint32_t GetRepLo(Duration d) {
 1634|  1.83M|  return d.rep_lo_;
 1635|  1.83M|}

_ZN4absl12lts_2026052614SourceLocation7currentENS1_10PrivateTagEjPKc:
  113|   279k|      const char* absl_nonnull file_name = __builtin_FILE()) {
  114|   279k|    return SourceLocation(line, file_name);
  115|   279k|  }
_ZN4absl12lts_2026052614SourceLocationC2EjPKc:
  151|   279k|      : line_(line), file_name_(file_name) {}

_ZN4absl12lts_2026052613MakeConstSpanITpTnRiJEKjEENS0_4SpanIKT0_EEPS5_m:
  794|  1.25k|    T* absl_nullable ptr ABSL_ATTRIBUTE_LIFETIME_BOUND, size_t size) noexcept {
  795|  1.25k|  return Span<const T>(ptr, size);
  796|  1.25k|}
_ZN4absl12lts_202605264SpanIKNS0_19str_format_internal13FormatArgImplEEC2IS4_S4_EESt16initializer_listIS3_E:
  310|   617k|      : Span(v.begin(), v.size()) {}
_ZN4absl12lts_202605264SpanIKNS0_19str_format_internal13FormatArgImplEEC2EPS4_m:
  230|   617k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202605264SpanIjEC2EPjm:
  230|  1.26k|      : ptr_(array), len_(length) {}
_ZN4absl12lts_202605264SpanIKjEC2EPS2_m:
  230|  1.26k|      : ptr_(array), len_(length) {}

_ZN5Darts7Details15DoubleArrayUnitC2Ev:
   53|  44.0M|  DoubleArrayUnit() : unit_() {}
_ZNK5Darts7Details15DoubleArrayUnit8has_leafEv:
   57|   633M|  bool has_leaf() const {
   58|   633M|    return ((unit_ >> 8) & 1) == 1;
   59|   633M|  }
_ZNK5Darts7Details15DoubleArrayUnit5valueEv:
   62|   487M|  value_type value() const {
   63|   487M|    return static_cast<value_type>(unit_ & ((1U << 31) - 1));
   64|   487M|  }
_ZNK5Darts7Details15DoubleArrayUnit5labelEv:
   69|  1.51G|  id_type label() const {
   70|  1.51G|    return unit_ & ((1U << 31) | 0xFF);
   71|  1.51G|  }
_ZNK5Darts7Details15DoubleArrayUnit6offsetEv:
   73|  1.27G|  id_type offset() const {
   74|  1.27G|    return (unit_ >> 10) << ((unit_ & (1U << 9)) >> 6);
   75|  1.27G|  }
_ZN5Darts7Details9BitVectorC2Ev:
  804|  47.1k|  BitVector() : units_(), ranks_(), num_ones_(0), size_(0) {}
_ZN5Darts7Details9BitVectorD2Ev:
  805|  47.1k|  ~BitVector() {
  806|  47.1k|    clear();
  807|  47.1k|  }
_ZNK5Darts7Details9BitVectorixEm:
  809|  48.8M|  bool operator[](std::size_t id) const {
  810|  48.8M|    return (units_[id / UNIT_SIZE] >> (id % UNIT_SIZE) & 1) == 1;
  811|  48.8M|  }
_ZNK5Darts7Details9BitVector8num_onesEv:
  830|  94.2k|  std::size_t num_ones() const {
  831|  94.2k|    return num_ones_;
  832|  94.2k|  }
_ZNK5Darts7Details9BitVector4sizeEv:
  833|  31.8M|  std::size_t size() const {
  834|  31.8M|    return size_;
  835|  31.8M|  }
_ZN5Darts7Details9BitVector6appendEv:
  837|  31.8M|  void append() {
  838|  31.8M|    if ((size_ % UNIT_SIZE) == 0) {
  ------------------
  |  Branch (838:9): [True: 1.01M, False: 30.8M]
  ------------------
  839|  1.01M|      units_.append(0);
  840|  1.01M|    }
  841|  31.8M|    ++size_;
  842|  31.8M|  }
_ZN5Darts7Details9BitVector5clearEv:
  845|   141k|  void clear() {
  846|   141k|    units_.clear();
  847|   141k|    ranks_.clear();
  848|   141k|  }
_ZN5Darts7Details9BitVector9pop_countEj:
  862|  1.01M|  static id_type pop_count(id_type unit) {
  863|  1.01M|    unit = ((unit & 0xAAAAAAAA) >> 1) + (unit & 0x55555555);
  864|  1.01M|    unit = ((unit & 0xCCCCCCCC) >> 2) + (unit & 0x33333333);
  865|  1.01M|    unit = ((unit >> 4) + unit) & 0x0F0F0F0F;
  866|  1.01M|    unit += unit >> 8;
  867|  1.01M|    unit += unit >> 16;
  868|  1.01M|    return unit & 0xFF;
  869|  1.01M|  }
_ZN5Darts7Details8DawgNodeC2Ev:
  950|  31.8M|  DawgNode() : child_(0), sibling_(0), label_('\0'),
  951|  31.8M|    is_state_(false), has_sibling_(false) {}
_ZN5Darts7Details8DawgNode9set_childEj:
  953|  56.2M|  void set_child(id_type child) {
  954|  56.2M|    child_ = child;
  955|  56.2M|  }
_ZN5Darts7Details8DawgNode11set_siblingEj:
  956|  31.7M|  void set_sibling(id_type sibling) {
  957|  31.7M|    sibling_ = sibling;
  958|  31.7M|  }
_ZN5Darts7Details8DawgNode9set_valueEi:
  959|  7.40M|  void set_value(value_type value) {
  960|  7.40M|    child_ = value;
  961|  7.40M|  }
_ZN5Darts7Details8DawgNode9set_labelEh:
  962|  31.8M|  void set_label(uchar_type label) {
  963|  31.8M|    label_ = label;
  964|  31.8M|  }
_ZN5Darts7Details8DawgNode12set_is_stateEb:
  965|  24.4M|  void set_is_state(bool is_state) {
  966|  24.4M|    is_state_ = is_state;
  967|  24.4M|  }
_ZN5Darts7Details8DawgNode15set_has_siblingEb:
  968|  7.35M|  void set_has_sibling(bool has_sibling) {
  969|  7.35M|    has_sibling_ = has_sibling;
  970|  7.35M|  }
_ZNK5Darts7Details8DawgNode5childEv:
  972|  94.5M|  id_type child() const {
  973|  94.5M|    return child_;
  974|  94.5M|  }
_ZNK5Darts7Details8DawgNode7siblingEv:
  975|   160M|  id_type sibling() const {
  976|   160M|    return sibling_;
  977|   160M|  }
_ZNK5Darts7Details8DawgNode5labelEv:
  981|  94.5M|  uchar_type label() const {
  982|  94.5M|    return label_;
  983|  94.5M|  }
_ZNK5Darts7Details8DawgNode4unitEv:
  991|  89.8M|  id_type unit() const {
  992|  89.8M|    if (label_ == '\0') {
  ------------------
  |  Branch (992:9): [True: 19.7M, False: 70.0M]
  ------------------
  993|  19.7M|      return (child_ << 1) | (has_sibling_ ? 1 : 0);
  ------------------
  |  Branch (993:31): [True: 4.41M, False: 15.3M]
  ------------------
  994|  19.7M|    }
  995|  70.0M|    return (child_ << 2) | (is_state_ ? 2 : 0) | (has_sibling_ ? 1 : 0);
  ------------------
  |  Branch (995:29): [True: 55.0M, False: 15.0M]
  |  Branch (995:51): [True: 10.3M, False: 59.7M]
  ------------------
  996|  89.8M|  }
_ZN5Darts7Details8DawgUnitC2Ej:
 1014|  31.8M|  explicit DawgUnit(id_type unit = 0) : unit_(unit) {}
_ZN5Darts7Details8DawgUnitC2ERKS1_:
 1015|  45.7M|  DawgUnit(const DawgUnit &unit) : unit_(unit.unit_) {}
_ZN5Darts7Details8DawgUnitaSEj:
 1017|  31.8M|  DawgUnit &operator=(id_type unit) {
 1018|  31.8M|    unit_ = unit;
 1019|  31.8M|    return *this;
 1020|  31.8M|  }
_ZNK5Darts7Details8DawgUnit4unitEv:
 1022|  46.6M|  id_type unit() const {
 1023|  46.6M|    return unit_;
 1024|  46.6M|  }
_ZNK5Darts7Details8DawgUnit5childEv:
 1026|  73.3M|  id_type child() const {
 1027|  73.3M|    return unit_ >> 2;
 1028|  73.3M|  }
_ZNK5Darts7Details8DawgUnit11has_siblingEv:
 1029|   149M|  bool has_sibling() const {
 1030|   149M|    return (unit_ & 1) == 1;
 1031|   149M|  }
_ZNK5Darts7Details8DawgUnit5valueEv:
 1032|  7.40M|  value_type value() const {
 1033|  7.40M|    return static_cast<value_type>(unit_ >> 1);
 1034|  7.40M|  }
_ZNK5Darts7Details8DawgUnit8is_stateEv:
 1035|  15.7M|  bool is_state() const {
 1036|  15.7M|    return (unit_ & 2) == 2;
 1037|  15.7M|  }
_ZN5Darts7Details11DawgBuilderC2Ev:
 1051|  47.1k|  DawgBuilder() : nodes_(), units_(), labels_(), is_intersections_(),
 1052|  47.1k|    table_(), node_stack_(), recycle_bin_(), num_states_(0) {}
_ZN5Darts7Details11DawgBuilderD2Ev:
 1053|  47.1k|  ~DawgBuilder() {
 1054|  47.1k|    clear();
 1055|  47.1k|  }
_ZNK5Darts7Details11DawgBuilder4rootEv:
 1057|  94.2k|  id_type root() const {
 1058|  94.2k|    return 0;
 1059|  94.2k|  }
_ZNK5Darts7Details11DawgBuilder5childEj:
 1061|  73.3M|  id_type child(id_type id) const {
 1062|  73.3M|    return units_[id].child();
 1063|  73.3M|  }
_ZNK5Darts7Details11DawgBuilder7siblingEj:
 1064|  95.3M|  id_type sibling(id_type id) const {
 1065|  95.3M|    return units_[id].has_sibling() ? (id + 1) : 0;
  ------------------
  |  Branch (1065:12): [True: 22.0M, False: 73.2M]
  ------------------
 1066|  95.3M|  }
_ZNK5Darts7Details11DawgBuilder5valueEj:
 1067|  7.40M|  int value(id_type id) const {
 1068|  7.40M|    return units_[id].value();
 1069|  7.40M|  }
_ZNK5Darts7Details11DawgBuilder7is_leafEj:
 1071|  31.7M|  bool is_leaf(id_type id) const {
 1072|  31.7M|    return label(id) == '\0';
 1073|  31.7M|  }
_ZNK5Darts7Details11DawgBuilder5labelEj:
 1074|  95.3M|  uchar_type label(id_type id) const {
 1075|  95.3M|    return labels_[id];
 1076|  95.3M|  }
_ZNK5Darts7Details11DawgBuilder15is_intersectionEj:
 1078|  48.8M|  bool is_intersection(id_type id) const {
 1079|  48.8M|    return is_intersections_[id];
 1080|  48.8M|  }
_ZNK5Darts7Details11DawgBuilder17num_intersectionsEv:
 1085|  94.2k|  std::size_t num_intersections() const {
 1086|  94.2k|    return is_intersections_.num_ones();
 1087|  94.2k|  }
_ZNK5Darts7Details11DawgBuilder4sizeEv:
 1089|   456k|  std::size_t size() const {
 1090|   456k|    return units_.size();
 1091|   456k|  }
_ZN5Darts7Details11DawgBuilder9free_nodeEj:
 1131|  31.7M|  void free_node(id_type id) {
 1132|  31.7M|    recycle_bin_.push(id);
 1133|  31.7M|  }
_ZN5Darts7Details11DawgBuilder4hashEj:
 1135|  52.1M|  static id_type hash(id_type key) {
 1136|  52.1M|    key = ~key + (key << 15);  // key = (key << 15) - key - 1;
 1137|  52.1M|    key = key ^ (key >> 12);
 1138|  52.1M|    key = key + (key << 2);
 1139|  52.1M|    key = key ^ (key >> 4);
 1140|  52.1M|    key = key * 2057;  // key = (key + (key << 3)) + (key << 11);
 1141|  52.1M|    key = key ^ (key >> 16);
 1142|  52.1M|    return key;
 1143|  52.1M|  }
_ZN5Darts7Details22DoubleArrayBuilderUnitC2Ev:
 1397|  44.0M|  DoubleArrayBuilderUnit() : unit_(0) {}
_ZN5Darts7Details22DoubleArrayBuilderUnit12set_has_leafEb:
 1399|  7.44M|  void set_has_leaf(bool has_leaf) {
 1400|  7.44M|    if (has_leaf) {
  ------------------
  |  Branch (1400:9): [True: 7.44M, False: 0]
  ------------------
 1401|  7.44M|      unit_ |= 1U << 8;
 1402|  7.44M|    } else {
 1403|      0|      unit_ &= ~(1U << 8);
 1404|      0|    }
 1405|  7.44M|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit9set_valueEi:
 1406|  7.44M|  void set_value(value_type value) {
 1407|  7.44M|    unit_ = value | (1U << 31);
 1408|  7.44M|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit9set_labelEh:
 1409|  36.5M|  void set_label(uchar_type label) {
 1410|  36.5M|    unit_ = (unit_ & ~0xFFU) | label;
 1411|  36.5M|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit10set_offsetEj:
 1412|  24.6M|  void set_offset(id_type offset) {
 1413|  24.6M|    if (offset >= 1U << 29) {
  ------------------
  |  Branch (1413:9): [True: 0, False: 24.6M]
  ------------------
 1414|      0|      DARTS_THROW("failed to modify unit: too large offset");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1415|      0|    }
 1416|  24.6M|    unit_ &= (1U << 31) | (1U << 8) | 0xFF;
 1417|  24.6M|    if (offset < 1U << 21) {
  ------------------
  |  Branch (1417:9): [True: 24.6M, False: 0]
  ------------------
 1418|  24.6M|      unit_ |= (offset << 10);
 1419|  24.6M|    } else {
 1420|      0|      unit_ |= (offset << 2) | (1U << 9);
 1421|      0|    }
 1422|  24.6M|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnitC2Ev:
 1436|   227M|  DoubleArrayBuilderExtraUnit() : prev_(0), next_(0),
 1437|   227M|      is_fixed_(false), is_used_(false) {}
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit8set_prevEj:
 1439|  88.4M|  void set_prev(id_type prev) {
 1440|  88.4M|    prev_ = prev;
 1441|  88.4M|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit8set_nextEj:
 1442|  88.4M|  void set_next(id_type next) {
 1443|  88.4M|    next_ = next;
 1444|  88.4M|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit12set_is_fixedEb:
 1445|  46.3M|  void set_is_fixed(bool is_fixed) {
 1446|  46.3M|    is_fixed_ = is_fixed;
 1447|  46.3M|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit11set_is_usedEb:
 1448|  26.9M|  void set_is_used(bool is_used) {
 1449|  26.9M|    is_used_ = is_used;
 1450|  26.9M|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit4prevEv:
 1452|  88.4M|  id_type prev() const {
 1453|  88.4M|    return prev_;
 1454|  88.4M|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit4nextEv:
 1455|   287M|  id_type next() const {
 1456|   287M|    return next_;
 1457|   287M|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit8is_fixedEv:
 1458|  92.2M|  bool is_fixed() const {
 1459|  92.2M|    return is_fixed_;
 1460|  92.2M|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit7is_usedEv:
 1461|   208M|  bool is_used() const {
 1462|   208M|    return is_used_;
 1463|   208M|  }
_ZN5Darts7Details18DoubleArrayBuilderC2EPFimmE:
 1481|  55.6k|      : progress_func_(progress_func), units_(), extras_(), labels_(),
 1482|  55.6k|        table_(), extras_head_(0) {}
_ZN5Darts7Details18DoubleArrayBuilderD2Ev:
 1483|  55.6k|  ~DoubleArrayBuilder() {
 1484|  55.6k|    clear();
 1485|  55.6k|  }
_ZNK5Darts7Details18DoubleArrayBuilder10num_blocksEv:
 1515|   284k|  std::size_t num_blocks() const {
 1516|   284k|    return units_.size() / BLOCK_SIZE;
 1517|   284k|  }
_ZNK5Darts7Details18DoubleArrayBuilder6extrasEj:
 1519|   436M|  const extra_type &extras(id_type id) const {
 1520|   436M|    return extras_[id % NUM_EXTRAS];
 1521|   436M|  }
_ZN5Darts7Details18DoubleArrayBuilder6extrasEj:
 1522|   490M|  extra_type &extras(id_type id) {
 1523|   490M|    return extras_[id % NUM_EXTRAS];
 1524|   490M|  }
_ZN5Darts7Details9BitVector5buildEv:
  872|  47.1k|inline void BitVector::build() {
  873|  47.1k|  try {
  874|  47.1k|    ranks_.reset(new id_type[units_.size()]);
  875|  47.1k|  } catch (const std::bad_alloc &) {
  876|      0|    DARTS_THROW("failed to build rank index: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  877|      0|  }
  878|       |
  879|  47.1k|  num_ones_ = 0;
  880|  1.06M|  for (std::size_t i = 0; i < units_.size(); ++i) {
  ------------------
  |  Branch (880:27): [True: 1.01M, False: 47.1k]
  ------------------
  881|  1.01M|    ranks_[i] = num_ones_;
  882|  1.01M|    num_ones_ += pop_count(units_[i]);
  883|  1.01M|  }
  884|  47.1k|}
_ZN5Darts7Details11DawgBuilder4initEv:
 1146|  47.1k|inline void DawgBuilder::init() {
 1147|  47.1k|  table_.resize(INITIAL_TABLE_SIZE, 0);
 1148|       |
 1149|  47.1k|  append_node();
 1150|  47.1k|  append_unit();
 1151|       |
 1152|  47.1k|  num_states_ = 1;
 1153|       |
 1154|  47.1k|  nodes_[0].set_label(0xFF);
 1155|  47.1k|  node_stack_.push(0);
 1156|  47.1k|}
_ZN5Darts7Details11DawgBuilder6finishEv:
 1158|  47.1k|inline void DawgBuilder::finish() {
 1159|  47.1k|  flush(0);
 1160|       |
 1161|  47.1k|  units_[0] = nodes_[0].unit();
 1162|  47.1k|  labels_[0] = nodes_[0].label();
 1163|       |
 1164|  47.1k|  nodes_.clear();
 1165|  47.1k|  table_.clear();
 1166|  47.1k|  node_stack_.clear();
 1167|  47.1k|  recycle_bin_.clear();
 1168|       |
 1169|  47.1k|  is_intersections_.build();
 1170|  47.1k|}
_ZN5Darts7Details11DawgBuilder6insertEPKcmi:
 1173|  7.40M|    value_type value) {
 1174|  7.40M|  if (value < 0) {
  ------------------
  |  Branch (1174:7): [True: 0, False: 7.40M]
  ------------------
 1175|      0|    DARTS_THROW("failed to insert key: negative value");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1176|  7.40M|  } else if (length == 0) {
  ------------------
  |  Branch (1176:14): [True: 0, False: 7.40M]
  ------------------
 1177|      0|    DARTS_THROW("failed to insert key: zero-length key");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1178|      0|  }
 1179|       |
 1180|  7.40M|  id_type id = 0;
 1181|  7.40M|  std::size_t key_pos = 0;
 1182|       |
 1183|  31.0M|  for ( ; key_pos <= length; ++key_pos) {
  ------------------
  |  Branch (1183:11): [True: 31.0M, False: 0]
  ------------------
 1184|  31.0M|    id_type child_id = nodes_[id].child();
 1185|  31.0M|    if (child_id == 0) {
  ------------------
  |  Branch (1185:9): [True: 47.1k, False: 30.9M]
  ------------------
 1186|  47.1k|      break;
 1187|  47.1k|    }
 1188|       |
 1189|  30.9M|    uchar_type key_label = static_cast<uchar_type>(key[key_pos]);
 1190|  30.9M|    if (key_pos < length && key_label == '\0') {
  ------------------
  |  Branch (1190:9): [True: 30.9M, False: 0]
  |  Branch (1190:29): [True: 0, False: 30.9M]
  ------------------
 1191|      0|      DARTS_THROW("failed to insert key: invalid null character");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1192|      0|    }
 1193|       |
 1194|  30.9M|    uchar_type unit_label = nodes_[child_id].label();
 1195|  30.9M|    if (key_label < unit_label) {
  ------------------
  |  Branch (1195:9): [True: 0, False: 30.9M]
  ------------------
 1196|      0|      DARTS_THROW("failed to insert key: wrong key order");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1197|  30.9M|    } else if (key_label > unit_label) {
  ------------------
  |  Branch (1197:16): [True: 7.35M, False: 23.6M]
  ------------------
 1198|  7.35M|      nodes_[child_id].set_has_sibling(true);
 1199|  7.35M|      flush(child_id);
 1200|  7.35M|      break;
 1201|  7.35M|    }
 1202|  23.6M|    id = child_id;
 1203|  23.6M|  }
 1204|       |
 1205|  7.40M|  if (key_pos > length) {
  ------------------
  |  Branch (1205:7): [True: 0, False: 7.40M]
  ------------------
 1206|      0|    return;
 1207|      0|  }
 1208|       |
 1209|  39.1M|  for ( ; key_pos <= length; ++key_pos) {
  ------------------
  |  Branch (1209:11): [True: 31.7M, False: 7.40M]
  ------------------
 1210|  31.7M|    uchar_type key_label = static_cast<uchar_type>(
 1211|  31.7M|        (key_pos < length) ? key[key_pos] : '\0');
  ------------------
  |  Branch (1211:9): [True: 24.3M, False: 7.40M]
  ------------------
 1212|  31.7M|    id_type child_id = append_node();
 1213|       |
 1214|  31.7M|    if (nodes_[id].child() == 0) {
  ------------------
  |  Branch (1214:9): [True: 24.4M, False: 7.35M]
  ------------------
 1215|  24.4M|      nodes_[child_id].set_is_state(true);
 1216|  24.4M|    }
 1217|  31.7M|    nodes_[child_id].set_sibling(nodes_[id].child());
 1218|  31.7M|    nodes_[child_id].set_label(key_label);
 1219|  31.7M|    nodes_[id].set_child(child_id);
 1220|  31.7M|    node_stack_.push(child_id);
 1221|       |
 1222|  31.7M|    id = child_id;
 1223|  31.7M|  }
 1224|  7.40M|  nodes_[id].set_value(value);
 1225|  7.40M|}
_ZN5Darts7Details11DawgBuilder5clearEv:
 1227|  94.2k|inline void DawgBuilder::clear() {
 1228|  94.2k|  nodes_.clear();
 1229|  94.2k|  units_.clear();
 1230|  94.2k|  labels_.clear();
 1231|  94.2k|  is_intersections_.clear();
 1232|  94.2k|  table_.clear();
 1233|  94.2k|  node_stack_.clear();
 1234|  94.2k|  recycle_bin_.clear();
 1235|  94.2k|  num_states_ = 0;
 1236|  94.2k|}
_ZN5Darts7Details11DawgBuilder5flushEj:
 1238|  7.40M|inline void DawgBuilder::flush(id_type id) {
 1239|  31.8M|  while (node_stack_.top() != id) {
  ------------------
  |  Branch (1239:10): [True: 24.4M, False: 7.40M]
  ------------------
 1240|  24.4M|    id_type node_id = node_stack_.top();
 1241|  24.4M|    node_stack_.pop();
 1242|       |
 1243|  24.4M|    if (num_states_ >= table_.size() - (table_.size() >> 2)) {
  ------------------
  |  Branch (1243:9): [True: 13.7k, False: 24.4M]
  ------------------
 1244|  13.7k|      expand_table();
 1245|  13.7k|    }
 1246|       |
 1247|  24.4M|    id_type num_siblings = 0;
 1248|  56.2M|    for (id_type i = node_id; i != 0; i = nodes_[i].sibling()) {
  ------------------
  |  Branch (1248:31): [True: 31.7M, False: 24.4M]
  ------------------
 1249|  31.7M|      ++num_siblings;
 1250|  31.7M|    }
 1251|       |
 1252|  24.4M|    id_type hash_id;
 1253|  24.4M|    id_type match_id = find_node(node_id, &hash_id);
 1254|  24.4M|    if (match_id != 0) {
  ------------------
  |  Branch (1254:9): [True: 0, False: 24.4M]
  ------------------
 1255|      0|      is_intersections_.set(match_id, true);
 1256|  24.4M|    } else {
 1257|  24.4M|      id_type unit_id = 0;
 1258|  56.2M|      for (id_type i = 0; i < num_siblings; ++i) {
  ------------------
  |  Branch (1258:27): [True: 31.7M, False: 24.4M]
  ------------------
 1259|  31.7M|        unit_id = append_unit();
 1260|  31.7M|      }
 1261|  56.2M|      for (id_type i = node_id; i != 0; i = nodes_[i].sibling()) {
  ------------------
  |  Branch (1261:33): [True: 31.7M, False: 24.4M]
  ------------------
 1262|  31.7M|        units_[unit_id] = nodes_[i].unit();
 1263|  31.7M|        labels_[unit_id] = nodes_[i].label();
 1264|  31.7M|        --unit_id;
 1265|  31.7M|      }
 1266|  24.4M|      match_id = unit_id + 1;
 1267|  24.4M|      table_[hash_id] = match_id;
 1268|  24.4M|      ++num_states_;
 1269|  24.4M|    }
 1270|       |
 1271|  56.2M|    for (id_type i = node_id, next; i != 0; i = next) {
  ------------------
  |  Branch (1271:37): [True: 31.7M, False: 24.4M]
  ------------------
 1272|  31.7M|      next = nodes_[i].sibling();
 1273|  31.7M|      free_node(i);
 1274|  31.7M|    }
 1275|       |
 1276|  24.4M|    nodes_[node_stack_.top()].set_child(match_id);
 1277|  24.4M|  }
 1278|  7.40M|  node_stack_.pop();
 1279|  7.40M|}
_ZN5Darts7Details11DawgBuilder12expand_tableEv:
 1281|  13.7k|inline void DawgBuilder::expand_table() {
 1282|  13.7k|  std::size_t table_size = table_.size() << 1;
 1283|  13.7k|  table_.clear();
 1284|  13.7k|  table_.resize(table_size, 0);
 1285|       |
 1286|  20.4M|  for (std::size_t i = 1; i < units_.size(); ++i) {
  ------------------
  |  Branch (1286:27): [True: 20.3M, False: 13.7k]
  ------------------
 1287|  20.3M|    id_type id = static_cast<id_type>(i);
 1288|  20.3M|    if (labels_[id] == '\0' || units_[id].is_state()) {
  ------------------
  |  Branch (1288:9): [True: 4.62M, False: 15.7M]
  |  Branch (1288:32): [True: 11.7M, False: 3.99M]
  ------------------
 1289|  16.3M|      id_type hash_id;
 1290|  16.3M|      find_unit(id, &hash_id);
 1291|  16.3M|      table_[hash_id] = id;
 1292|  16.3M|    }
 1293|  20.3M|  }
 1294|  13.7k|}
_ZNK5Darts7Details11DawgBuilder9find_unitEjPj:
 1296|  16.3M|inline id_type DawgBuilder::find_unit(id_type id, id_type *hash_id) const {
 1297|  16.3M|  *hash_id = hash_unit(id) % table_.size();
 1298|  21.3M|  for ( ; ; *hash_id = (*hash_id + 1) % table_.size()) {
 1299|  21.3M|    id_type unit_id = table_[*hash_id];
 1300|  21.3M|    if (unit_id == 0) {
  ------------------
  |  Branch (1300:9): [True: 16.3M, False: 4.93M]
  ------------------
 1301|  16.3M|      break;
 1302|  16.3M|    }
 1303|       |
 1304|       |    // There must not be the same unit.
 1305|  21.3M|  }
 1306|  16.3M|  return 0;
 1307|  16.3M|}
_ZNK5Darts7Details11DawgBuilder9find_nodeEjPj:
 1310|  24.4M|    id_type *hash_id) const {
 1311|  24.4M|  *hash_id = hash_node(node_id) % table_.size();
 1312|  57.2M|  for ( ; ; *hash_id = (*hash_id + 1) % table_.size()) {
 1313|  57.2M|    id_type unit_id = table_[*hash_id];
 1314|  57.2M|    if (unit_id == 0) {
  ------------------
  |  Branch (1314:9): [True: 24.4M, False: 32.8M]
  ------------------
 1315|  24.4M|      break;
 1316|  24.4M|    }
 1317|       |
 1318|  32.8M|    if (are_equal(node_id, unit_id)) {
  ------------------
  |  Branch (1318:9): [True: 0, False: 32.8M]
  ------------------
 1319|      0|      return unit_id;
 1320|      0|    }
 1321|  32.8M|  }
 1322|  24.4M|  return 0;
 1323|  24.4M|}
_ZNK5Darts7Details11DawgBuilder9are_equalEjj:
 1325|  32.8M|inline bool DawgBuilder::are_equal(id_type node_id, id_type unit_id) const {
 1326|  33.6M|  for (id_type i = nodes_[node_id].sibling(); i != 0;
  ------------------
  |  Branch (1326:47): [True: 4.06M, False: 29.5M]
  ------------------
 1327|  32.8M|      i = nodes_[i].sibling()) {
 1328|  4.06M|    if (units_[unit_id].has_sibling() == false) {
  ------------------
  |  Branch (1328:9): [True: 3.24M, False: 822k]
  ------------------
 1329|  3.24M|      return false;
 1330|  3.24M|    }
 1331|   822k|    ++unit_id;
 1332|   822k|  }
 1333|  29.5M|  if (units_[unit_id].has_sibling() == true) {
  ------------------
  |  Branch (1333:7): [True: 3.34M, False: 26.2M]
  ------------------
 1334|  3.34M|    return false;
 1335|  3.34M|  }
 1336|       |
 1337|  26.2M|  for (id_type i = node_id; i != 0; i = nodes_[i].sibling(), --unit_id) {
  ------------------
  |  Branch (1337:29): [True: 26.2M, False: 0]
  ------------------
 1338|  26.2M|    if (nodes_[i].unit() != units_[unit_id].unit() ||
  ------------------
  |  Branch (1338:9): [True: 26.2M, False: 1.38k]
  ------------------
 1339|  26.2M|        nodes_[i].label() != labels_[unit_id]) {
  ------------------
  |  Branch (1339:9): [True: 1.38k, False: 0]
  ------------------
 1340|  26.2M|      return false;
 1341|  26.2M|    }
 1342|  26.2M|  }
 1343|      0|  return true;
 1344|  26.2M|}
_ZNK5Darts7Details11DawgBuilder9hash_unitEj:
 1346|  16.3M|inline id_type DawgBuilder::hash_unit(id_type id) const {
 1347|  16.3M|  id_type hash_value = 0;
 1348|  20.3M|  for ( ; id != 0; ++id) {
  ------------------
  |  Branch (1348:11): [True: 20.3M, False: 0]
  ------------------
 1349|  20.3M|    id_type unit = units_[id].unit();
 1350|  20.3M|    uchar_type label = labels_[id];
 1351|  20.3M|    hash_value ^= hash((label << 24) ^ unit);
 1352|       |
 1353|  20.3M|    if (units_[id].has_sibling() == false) {
  ------------------
  |  Branch (1353:9): [True: 16.3M, False: 3.99M]
  ------------------
 1354|  16.3M|      break;
 1355|  16.3M|    }
 1356|  20.3M|  }
 1357|  16.3M|  return hash_value;
 1358|  16.3M|}
_ZNK5Darts7Details11DawgBuilder9hash_nodeEj:
 1360|  24.4M|inline id_type DawgBuilder::hash_node(id_type id) const {
 1361|  24.4M|  id_type hash_value = 0;
 1362|  56.2M|  for ( ; id != 0; id = nodes_[id].sibling()) {
  ------------------
  |  Branch (1362:11): [True: 31.7M, False: 24.4M]
  ------------------
 1363|  31.7M|    id_type unit = nodes_[id].unit();
 1364|  31.7M|    uchar_type label = nodes_[id].label();
 1365|  31.7M|    hash_value ^= hash((label << 24) ^ unit);
 1366|  31.7M|  }
 1367|  24.4M|  return hash_value;
 1368|  24.4M|}
_ZN5Darts7Details11DawgBuilder11append_unitEv:
 1370|  31.8M|inline id_type DawgBuilder::append_unit() {
 1371|  31.8M|  is_intersections_.append();
 1372|  31.8M|  units_.append();
 1373|  31.8M|  labels_.append();
 1374|       |
 1375|  31.8M|  return static_cast<id_type>(is_intersections_.size() - 1);
 1376|  31.8M|}
_ZN5Darts7Details11DawgBuilder11append_nodeEv:
 1378|  31.8M|inline id_type DawgBuilder::append_node() {
 1379|  31.8M|  id_type id;
 1380|  31.8M|  if (recycle_bin_.empty()) {
  ------------------
  |  Branch (1380:7): [True: 3.13M, False: 28.7M]
  ------------------
 1381|  3.13M|    id = static_cast<id_type>(nodes_.size());
 1382|  3.13M|    nodes_.append();
 1383|  28.7M|  } else {
 1384|  28.7M|    id = recycle_bin_.top();
 1385|  28.7M|    nodes_[id] = DawgNode();
 1386|  28.7M|    recycle_bin_.pop();
 1387|  28.7M|  }
 1388|  31.8M|  return id;
 1389|  31.8M|}
_ZNK5Darts7Details18DoubleArrayBuilder4copyEPmPPNS0_15DoubleArrayUnitE:
 1566|  55.6k|    DoubleArrayUnit **buf_ptr) const {
 1567|  55.6k|  if (size_ptr != NULL) {
  ------------------
  |  Branch (1567:7): [True: 55.6k, False: 0]
  ------------------
 1568|  55.6k|    *size_ptr = units_.size();
 1569|  55.6k|  }
 1570|  55.6k|  if (buf_ptr != NULL) {
  ------------------
  |  Branch (1570:7): [True: 55.6k, False: 0]
  ------------------
 1571|  55.6k|    *buf_ptr = new DoubleArrayUnit[units_.size()];
 1572|  55.6k|    unit_type *units = reinterpret_cast<unit_type *>(*buf_ptr);
 1573|  44.0M|    for (std::size_t i = 0; i < units_.size(); ++i) {
  ------------------
  |  Branch (1573:29): [True: 44.0M, False: 55.6k]
  ------------------
 1574|  44.0M|      units[i] = units_[i];
 1575|  44.0M|    }
 1576|  55.6k|  }
 1577|  55.6k|}
_ZN5Darts7Details18DoubleArrayBuilder5clearEv:
 1579|  55.6k|inline void DoubleArrayBuilder::clear() {
 1580|  55.6k|  units_.clear();
 1581|  55.6k|  extras_.clear();
 1582|  55.6k|  labels_.clear();
 1583|  55.6k|  table_.clear();
 1584|  55.6k|  extras_head_ = 0;
 1585|  55.6k|}
_ZN5Darts7Details18DoubleArrayBuilder15build_from_dawgERKNS0_11DawgBuilderE:
 1600|  47.1k|inline void DoubleArrayBuilder::build_from_dawg(const DawgBuilder &dawg) {
 1601|  47.1k|  std::size_t num_units = 1;
 1602|   456k|  while (num_units < dawg.size()) {
  ------------------
  |  Branch (1602:10): [True: 409k, False: 47.1k]
  ------------------
 1603|   409k|    num_units <<= 1;
 1604|   409k|  }
 1605|  47.1k|  units_.reserve(num_units);
 1606|       |
 1607|  47.1k|  table_.reset(new id_type[dawg.num_intersections()]);
 1608|  47.1k|  for (std::size_t i = 0; i < dawg.num_intersections(); ++i) {
  ------------------
  |  Branch (1608:27): [True: 0, False: 47.1k]
  ------------------
 1609|      0|    table_[i] = 0;
 1610|      0|  }
 1611|       |
 1612|  47.1k|  extras_.reset(new extra_type[NUM_EXTRAS]);
 1613|       |
 1614|  47.1k|  reserve_id(0);
 1615|  47.1k|  extras(0).set_is_used(true);
 1616|  47.1k|  units_[0].set_offset(1);
 1617|  47.1k|  units_[0].set_label('\0');
 1618|       |
 1619|  47.1k|  if (dawg.child(dawg.root()) != 0) {
  ------------------
  |  Branch (1619:7): [True: 47.1k, False: 0]
  ------------------
 1620|  47.1k|    build_from_dawg(dawg, dawg.root(), 0);
 1621|  47.1k|  }
 1622|       |
 1623|  47.1k|  fix_all_blocks();
 1624|       |
 1625|  47.1k|  extras_.clear();
 1626|  47.1k|  labels_.clear();
 1627|  47.1k|  table_.clear();
 1628|  47.1k|}
_ZN5Darts7Details18DoubleArrayBuilder15build_from_dawgERKNS0_11DawgBuilderEjj:
 1631|  24.4M|    id_type dawg_id, id_type dic_id) {
 1632|  24.4M|  id_type dawg_child_id = dawg.child(dawg_id);
 1633|  24.4M|  if (dawg.is_intersection(dawg_child_id)) {
  ------------------
  |  Branch (1633:7): [True: 0, False: 24.4M]
  ------------------
 1634|      0|    id_type intersection_id = dawg.intersection_id(dawg_child_id);
 1635|      0|    id_type offset = table_[intersection_id];
 1636|      0|    if (offset != 0) {
  ------------------
  |  Branch (1636:9): [True: 0, False: 0]
  ------------------
 1637|      0|      offset ^= dic_id;
 1638|      0|      if (!(offset & UPPER_MASK) || !(offset & LOWER_MASK)) {
  ------------------
  |  Branch (1638:11): [True: 0, False: 0]
  |  Branch (1638:37): [True: 0, False: 0]
  ------------------
 1639|      0|        if (dawg.is_leaf(dawg_child_id)) {
  ------------------
  |  Branch (1639:13): [True: 0, False: 0]
  ------------------
 1640|      0|          units_[dic_id].set_has_leaf(true);
 1641|      0|        }
 1642|      0|        units_[dic_id].set_offset(offset);
 1643|      0|        return;
 1644|      0|      }
 1645|      0|    }
 1646|      0|  }
 1647|       |
 1648|  24.4M|  id_type offset = arrange_from_dawg(dawg, dawg_id, dic_id);
 1649|  24.4M|  if (dawg.is_intersection(dawg_child_id)) {
  ------------------
  |  Branch (1649:7): [True: 0, False: 24.4M]
  ------------------
 1650|      0|    table_[dawg.intersection_id(dawg_child_id)] = offset;
 1651|      0|  }
 1652|       |
 1653|  31.7M|  do {
 1654|  31.7M|    uchar_type child_label = dawg.label(dawg_child_id);
 1655|  31.7M|    id_type dic_child_id = offset ^ child_label;
 1656|  31.7M|    if (child_label != '\0') {
  ------------------
  |  Branch (1656:9): [True: 24.3M, False: 7.40M]
  ------------------
 1657|  24.3M|      build_from_dawg(dawg, dawg_child_id, dic_child_id);
 1658|  24.3M|    }
 1659|  31.7M|    dawg_child_id = dawg.sibling(dawg_child_id);
 1660|  31.7M|  } while (dawg_child_id != 0);
  ------------------
  |  Branch (1660:12): [True: 7.35M, False: 24.4M]
  ------------------
 1661|  24.4M|}
_ZN5Darts7Details18DoubleArrayBuilder17arrange_from_dawgERKNS0_11DawgBuilderEjj:
 1664|  24.4M|    id_type dawg_id, id_type dic_id) {
 1665|  24.4M|  labels_.resize(0);
 1666|       |
 1667|  24.4M|  id_type dawg_child_id = dawg.child(dawg_id);
 1668|  56.2M|  while (dawg_child_id != 0) {
  ------------------
  |  Branch (1668:10): [True: 31.7M, False: 24.4M]
  ------------------
 1669|  31.7M|    labels_.append(dawg.label(dawg_child_id));
 1670|  31.7M|    dawg_child_id = dawg.sibling(dawg_child_id);
 1671|  31.7M|  }
 1672|       |
 1673|  24.4M|  id_type offset = find_valid_offset(dic_id);
 1674|  24.4M|  units_[dic_id].set_offset(dic_id ^ offset);
 1675|       |
 1676|  24.4M|  dawg_child_id = dawg.child(dawg_id);
 1677|  56.2M|  for (std::size_t i = 0; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1677:27): [True: 31.7M, False: 24.4M]
  ------------------
 1678|  31.7M|    id_type dic_child_id = offset ^ labels_[i];
 1679|  31.7M|    reserve_id(dic_child_id);
 1680|       |
 1681|  31.7M|    if (dawg.is_leaf(dawg_child_id)) {
  ------------------
  |  Branch (1681:9): [True: 7.40M, False: 24.3M]
  ------------------
 1682|  7.40M|      units_[dic_id].set_has_leaf(true);
 1683|  7.40M|      units_[dic_child_id].set_value(dawg.value(dawg_child_id));
 1684|  24.3M|    } else {
 1685|  24.3M|      units_[dic_child_id].set_label(labels_[i]);
 1686|  24.3M|    }
 1687|       |
 1688|  31.7M|    dawg_child_id = dawg.sibling(dawg_child_id);
 1689|  31.7M|  }
 1690|  24.4M|  extras(offset).set_is_used(true);
 1691|       |
 1692|  24.4M|  return offset;
 1693|  24.4M|}
_ZNK5Darts7Details18DoubleArrayBuilder17find_valid_offsetEj:
 1801|  24.5M|inline id_type DoubleArrayBuilder::find_valid_offset(id_type id) const {
 1802|  24.5M|  if (extras_head_ >= units_.size()) {
  ------------------
  |  Branch (1802:7): [True: 90, False: 24.5M]
  ------------------
 1803|     90|    return units_.size() | (id & LOWER_MASK);
 1804|     90|  }
 1805|       |
 1806|  24.5M|  id_type unfixed_id = extras_head_;
 1807|   206M|  do {
 1808|   206M|    id_type offset = unfixed_id ^ labels_[0];
 1809|   206M|    if (is_valid_offset(id, offset)) {
  ------------------
  |  Branch (1809:9): [True: 24.4M, False: 181M]
  ------------------
 1810|  24.4M|      return offset;
 1811|  24.4M|    }
 1812|   181M|    unfixed_id = extras(unfixed_id).next();
 1813|   181M|  } while (unfixed_id != extras_head_);
  ------------------
  |  Branch (1813:12): [True: 181M, False: 116k]
  ------------------
 1814|       |
 1815|   116k|  return units_.size() | (id & LOWER_MASK);
 1816|  24.5M|}
_ZNK5Darts7Details18DoubleArrayBuilder15is_valid_offsetEjj:
 1819|   206M|    id_type offset) const {
 1820|   206M|  if (extras(offset).is_used()) {
  ------------------
  |  Branch (1820:7): [True: 156M, False: 49.7M]
  ------------------
 1821|   156M|    return false;
 1822|   156M|  }
 1823|       |
 1824|  49.7M|  id_type rel_offset = id ^ offset;
 1825|  49.7M|  if ((rel_offset & LOWER_MASK) && (rel_offset & UPPER_MASK)) {
  ------------------
  |  Branch (1825:7): [True: 49.6M, False: 90.8k]
  |  Branch (1825:36): [True: 0, False: 49.6M]
  ------------------
 1826|      0|    return false;
 1827|      0|  }
 1828|       |
 1829|  72.6M|  for (std::size_t i = 1; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1829:27): [True: 48.2M, False: 24.4M]
  ------------------
 1830|  48.2M|    if (extras(offset ^ labels_[i]).is_fixed()) {
  ------------------
  |  Branch (1830:9): [True: 25.2M, False: 22.9M]
  ------------------
 1831|  25.2M|      return false;
 1832|  25.2M|    }
 1833|  48.2M|  }
 1834|       |
 1835|  24.4M|  return true;
 1836|  49.7M|}
_ZN5Darts7Details18DoubleArrayBuilder10reserve_idEj:
 1838|  44.0M|inline void DoubleArrayBuilder::reserve_id(id_type id) {
 1839|  44.0M|  if (id >= units_.size()) {
  ------------------
  |  Branch (1839:7): [True: 172k, False: 43.8M]
  ------------------
 1840|   172k|    expand_units();
 1841|   172k|  }
 1842|       |
 1843|  44.0M|  if (id == extras_head_) {
  ------------------
  |  Branch (1843:7): [True: 17.2M, False: 26.7M]
  ------------------
 1844|  17.2M|    extras_head_ = extras(id).next();
 1845|  17.2M|    if (extras_head_ == id) {
  ------------------
  |  Branch (1845:9): [True: 55.7k, False: 17.1M]
  ------------------
 1846|  55.7k|      extras_head_ = units_.size();
 1847|  55.7k|    }
 1848|  17.2M|  }
 1849|  44.0M|  extras(extras(id).prev()).set_next(extras(id).next());
 1850|  44.0M|  extras(extras(id).next()).set_prev(extras(id).prev());
 1851|  44.0M|  extras(id).set_is_fixed(true);
 1852|  44.0M|}
_ZN5Darts7Details18DoubleArrayBuilder12expand_unitsEv:
 1854|   172k|inline void DoubleArrayBuilder::expand_units() {
 1855|   172k|  id_type src_num_units = units_.size();
 1856|   172k|  id_type src_num_blocks = num_blocks();
 1857|       |
 1858|   172k|  id_type dest_num_units = src_num_units + BLOCK_SIZE;
 1859|   172k|  id_type dest_num_blocks = src_num_blocks + 1;
 1860|       |
 1861|   172k|  if (dest_num_blocks > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1861:7): [True: 9.08k, False: 162k]
  ------------------
 1862|  9.08k|    fix_block(src_num_blocks - NUM_EXTRA_BLOCKS);
 1863|  9.08k|  }
 1864|       |
 1865|   172k|  units_.resize(dest_num_units);
 1866|       |
 1867|   172k|  if (dest_num_blocks > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1867:7): [True: 9.08k, False: 162k]
  ------------------
 1868|  2.33M|    for (std::size_t id = src_num_units; id < dest_num_units; ++id) {
  ------------------
  |  Branch (1868:42): [True: 2.32M, False: 9.08k]
  ------------------
 1869|  2.32M|      extras(id).set_is_used(false);
 1870|  2.32M|      extras(id).set_is_fixed(false);
 1871|  2.32M|    }
 1872|  9.08k|  }
 1873|       |
 1874|  44.0M|  for (id_type i = src_num_units + 1; i < dest_num_units; ++i) {
  ------------------
  |  Branch (1874:39): [True: 43.8M, False: 172k]
  ------------------
 1875|  43.8M|    extras(i - 1).set_next(i);
 1876|  43.8M|    extras(i).set_prev(i - 1);
 1877|  43.8M|  }
 1878|       |
 1879|   172k|  extras(src_num_units).set_prev(dest_num_units - 1);
 1880|   172k|  extras(dest_num_units - 1).set_next(src_num_units);
 1881|       |
 1882|   172k|  extras(src_num_units).set_prev(extras(extras_head_).prev());
 1883|   172k|  extras(dest_num_units - 1).set_next(extras_head_);
 1884|       |
 1885|   172k|  extras(extras(extras_head_).prev()).set_next(src_num_units);
 1886|   172k|  extras(extras_head_).set_prev(dest_num_units - 1);
 1887|   172k|}
_ZN5Darts7Details18DoubleArrayBuilder14fix_all_blocksEv:
 1889|  55.6k|inline void DoubleArrayBuilder::fix_all_blocks() {
 1890|  55.6k|  id_type begin = 0;
 1891|  55.6k|  if (num_blocks() > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1891:7): [True: 705, False: 54.9k]
  ------------------
 1892|    705|    begin = num_blocks() - NUM_EXTRA_BLOCKS;
 1893|    705|  }
 1894|  55.6k|  id_type end = num_blocks();
 1895|       |
 1896|   218k|  for (id_type block_id = begin; block_id != end; ++block_id) {
  ------------------
  |  Branch (1896:34): [True: 162k, False: 55.6k]
  ------------------
 1897|   162k|    fix_block(block_id);
 1898|   162k|  }
 1899|  55.6k|}
_ZN5Darts7Details18DoubleArrayBuilder9fix_blockEj:
 1901|   172k|inline void DoubleArrayBuilder::fix_block(id_type block_id) {
 1902|   172k|  id_type begin = block_id * BLOCK_SIZE;
 1903|   172k|  id_type end = begin + BLOCK_SIZE;
 1904|       |
 1905|   172k|  id_type unused_offset = 0;
 1906|  2.20M|  for (id_type offset = begin; offset != end; ++offset) {
  ------------------
  |  Branch (1906:32): [True: 2.20M, False: 3]
  ------------------
 1907|  2.20M|    if (!extras(offset).is_used()) {
  ------------------
  |  Branch (1907:9): [True: 172k, False: 2.03M]
  ------------------
 1908|   172k|      unused_offset = offset;
 1909|   172k|      break;
 1910|   172k|    }
 1911|  2.20M|  }
 1912|       |
 1913|  44.2M|  for (id_type id = begin; id != end; ++id) {
  ------------------
  |  Branch (1913:28): [True: 44.0M, False: 172k]
  ------------------
 1914|  44.0M|    if (!extras(id).is_fixed()) {
  ------------------
  |  Branch (1914:9): [True: 12.0M, False: 32.0M]
  ------------------
 1915|  12.0M|      reserve_id(id);
 1916|  12.0M|      units_[id].set_label(static_cast<uchar_type>(id ^ unused_offset));
 1917|  12.0M|    }
 1918|  44.0M|  }
 1919|   172k|}
_ZN5Darts7Details9AutoArrayIcE5clearEv:
  608|  7.13M|  void clear() {
  609|  7.13M|    if (array_ != NULL) {
  ------------------
  |  Branch (609:9): [True: 2.54M, False: 4.59M]
  ------------------
  610|  2.54M|      delete[] array_;
  611|       |      array_ = NULL;
  612|  2.54M|    }
  613|  7.13M|  }
_ZNK5Darts7Details8AutoPoolIjEixEm:
  641|   127M|  const T &operator[](std::size_t id) const {
  642|   127M|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  643|   127M|  }
_ZNK5Darts7Details9AutoArrayIcEixEm:
  597|   973M|  const T &operator[](std::size_t id) const {
  598|   973M|    return array_[id];
  599|   973M|  }
_ZN5Darts7Details8AutoPoolIjEixEm:
  644|   464M|  T &operator[](std::size_t id) {
  645|   464M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  646|   464M|  }
_ZN5Darts7Details9AutoArrayIcEixEm:
  600|  1.45G|  T &operator[](std::size_t id) {
  601|  1.45G|    return array_[id];
  602|  1.45G|  }
_ZNK5Darts7Details8AutoPoolIjE5emptyEv:
  648|  31.8M|  bool empty() const {
  649|  31.8M|    return size_ == 0;
  650|  31.8M|  }
_ZN5Darts7Details8AutoPoolIjE6appendERKj:
  674|  64.6M|  void append(const T &value) {
  675|  64.6M|    if (size_ == capacity_)
  ------------------
  |  Branch (675:9): [True: 843k, False: 63.7M]
  ------------------
  676|   843k|      resize_buf(size_ + 1);
  677|  64.6M|    new(&(*this)[size_++]) T(value);
  678|  64.6M|  }
_ZN5Darts7Details8AutoPoolIjE10resize_bufEm:
  722|   904k|void AutoPool<T>::resize_buf(std::size_t size) {
  723|   904k|  std::size_t capacity;
  724|   904k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (724:7): [True: 340k, False: 564k]
  ------------------
  725|   340k|    capacity = size;
  726|   564k|  } else {
  727|   564k|    capacity = 1;
  728|  2.73M|    while (capacity < size) {
  ------------------
  |  Branch (728:12): [True: 2.17M, False: 564k]
  ------------------
  729|  2.17M|      capacity <<= 1;
  730|  2.17M|    }
  731|   564k|  }
  732|       |
  733|   904k|  AutoArray<char> buf;
  734|   904k|  try {
  735|   904k|    buf.reset(new char[sizeof(T) * capacity]);
  736|   904k|  } catch (const std::bad_alloc &) {
  737|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  738|      0|  }
  739|       |
  740|   904k|  if (size_ > 0) {
  ------------------
  |  Branch (740:7): [True: 702k, False: 202k]
  ------------------
  741|   702k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  742|   702k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  743|  8.29M|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (743:29): [True: 7.59M, False: 702k]
  ------------------
  744|  7.59M|      new(&dest[i]) T(src[i]);
  745|  7.59M|      src[i].~T();
  746|  7.59M|    }
  747|   702k|  }
  748|       |
  749|   904k|  buf_.swap(&buf);
  750|   904k|  capacity_ = capacity;
  751|   904k|}
_ZN5Darts7Details9AutoArrayIcE5resetEPc:
  619|  2.54M|  void reset(T *array = NULL) {
  620|  2.54M|    AutoArray(array).swap(this);
  621|  2.54M|  }
_ZN5Darts7Details9AutoArrayIcE4swapEPS2_:
  614|  5.08M|  void swap(AutoArray *array) {
  615|  5.08M|    T *temp = array_;
  616|  5.08M|    array_ = array->array_;
  617|  5.08M|    array->array_ = temp;
  618|  5.08M|  }
_ZN5Darts7Details8AutoPoolIjE5clearEv:
  655|   861k|  void clear() {
  656|   861k|    resize(0);
  657|   861k|    buf_.clear();
  658|   861k|    size_ = 0;
  659|   861k|    capacity_ = 0;
  660|   861k|  }
_ZN5Darts7Details8AutoPoolIjE6resizeEm:
  680|   861k|  void resize(std::size_t size) {
  681|  96.9M|    while (size_ > size) {
  ------------------
  |  Branch (681:12): [True: 96.1M, False: 861k]
  ------------------
  682|  96.1M|      (*this)[--size_].~T();
  683|  96.1M|    }
  684|   861k|    if (size > capacity_) {
  ------------------
  |  Branch (684:9): [True: 0, False: 861k]
  ------------------
  685|      0|      resize_buf(size);
  686|      0|    }
  687|   861k|    while (size_ < size) {
  ------------------
  |  Branch (687:12): [True: 0, False: 861k]
  ------------------
  688|      0|      new(&(*this)[size_++]) T;
  689|      0|    }
  690|   861k|  }
_ZN5Darts7Details9AutoArrayIjE5clearEv:
  608|   441k|  void clear() {
  609|   441k|    if (array_ != NULL) {
  ------------------
  |  Branch (609:9): [True: 94.2k, False: 346k]
  ------------------
  610|  94.2k|      delete[] array_;
  611|       |      array_ = NULL;
  612|  94.2k|    }
  613|   441k|  }
_ZN5Darts7Details9AutoArrayIjE5resetEPj:
  619|  94.2k|  void reset(T *array = NULL) {
  620|  94.2k|    AutoArray(array).swap(this);
  621|  94.2k|  }
_ZN5Darts7Details9AutoArrayIjE4swapEPS2_:
  614|  94.2k|  void swap(AutoArray *array) {
  615|  94.2k|    T *temp = array_;
  616|  94.2k|    array_ = array->array_;
  617|  94.2k|    array->array_ = temp;
  618|  94.2k|  }
_ZNK5Darts7Details8AutoPoolIjE4sizeEv:
  651|   237M|  std::size_t size() const {
  652|   237M|    return size_;
  653|   237M|  }
_ZN5Darts7Details9AutoArrayIjEixEm:
  600|  1.01M|  T &operator[](std::size_t id) {
  601|  1.01M|    return array_[id];
  602|  1.01M|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgUnitEEixEm:
  641|   276M|  const T &operator[](std::size_t id) const {
  642|   276M|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  643|   276M|  }
_ZNK5Darts7Details8AutoPoolIhEixEm:
  641|   370M|  const T &operator[](std::size_t id) const {
  642|   370M|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  643|   370M|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgUnitEE4sizeEv:
  651|  20.8M|  std::size_t size() const {
  652|  20.8M|    return size_;
  653|  20.8M|  }
_ZN5Darts7Details9AutoStackIjE4pushERKj:
  779|  63.6M|  void push(const T &value) {
  780|  63.6M|    pool_.push_back(value);
  781|  63.6M|  }
_ZN5Darts7Details8AutoPoolIjE9push_backERKj:
  662|  63.6M|  void push_back(const T &value) {
  663|  63.6M|    append(value);
  664|  63.6M|  }
_ZN5Darts7Details8AutoPoolIjE6resizeEmRKj:
  691|  60.8k|  void resize(std::size_t size, const T &value) {
  692|  60.8k|    while (size_ > size) {
  ------------------
  |  Branch (692:12): [True: 0, False: 60.8k]
  ------------------
  693|      0|      (*this)[--size_].~T();
  694|      0|    }
  695|  60.8k|    if (size > capacity_) {
  ------------------
  |  Branch (695:9): [True: 60.8k, False: 0]
  ------------------
  696|  60.8k|      resize_buf(size);
  697|  60.8k|    }
  698|  92.0M|    while (size_ < size) {
  ------------------
  |  Branch (698:12): [True: 92.0M, False: 60.8k]
  ------------------
  699|  92.0M|      new(&(*this)[size_++]) T(value);
  700|  92.0M|    }
  701|  60.8k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEEixEm:
  644|   478M|  T &operator[](std::size_t id) {
  645|   478M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  646|   478M|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEEixEm:
  644|   111M|  T &operator[](std::size_t id) {
  645|   111M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  646|   111M|  }
_ZN5Darts7Details8AutoPoolIhEixEm:
  644|   236M|  T &operator[](std::size_t id) {
  645|   236M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  646|   236M|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE5clearEv:
  655|   188k|  void clear() {
  656|   188k|    resize(0);
  657|   188k|    buf_.clear();
  658|   188k|    size_ = 0;
  659|   188k|    capacity_ = 0;
  660|   188k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE6resizeEm:
  680|   188k|  void resize(std::size_t size) {
  681|  3.32M|    while (size_ > size) {
  ------------------
  |  Branch (681:12): [True: 3.13M, False: 188k]
  ------------------
  682|  3.13M|      (*this)[--size_].~T();
  683|  3.13M|    }
  684|   188k|    if (size > capacity_) {
  ------------------
  |  Branch (684:9): [True: 0, False: 188k]
  ------------------
  685|      0|      resize_buf(size);
  686|      0|    }
  687|   188k|    while (size_ < size) {
  ------------------
  |  Branch (687:12): [True: 0, False: 188k]
  ------------------
  688|      0|      new(&(*this)[size_++]) T;
  689|      0|    }
  690|   188k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE10resize_bufEm:
  722|   337k|void AutoPool<T>::resize_buf(std::size_t size) {
  723|   337k|  std::size_t capacity;
  724|   337k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (724:7): [True: 94.2k, False: 242k]
  ------------------
  725|  94.2k|    capacity = size;
  726|   242k|  } else {
  727|   242k|    capacity = 1;
  728|  1.26M|    while (capacity < size) {
  ------------------
  |  Branch (728:12): [True: 1.02M, False: 242k]
  ------------------
  729|  1.02M|      capacity <<= 1;
  730|  1.02M|    }
  731|   242k|  }
  732|       |
  733|   337k|  AutoArray<char> buf;
  734|   337k|  try {
  735|   337k|    buf.reset(new char[sizeof(T) * capacity]);
  736|   337k|  } catch (const std::bad_alloc &) {
  737|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  738|      0|  }
  739|       |
  740|   337k|  if (size_ > 0) {
  ------------------
  |  Branch (740:7): [True: 290k, False: 47.1k]
  ------------------
  741|   290k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  742|   290k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  743|  4.66M|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (743:29): [True: 4.37M, False: 290k]
  ------------------
  744|  4.37M|      new(&dest[i]) T(src[i]);
  745|  4.37M|      src[i].~T();
  746|  4.37M|    }
  747|   290k|  }
  748|       |
  749|   337k|  buf_.swap(&buf);
  750|   337k|  capacity_ = capacity;
  751|   337k|}
_ZN5Darts7Details9AutoStackIjE5clearEv:
  786|   376k|  void clear() {
  787|   376k|    pool_.clear();
  788|   376k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE5clearEv:
  655|   141k|  void clear() {
  656|   141k|    resize(0);
  657|   141k|    buf_.clear();
  658|   141k|    size_ = 0;
  659|   141k|    capacity_ = 0;
  660|   141k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE6resizeEm:
  680|   141k|  void resize(std::size_t size) {
  681|  31.9M|    while (size_ > size) {
  ------------------
  |  Branch (681:12): [True: 31.8M, False: 141k]
  ------------------
  682|  31.8M|      (*this)[--size_].~T();
  683|  31.8M|    }
  684|   141k|    if (size > capacity_) {
  ------------------
  |  Branch (684:9): [True: 0, False: 141k]
  ------------------
  685|      0|      resize_buf(size);
  686|      0|    }
  687|   141k|    while (size_ < size) {
  ------------------
  |  Branch (687:12): [True: 0, False: 141k]
  ------------------
  688|      0|      new(&(*this)[size_++]) T;
  689|      0|    }
  690|   141k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE10resize_bufEm:
  722|   456k|void AutoPool<T>::resize_buf(std::size_t size) {
  723|   456k|  std::size_t capacity;
  724|   456k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (724:7): [True: 94.2k, False: 362k]
  ------------------
  725|  94.2k|    capacity = size;
  726|   362k|  } else {
  727|   362k|    capacity = 1;
  728|  2.39M|    while (capacity < size) {
  ------------------
  |  Branch (728:12): [True: 2.03M, False: 362k]
  ------------------
  729|  2.03M|      capacity <<= 1;
  730|  2.03M|    }
  731|   362k|  }
  732|       |
  733|   456k|  AutoArray<char> buf;
  734|   456k|  try {
  735|   456k|    buf.reset(new char[sizeof(T) * capacity]);
  736|   456k|  } catch (const std::bad_alloc &) {
  737|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  738|      0|  }
  739|       |
  740|   456k|  if (size_ > 0) {
  ------------------
  |  Branch (740:7): [True: 409k, False: 47.1k]
  ------------------
  741|   409k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  742|   409k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  743|  46.1M|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (743:29): [True: 45.7M, False: 409k]
  ------------------
  744|  45.7M|      new(&dest[i]) T(src[i]);
  745|  45.7M|      src[i].~T();
  746|  45.7M|    }
  747|   409k|  }
  748|       |
  749|   456k|  buf_.swap(&buf);
  750|   456k|  capacity_ = capacity;
  751|   456k|}
_ZN5Darts7Details8AutoPoolIhE5clearEv:
  655|   308k|  void clear() {
  656|   308k|    resize(0);
  657|   308k|    buf_.clear();
  658|   308k|    size_ = 0;
  659|   308k|    capacity_ = 0;
  660|   308k|  }
_ZN5Darts7Details9AutoStackIjE3topEv:
  768|   109M|  T &top() {
  769|   109M|    return pool_[size() - 1];
  770|   109M|  }
_ZNK5Darts7Details9AutoStackIjE4sizeEv:
  775|   109M|  std::size_t size() const {
  776|   109M|    return pool_.size();
  777|   109M|  }
_ZN5Darts7Details9AutoStackIjE3popEv:
  782|  60.5M|  void pop() {
  783|  60.5M|    pool_.pop_back();
  784|  60.5M|  }
_ZN5Darts7Details8AutoPoolIjE8pop_backEv:
  665|  60.5M|  void pop_back() {
  666|  60.5M|    (*this)[--size_].~T();
  667|  60.5M|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgNodeEEixEm:
  641|   155M|  const T &operator[](std::size_t id) const {
  642|   155M|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  643|   155M|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE6appendEv:
  669|  31.8M|  void append() {
  670|  31.8M|    if (size_ == capacity_)
  ------------------
  |  Branch (670:9): [True: 456k, False: 31.3M]
  ------------------
  671|   456k|      resize_buf(size_ + 1);
  672|  31.8M|    new(&(*this)[size_++]) T;
  673|  31.8M|  }
_ZN5Darts7Details8AutoPoolIhE6appendEv:
  669|  31.8M|  void append() {
  670|  31.8M|    if (size_ == capacity_)
  ------------------
  |  Branch (670:9): [True: 456k, False: 31.3M]
  ------------------
  671|   456k|      resize_buf(size_ + 1);
  672|  31.8M|    new(&(*this)[size_++]) T;
  673|  31.8M|  }
_ZN5Darts7Details8AutoPoolIhE10resize_bufEm:
  722|   756k|void AutoPool<T>::resize_buf(std::size_t size) {
  723|   756k|  std::size_t capacity;
  724|   756k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (724:7): [True: 205k, False: 551k]
  ------------------
  725|   205k|    capacity = size;
  726|   551k|  } else {
  727|   551k|    capacity = 1;
  728|  3.26M|    while (capacity < size) {
  ------------------
  |  Branch (728:12): [True: 2.71M, False: 551k]
  ------------------
  729|  2.71M|      capacity <<= 1;
  730|  2.71M|    }
  731|   551k|  }
  732|       |
  733|   756k|  AutoArray<char> buf;
  734|   756k|  try {
  735|   756k|    buf.reset(new char[sizeof(T) * capacity]);
  736|   756k|  } catch (const std::bad_alloc &) {
  737|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  738|      0|  }
  739|       |
  740|   756k|  if (size_ > 0) {
  ------------------
  |  Branch (740:7): [True: 653k, False: 102k]
  ------------------
  741|   653k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  742|   653k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  743|  48.3M|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (743:29): [True: 47.7M, False: 653k]
  ------------------
  744|  47.7M|      new(&dest[i]) T(src[i]);
  745|  47.7M|      src[i].~T();
  746|  47.7M|    }
  747|   653k|  }
  748|       |
  749|   756k|  buf_.swap(&buf);
  750|   756k|  capacity_ = capacity;
  751|   756k|}
_ZNK5Darts7Details9AutoStackIjE5emptyEv:
  772|  31.8M|  bool empty() const {
  773|  31.8M|    return pool_.empty();
  774|  31.8M|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgNodeEE4sizeEv:
  651|  3.13M|  std::size_t size() const {
  652|  3.13M|    return size_;
  653|  3.13M|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE6appendEv:
  669|  3.13M|  void append() {
  670|  3.13M|    if (size_ == capacity_)
  ------------------
  |  Branch (670:9): [True: 337k, False: 2.79M]
  ------------------
  671|   337k|      resize_buf(size_ + 1);
  672|  3.13M|    new(&(*this)[size_++]) T;
  673|  3.13M|  }
_ZNK5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE4sizeEv:
  651|   113M|  std::size_t size() const {
  652|   113M|    return size_;
  653|   113M|  }
_ZNK5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEixEm:
  597|   436M|  const T &operator[](std::size_t id) const {
  598|   436M|    return array_[id];
  599|   436M|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEixEm:
  600|   490M|  T &operator[](std::size_t id) {
  601|   490M|    return array_[id];
  602|   490M|  }
_ZNK5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEixEm:
  641|  44.0M|  const T &operator[](std::size_t id) const {
  642|  44.0M|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  643|  44.0M|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE5clearEv:
  655|   111k|  void clear() {
  656|   111k|    resize(0);
  657|   111k|    buf_.clear();
  658|   111k|    size_ = 0;
  659|   111k|    capacity_ = 0;
  660|   111k|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE5clearEv:
  608|   222k|  void clear() {
  609|   222k|    if (array_ != NULL) {
  ------------------
  |  Branch (609:9): [True: 55.6k, False: 166k]
  ------------------
  610|  55.6k|      delete[] array_;
  611|       |      array_ = NULL;
  612|  55.6k|    }
  613|   222k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE7reserveEm:
  703|  55.6k|  void reserve(std::size_t size) {
  704|  55.6k|    if (size > capacity_) {
  ------------------
  |  Branch (704:9): [True: 55.6k, False: 0]
  ------------------
  705|  55.6k|      resize_buf(size);
  706|  55.6k|    }
  707|  55.6k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE10resize_bufEm:
  722|  85.7k|void AutoPool<T>::resize_buf(std::size_t size) {
  723|  85.7k|  std::size_t capacity;
  724|  85.7k|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (724:7): [True: 81.7k, False: 4.08k]
  ------------------
  725|  81.7k|    capacity = size;
  726|  81.7k|  } else {
  727|  4.08k|    capacity = 1;
  728|  46.7k|    while (capacity < size) {
  ------------------
  |  Branch (728:12): [True: 42.6k, False: 4.08k]
  ------------------
  729|  42.6k|      capacity <<= 1;
  730|  42.6k|    }
  731|  4.08k|  }
  732|       |
  733|  85.7k|  AutoArray<char> buf;
  734|  85.7k|  try {
  735|  85.7k|    buf.reset(new char[sizeof(T) * capacity]);
  736|  85.7k|  } catch (const std::bad_alloc &) {
  737|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  738|      0|  }
  739|       |
  740|  85.7k|  if (size_ > 0) {
  ------------------
  |  Branch (740:7): [True: 8.94k, False: 76.8k]
  ------------------
  741|  8.94k|    T *src = reinterpret_cast<T *>(&buf_[0]);
  742|  8.94k|    T *dest = reinterpret_cast<T *>(&buf[0]);
  743|  4.59M|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (743:29): [True: 4.58M, False: 8.94k]
  ------------------
  744|  4.58M|      new(&dest[i]) T(src[i]);
  745|  4.58M|      src[i].~T();
  746|  4.58M|    }
  747|  8.94k|  }
  748|       |
  749|  85.7k|  buf_.swap(&buf);
  750|  85.7k|  capacity_ = capacity;
  751|  85.7k|}
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE5resetEPS2_:
  619|  55.6k|  void reset(T *array = NULL) {
  620|  55.6k|    AutoArray(array).swap(this);
  621|  55.6k|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE4swapEPS3_:
  614|  55.6k|  void swap(AutoArray *array) {
  615|  55.6k|    T *temp = array_;
  616|  55.6k|    array_ = array->array_;
  617|  55.6k|    array->array_ = temp;
  618|  55.6k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEixEm:
  644|   164M|  T &operator[](std::size_t id) {
  645|   164M|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  646|   164M|  }
_ZN5Darts7Details8AutoPoolIhE6resizeEm:
  680|  24.8M|  void resize(std::size_t size) {
  681|  88.6M|    while (size_ > size) {
  ------------------
  |  Branch (681:12): [True: 63.7M, False: 24.8M]
  ------------------
  682|  63.7M|      (*this)[--size_].~T();
  683|  63.7M|    }
  684|  24.8M|    if (size > capacity_) {
  ------------------
  |  Branch (684:9): [True: 0, False: 24.8M]
  ------------------
  685|      0|      resize_buf(size);
  686|      0|    }
  687|  24.8M|    while (size_ < size) {
  ------------------
  |  Branch (687:12): [True: 0, False: 24.8M]
  ------------------
  688|      0|      new(&(*this)[size_++]) T;
  689|      0|    }
  690|  24.8M|  }
_ZN5Darts7Details8AutoPoolIhE6appendERKh:
  674|  31.9M|  void append(const T &value) {
  675|  31.9M|    if (size_ == capacity_)
  ------------------
  |  Branch (675:9): [True: 299k, False: 31.6M]
  ------------------
  676|   299k|      resize_buf(size_ + 1);
  677|  31.9M|    new(&(*this)[size_++]) T(value);
  678|  31.9M|  }
_ZNK5Darts7Details8AutoPoolIhE4sizeEv:
  651|   129M|  std::size_t size() const {
  652|   129M|    return size_;
  653|   129M|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE6resizeEm:
  680|   283k|  void resize(std::size_t size) {
  681|  44.3M|    while (size_ > size) {
  ------------------
  |  Branch (681:12): [True: 44.0M, False: 283k]
  ------------------
  682|  44.0M|      (*this)[--size_].~T();
  683|  44.0M|    }
  684|   283k|    if (size > capacity_) {
  ------------------
  |  Branch (684:9): [True: 30.1k, False: 253k]
  ------------------
  685|  30.1k|      resize_buf(size);
  686|  30.1k|    }
  687|  44.3M|    while (size_ < size) {
  ------------------
  |  Branch (687:12): [True: 44.0M, False: 283k]
  ------------------
  688|  44.0M|      new(&(*this)[size_++]) T;
  689|  44.0M|    }
  690|   283k|  }
_ZN5Darts15DoubleArrayImplIvvivEC2Ev:
  139|  72.7k|  DoubleArrayImpl() : size_(0), array_(NULL), buf_(NULL) {}
_ZN5Darts15DoubleArrayImplIvvivED2Ev:
  142|  72.7k|  virtual ~DoubleArrayImpl() {
  143|  72.7k|    clear();
  144|  72.7k|  }
_ZN5Darts15DoubleArrayImplIvvivE5clearEv:
  194|   145k|  void clear() {
  195|   145k|    size_ = 0;
  196|   145k|    array_ = NULL;
  197|   145k|    if (buf_ != NULL) {
  ------------------
  |  Branch (197:9): [True: 55.6k, False: 89.8k]
  ------------------
  198|  55.6k|      delete[] buf_;
  199|       |      buf_ = NULL;
  200|  55.6k|    }
  201|   145k|  }
_ZN5Darts15DoubleArrayImplIvvivE5buildEmPKPKcPKmPKiPFimmE:
 1930|  55.6k|    const value_type *values, Details::progress_func_type progress_func) {
 1931|  55.6k|  Details::Keyset<value_type> keyset(num_keys, keys, lengths, values);
 1932|       |
 1933|  55.6k|  Details::DoubleArrayBuilder builder(progress_func);
 1934|  55.6k|  builder.build(keyset);
 1935|       |
 1936|  55.6k|  std::size_t size = 0;
 1937|  55.6k|  unit_type *buf = NULL;
 1938|  55.6k|  builder.copy(&size, &buf);
 1939|       |
 1940|  55.6k|  clear();
 1941|       |
 1942|  55.6k|  size_ = size;
 1943|  55.6k|  array_ = buf;
 1944|  55.6k|  buf_ = buf;
 1945|       |
 1946|  55.6k|  if (progress_func != NULL) {
  ------------------
  |  Branch (1946:7): [True: 0, False: 55.6k]
  ------------------
 1947|      0|    progress_func(num_keys + 1, num_keys + 1);
 1948|      0|  }
 1949|       |
 1950|  55.6k|  return 0;
 1951|  55.6k|}
_ZN5Darts7Details6KeysetIiEC2EmPKPKcPKmPKi:
  895|  55.6k|      num_keys_(num_keys), keys_(keys), lengths_(lengths), values_(values) {}
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEC2Ev:
  638|  55.6k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoArrayIcEC2EPc:
  592|  5.52M|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEC2EPS2_:
  592|   111k|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details8AutoPoolIhEC2Ev:
  638|   102k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoArrayIjEC2EPj:
  592|   197k|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details8AutoPoolIhED2Ev:
  639|   102k|  ~AutoPool() { clear(); }
_ZN5Darts7Details9AutoArrayIcED2Ev:
  593|  5.52M|  ~AutoArray() {
  594|  5.52M|    clear();
  595|  5.52M|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEED2Ev:
  593|   111k|  ~AutoArray() {
  594|   111k|    clear();
  595|   111k|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEED2Ev:
  639|  55.6k|  ~AutoPool() { clear(); }
_ZN5Darts7Details18DoubleArrayBuilder5buildIiEEvRKNS0_6KeysetIT_EE:
 1554|  55.6k|void DoubleArrayBuilder::build(const Keyset<T> &keyset) {
 1555|  55.6k|  if (keyset.has_values()) {
  ------------------
  |  Branch (1555:7): [True: 47.1k, False: 8.53k]
  ------------------
 1556|  47.1k|    Details::DawgBuilder dawg_builder;
 1557|  47.1k|    build_dawg(keyset, &dawg_builder);
 1558|  47.1k|    build_from_dawg(dawg_builder);
 1559|  47.1k|    dawg_builder.clear();
 1560|  47.1k|  } else {
 1561|  8.53k|    build_from_keyset(keyset);
 1562|  8.53k|  }
 1563|  55.6k|}
_ZNK5Darts7Details6KeysetIiE10has_valuesEv:
  923|  7.54M|  bool has_values() const {
  924|       |    return values_ != NULL;
  925|  7.54M|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEEC2Ev:
  638|  47.1k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEEC2Ev:
  638|  47.1k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details8AutoPoolIjEC2Ev:
  638|   188k|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoStackIjEC2Ev:
  760|  94.2k|  AutoStack() : pool_() {}
_ZN5Darts7Details9AutoStackIjED2Ev:
  761|  94.2k|  ~AutoStack() {
  762|  94.2k|    clear();
  763|  94.2k|  }
_ZN5Darts7Details8AutoPoolIjED2Ev:
  639|   188k|  ~AutoPool() { clear(); }
_ZN5Darts7Details9AutoArrayIjED2Ev:
  593|   197k|  ~AutoArray() {
  594|   197k|    clear();
  595|   197k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEED2Ev:
  639|  47.1k|  ~AutoPool() { clear(); }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEED2Ev:
  639|  47.1k|  ~AutoPool() { clear(); }
_ZN5Darts7Details18DoubleArrayBuilder10build_dawgIiEEvRKNS0_6KeysetIT_EEPNS0_11DawgBuilderE:
 1589|  47.1k|    DawgBuilder *dawg_builder) {
 1590|  47.1k|  dawg_builder->init();
 1591|  7.45M|  for (std::size_t i = 0; i < keyset.num_keys(); ++i) {
  ------------------
  |  Branch (1591:27): [True: 7.40M, False: 47.1k]
  ------------------
 1592|  7.40M|    dawg_builder->insert(keyset.keys(i), keyset.lengths(i), keyset.values(i));
 1593|  7.40M|    if (progress_func_ != NULL) {
  ------------------
  |  Branch (1593:9): [True: 0, False: 7.40M]
  ------------------
 1594|      0|      progress_func_(i + 1, keyset.num_keys() + 1);
 1595|      0|    }
 1596|  7.40M|  }
 1597|  47.1k|  dawg_builder->finish();
 1598|  47.1k|}
_ZNK5Darts7Details6KeysetIiE8num_keysEv:
  897|  7.49M|  std::size_t num_keys() const {
  898|  7.49M|    return num_keys_;
  899|  7.49M|  }
_ZNK5Darts7Details6KeysetIiE4keysEm:
  900|  7.40M|  const char_type *keys(std::size_t id) const {
  901|  7.40M|    return keys_[id];
  902|  7.40M|  }
_ZNK5Darts7Details6KeysetIiE7lengthsEm:
  912|  7.44M|  std::size_t lengths(std::size_t id) const {
  913|  7.44M|    if (has_lengths()) {
  ------------------
  |  Branch (913:9): [True: 7.44M, False: 0]
  ------------------
  914|  7.44M|      return lengths_[id];
  915|  7.44M|    }
  916|      0|    std::size_t length = 0;
  917|      0|    while (keys_[id][length] != '\0') {
  ------------------
  |  Branch (917:12): [True: 0, False: 0]
  ------------------
  918|      0|      ++length;
  919|      0|    }
  920|      0|    return length;
  921|  7.44M|  }
_ZNK5Darts7Details6KeysetIiE11has_lengthsEv:
  909|  8.11M|  bool has_lengths() const {
  910|       |    return lengths_ != NULL;
  911|  8.11M|  }
_ZNK5Darts7Details6KeysetIiE6valuesEm:
  926|  7.49M|  const value_type values(std::size_t id) const {
  927|  7.49M|    if (has_values()) {
  ------------------
  |  Branch (927:9): [True: 7.40M, False: 86.0k]
  ------------------
  928|  7.40M|      return static_cast<value_type>(values_[id]);
  929|  7.40M|    }
  930|  86.0k|    return static_cast<value_type>(id);
  931|  7.49M|  }
_ZN5Darts7Details18DoubleArrayBuilder17build_from_keysetIiEEvRKNS0_6KeysetIT_EE:
 1696|  8.53k|void DoubleArrayBuilder::build_from_keyset(const Keyset<T> &keyset) {
 1697|  8.53k|  std::size_t num_units = 1;
 1698|  26.0k|  while (num_units < keyset.num_keys()) {
  ------------------
  |  Branch (1698:10): [True: 17.5k, False: 8.53k]
  ------------------
 1699|  17.5k|    num_units <<= 1;
 1700|  17.5k|  }
 1701|  8.53k|  units_.reserve(num_units);
 1702|       |
 1703|  8.53k|  extras_.reset(new extra_type[NUM_EXTRAS]);
 1704|       |
 1705|  8.53k|  reserve_id(0);
 1706|  8.53k|  extras(0).set_is_used(true);
 1707|  8.53k|  units_[0].set_offset(1);
 1708|  8.53k|  units_[0].set_label('\0');
 1709|       |
 1710|  8.53k|  if (keyset.num_keys() > 0) {
  ------------------
  |  Branch (1710:7): [True: 8.53k, False: 0]
  ------------------
 1711|  8.53k|    build_from_keyset(keyset, 0, keyset.num_keys(), 0, 0);
 1712|  8.53k|  }
 1713|       |
 1714|  8.53k|  fix_all_blocks();
 1715|       |
 1716|  8.53k|  extras_.clear();
 1717|  8.53k|  labels_.clear();
 1718|  8.53k|}
_ZN5Darts7Details18DoubleArrayBuilder17build_from_keysetIiEEvRKNS0_6KeysetIT_EEmmmj:
 1722|   129k|    std::size_t begin, std::size_t end, std::size_t depth, id_type dic_id) {
 1723|   129k|  id_type offset = arrange_from_keyset(keyset, begin, end, depth, dic_id);
 1724|       |
 1725|   172k|  while (begin < end) {
  ------------------
  |  Branch (1725:10): [True: 129k, False: 43.0k]
  ------------------
 1726|   129k|    if (keyset.keys(begin, depth) != '\0') {
  ------------------
  |  Branch (1726:9): [True: 86.9k, False: 43.0k]
  ------------------
 1727|  86.9k|      break;
 1728|  86.9k|    }
 1729|  43.0k|    ++begin;
 1730|  43.0k|  }
 1731|   129k|  if (begin == end) {
  ------------------
  |  Branch (1731:7): [True: 43.0k, False: 86.9k]
  ------------------
 1732|  43.0k|    return;
 1733|  43.0k|  }
 1734|       |
 1735|  86.9k|  std::size_t last_begin = begin;
 1736|  86.9k|  uchar_type last_label = keyset.keys(begin, depth);
 1737|   206k|  while (++begin < end) {
  ------------------
  |  Branch (1737:10): [True: 119k, False: 86.9k]
  ------------------
 1738|   119k|    uchar_type label = keyset.keys(begin, depth);
 1739|   119k|    if (label != last_label) {
  ------------------
  |  Branch (1739:9): [True: 34.4k, False: 85.4k]
  ------------------
 1740|  34.4k|      build_from_keyset(keyset, last_begin, begin,
 1741|  34.4k|          depth + 1, offset ^ last_label);
 1742|  34.4k|      last_begin = begin;
 1743|  34.4k|      last_label = keyset.keys(begin, depth);
 1744|  34.4k|    }
 1745|   119k|  }
 1746|  86.9k|  build_from_keyset(keyset, last_begin, end, depth + 1, offset ^ last_label);
 1747|  86.9k|}
_ZN5Darts7Details18DoubleArrayBuilder19arrange_from_keysetIiEEjRKNS0_6KeysetIT_EEmmmj:
 1751|   129k|    std::size_t begin, std::size_t end, std::size_t depth, id_type dic_id) {
 1752|   129k|  labels_.resize(0);
 1753|       |
 1754|   129k|  value_type value = -1;
 1755|   379k|  for (std::size_t i = begin; i < end; ++i) {
  ------------------
  |  Branch (1755:31): [True: 249k, False: 129k]
  ------------------
 1756|   249k|    uchar_type label = keyset.keys(i, depth);
 1757|   249k|    if (label == '\0') {
  ------------------
  |  Branch (1757:9): [True: 43.0k, False: 206k]
  ------------------
 1758|  43.0k|      if (keyset.has_lengths() && depth < keyset.lengths(i)) {
  ------------------
  |  Branch (1758:11): [True: 43.0k, False: 0]
  |  Branch (1758:35): [True: 0, False: 43.0k]
  ------------------
 1759|      0|        DARTS_THROW("failed to build double-array: "
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1760|      0|            "invalid null character");
 1761|  43.0k|      } else if (keyset.values(i) < 0) {
  ------------------
  |  Branch (1761:18): [True: 0, False: 43.0k]
  ------------------
 1762|      0|        DARTS_THROW("failed to build double-array: negative value");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1763|      0|      }
 1764|       |
 1765|  43.0k|      if (value == -1) {
  ------------------
  |  Branch (1765:11): [True: 43.0k, False: 0]
  ------------------
 1766|  43.0k|        value = keyset.values(i);
 1767|  43.0k|      }
 1768|  43.0k|      if (progress_func_ != NULL) {
  ------------------
  |  Branch (1768:11): [True: 0, False: 43.0k]
  ------------------
 1769|      0|        progress_func_(i + 1, keyset.num_keys() + 1);
 1770|      0|      }
 1771|  43.0k|    }
 1772|       |
 1773|   249k|    if (labels_.empty()) {
  ------------------
  |  Branch (1773:9): [True: 129k, False: 119k]
  ------------------
 1774|   129k|      labels_.append(label);
 1775|   129k|    } else if (label != labels_[labels_.size() - 1]) {
  ------------------
  |  Branch (1775:16): [True: 34.4k, False: 85.4k]
  ------------------
 1776|  34.4k|      if (label < labels_[labels_.size() - 1]) {
  ------------------
  |  Branch (1776:11): [True: 0, False: 34.4k]
  ------------------
 1777|      0|        DARTS_THROW("failed to build double-array: wrong key order");
  ------------------
  |  |   19|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   20|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1778|      0|      }
 1779|  34.4k|      labels_.append(label);
 1780|  34.4k|    }
 1781|   249k|  }
 1782|       |
 1783|   129k|  id_type offset = find_valid_offset(dic_id);
 1784|   129k|  units_[dic_id].set_offset(dic_id ^ offset);
 1785|       |
 1786|   294k|  for (std::size_t i = 0; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1786:27): [True: 164k, False: 129k]
  ------------------
 1787|   164k|    id_type dic_child_id = offset ^ labels_[i];
 1788|   164k|    reserve_id(dic_child_id);
 1789|   164k|    if (labels_[i] == '\0') {
  ------------------
  |  Branch (1789:9): [True: 43.0k, False: 121k]
  ------------------
 1790|  43.0k|      units_[dic_id].set_has_leaf(true);
 1791|  43.0k|      units_[dic_child_id].set_value(value);
 1792|   121k|    } else {
 1793|   121k|      units_[dic_child_id].set_label(labels_[i]);
 1794|   121k|    }
 1795|   164k|  }
 1796|   129k|  extras(offset).set_is_used(true);
 1797|       |
 1798|   129k|  return offset;
 1799|   129k|}
_ZNK5Darts7Details8AutoPoolIhE5emptyEv:
  648|   249k|  bool empty() const {
  649|   249k|    return size_ == 0;
  650|   249k|  }
_ZNK5Darts7Details6KeysetIiE4keysEmm:
  903|   621k|  uchar_type keys(std::size_t key_id, std::size_t char_id) const {
  904|   621k|    if (has_lengths() && char_id >= lengths_[key_id])
  ------------------
  |  Branch (904:9): [True: 621k, False: 0]
  |  Branch (904:26): [True: 86.0k, False: 535k]
  ------------------
  905|  86.0k|      return '\0';
  906|   535k|    return keys_[key_id][char_id];
  907|   621k|  }
_ZNK5Darts15DoubleArrayImplIvvivE18commonPrefixSearchINS1_16result_pair_typeEEEmPKcPT_mmm:
  505|   135M|    std::size_t length, std::size_t node_pos) const {
  506|   135M|  std::size_t num_results = 0;
  507|       |
  508|   135M|  unit_type unit = array_[node_pos];
  509|   135M|  node_pos ^= unit.offset();
  510|   135M|  if (length != 0) {
  ------------------
  |  Branch (510:7): [True: 135M, False: 0]
  ------------------
  511|   769M|    for (std::size_t i = 0; i < length; ++i) {
  ------------------
  |  Branch (511:29): [True: 749M, False: 19.4M]
  ------------------
  512|   749M|      node_pos ^= static_cast<uchar_type>(key[i]);
  513|   749M|      unit = array_[node_pos];
  514|   749M|      if (unit.label() != static_cast<uchar_type>(key[i])) {
  ------------------
  |  Branch (514:11): [True: 116M, False: 633M]
  ------------------
  515|   116M|        return num_results;
  516|   116M|      }
  517|       |
  518|   633M|      node_pos ^= unit.offset();
  519|   633M|      if (unit.has_leaf()) {
  ------------------
  |  Branch (519:11): [True: 232M, False: 400M]
  ------------------
  520|   232M|        if (num_results < max_num_results) {
  ------------------
  |  Branch (520:13): [True: 232M, False: 0]
  ------------------
  521|   232M|          set_result(&results[num_results], static_cast<value_type>(
  522|   232M|              array_[node_pos].value()), i + 1);
  523|   232M|        }
  524|   232M|        ++num_results;
  525|   232M|      }
  526|   633M|    }
  527|   135M|  } else {
  528|      0|    for ( ; key[length] != '\0'; ++length) {
  ------------------
  |  Branch (528:13): [True: 0, False: 0]
  ------------------
  529|      0|      node_pos ^= static_cast<uchar_type>(key[length]);
  530|      0|      unit = array_[node_pos];
  531|      0|      if (unit.label() != static_cast<uchar_type>(key[length])) {
  ------------------
  |  Branch (531:11): [True: 0, False: 0]
  ------------------
  532|      0|        return num_results;
  533|      0|      }
  534|       |
  535|      0|      node_pos ^= unit.offset();
  536|      0|      if (unit.has_leaf()) {
  ------------------
  |  Branch (536:11): [True: 0, False: 0]
  ------------------
  537|      0|        if (num_results < max_num_results) {
  ------------------
  |  Branch (537:13): [True: 0, False: 0]
  ------------------
  538|      0|          set_result(&results[num_results], static_cast<value_type>(
  539|      0|              array_[node_pos].value()), length + 1);
  540|      0|        }
  541|      0|        ++num_results;
  542|      0|      }
  543|      0|    }
  544|      0|  }
  545|       |
  546|  19.4M|  return num_results;
  547|   135M|}
_ZNK5Darts15DoubleArrayImplIvvivE10set_resultEPNS1_16result_pair_typeEim:
  160|   232M|      value_type value, std::size_t length) const {
  161|   232M|    result->value = value;
  162|   232M|    result->length = length;
  163|   232M|  }
_ZNK5Darts15DoubleArrayImplIvvivE9unit_sizeEv:
  204|  17.0k|  std::size_t unit_size() const {
  205|  17.0k|    return sizeof(unit_type);
  206|  17.0k|  }
_ZNK5Darts15DoubleArrayImplIvvivE8validateEi:
  445|  17.0k|bool DoubleArrayImpl<A, B, T, C>::validate(value_type max_value_limit) const {
  446|  17.0k|  if (size_ == 0 || array_ == NULL) return false;
  ------------------
  |  Branch (446:7): [True: 0, False: 17.0k]
  |  Branch (446:21): [True: 0, False: 17.0k]
  ------------------
  447|  17.0k|  if (array_[0].label() != '\0' || array_[0].has_leaf() ||
  ------------------
  |  Branch (447:7): [True: 0, False: 17.0k]
  |  Branch (447:36): [True: 0, False: 17.0k]
  ------------------
  448|  17.0k|      array_[0].offset() == 0 || ((0 ^ array_[0].offset()) | 0xFF) >= size_) {
  ------------------
  |  Branch (448:7): [True: 0, False: 17.0k]
  |  Branch (448:34): [True: 0, False: 17.0k]
  ------------------
  449|      0|    return false;
  450|      0|  }
  451|   765M|  for (std::size_t i = 1; i < size_; ++i) {
  ------------------
  |  Branch (451:27): [True: 765M, False: 17.0k]
  ------------------
  452|   765M|    if (array_[i].label() <= 0xFF) {
  ------------------
  |  Branch (452:9): [True: 510M, False: 255M]
  ------------------
  453|   510M|      if (((i ^ array_[i].offset()) | 0xFF) >= size_) {
  ------------------
  |  Branch (453:11): [True: 0, False: 510M]
  ------------------
  454|      0|        return false;
  455|      0|      }
  456|   510M|    } else {
  457|   255M|      if (max_value_limit >= 0) {
  ------------------
  |  Branch (457:11): [True: 255M, False: 0]
  ------------------
  458|   255M|        if (array_[i].value() >= max_value_limit) {
  ------------------
  |  Branch (458:13): [True: 0, False: 255M]
  ------------------
  459|      0|          return false;
  460|      0|        }
  461|   255M|      }
  462|   255M|    }
  463|   765M|  }
  464|  17.0k|  return true;
  465|  17.0k|}
_ZN5Darts15DoubleArrayImplIvvivE9set_arrayEPKvm:
  172|  17.0k|  void set_array(const void *ptr, std::size_t size = 0) {
  173|  17.0k|    clear();
  174|  17.0k|    array_ = static_cast<const unit_type *>(ptr);
  175|  17.0k|    size_ = size;
  176|  17.0k|  }

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

_Z6saisxxINSt3__111__wrap_iterIPDiEENS1_IPiEEiEiT_T0_T1_S8_:
  326|  5.83k|saisxx(string_type T, sarray_type SA, index_type n, index_type k = 256) {
  327|  5.83k|  int err;
  328|  5.83k|  if((n < 0) || (k <= 0)) { return -1; }
  ------------------
  |  Branch (328:6): [True: 0, False: 5.83k]
  |  Branch (328:17): [True: 0, False: 5.83k]
  ------------------
  329|  5.83k|  if(n <= 1) { if(n == 1) { SA[0] = 0; } return 0; }
  ------------------
  |  Branch (329:6): [True: 0, False: 5.83k]
  |  Branch (329:19): [True: 0, False: 0]
  ------------------
  330|  5.83k|  try { err = saisxx_private::suffixsort(T, SA, index_type(0), n, k, false); }
  331|  5.83k|  catch(...) { err = -2; }
  332|  5.83k|  return err;
  333|  5.83k|}
_ZN14saisxx_private10suffixsortINSt3__111__wrap_iterIPDiEENS2_IPiEEiEEiT_T0_T1_S9_S9_b:
  164|  5.83k|           bool isbwt) {
  165|  5.83k|typedef typename std::iterator_traits<string_type>::value_type char_type;
  166|  5.83k|  sarray_type RA;
  167|  5.83k|  index_type i, j, m, p, q, plen, qlen, name;
  168|  5.83k|  int pidx = 0;
  169|  5.83k|  bool diff;
  170|  5.83k|  int c;
  171|       |#ifdef _OPENMP
  172|       |  int maxthreads = omp_get_max_threads();
  173|       |#else
  174|  5.83k|# define maxthreads 1
  175|  5.83k|#endif
  176|  5.83k|  char_type c0, c1;
  177|       |
  178|       |  /* stage 1: reduce the problem by at least 1/2
  179|       |     sort all the S-substrings */
  180|  5.83k|  if(fs < (maxthreads * k)) {
  ------------------
  |  |  174|  5.83k|# define maxthreads 1
  ------------------
  |  Branch (180:6): [True: 5.83k, False: 0]
  ------------------
  181|  5.83k|    index_type *C, *B;
  182|  5.83k|    C = new index_type[maxthreads * k];
  ------------------
  |  |  174|  5.83k|# define maxthreads 1
  ------------------
  183|  5.83k|    B = (1 < maxthreads) ? C + k : C;
  ------------------
  |  |  174|  5.83k|# define maxthreads 1
  ------------------
  |  Branch (183:9): [Folded, False: 5.83k]
  ------------------
  184|  5.83k|    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.20M|    for(i = 0; i < n; ++i) { SA[i] = 0; }
  ------------------
  |  Branch (188:16): [True: 6.19M, False: 5.83k]
  ------------------
  189|  6.19M|    for(i = n - 2, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (189:42): [True: 6.19M, False: 5.83k]
  ------------------
  190|  6.19M|      if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (190:10): [True: 2.74M, False: 3.44M]
  ------------------
  191|  3.44M|      else if(c != 0) { SA[--B[c1]] = i + 1, c = 0; }
  ------------------
  |  Branch (191:15): [True: 1.51M, False: 1.93M]
  ------------------
  192|  6.19M|    }
  193|  5.83k|    induceSA(T, SA, C, B, n, k);
  194|  5.83k|    delete [] C;
  195|  5.83k|  } 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.20M|  for(i = 0, m = 0; i < n; ++i) {
  ------------------
  |  Branch (224:21): [True: 6.19M, False: 5.83k]
  ------------------
  225|  6.19M|    p = SA[i];
  226|  6.19M|    if((0 < p) && (T[p - 1] > (c0 = T[p]))) {
  ------------------
  |  Branch (226:8): [True: 6.19M, False: 5.83k]
  |  Branch (226:19): [True: 2.03M, False: 4.16M]
  ------------------
  227|  2.88M|      for(j = p + 1; (j < n) && (c0 == (c1 = T[j])); ++j) { }
  ------------------
  |  Branch (227:22): [True: 2.87M, False: 5.83k]
  |  Branch (227:33): [True: 849k, False: 2.02M]
  ------------------
  228|  2.03M|      if((j < n) && (c0 < c1)) { SA[m++] = p; }
  ------------------
  |  Branch (228:10): [True: 2.02M, False: 5.83k]
  |  Branch (228:21): [True: 1.51M, False: 509k]
  ------------------
  229|  2.03M|    }
  230|  6.19M|  }
  231|  5.83k|#endif
  232|  5.83k|  j = m + (n >> 1);
  233|       |#ifdef _OPENMP
  234|       |#pragma omp parallel for default(shared) private(i)
  235|       |#endif
  236|  3.10M|  for(i = m; i < j; ++i) { SA[i] = 0; } /* init the name array buffer */
  ------------------
  |  Branch (236:14): [True: 3.09M, False: 5.83k]
  ------------------
  237|       |  /* store the length of all substrings */
  238|  6.19M|  for(i = n - 2, j = n, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (238:47): [True: 6.19M, False: 5.83k]
  ------------------
  239|  6.19M|    if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (239:8): [True: 2.74M, False: 3.44M]
  ------------------
  240|  3.44M|    else if(c != 0) { SA[m + ((i + 1) >> 1)] = j - i - 1; j = i + 1; c = 0; }
  ------------------
  |  Branch (240:13): [True: 1.51M, False: 1.93M]
  ------------------
  241|  6.19M|  }
  242|       |  /* find the lexicographic names of all substrings */
  243|  1.52M|  for(i = 0, name = 0, q = n, qlen = 0; i < m; ++i) {
  ------------------
  |  Branch (243:41): [True: 1.51M, False: 5.83k]
  ------------------
  244|  1.51M|    p = SA[i], plen = SA[m + (p >> 1)], diff = true;
  245|  1.51M|    if(plen == qlen) {
  ------------------
  |  Branch (245:8): [True: 900k, False: 615k]
  ------------------
  246|  3.74M|      for(j = 0; (j < plen) && (T[p + j] == T[q + j]); ++j) { }
  ------------------
  |  Branch (246:18): [True: 2.95M, False: 783k]
  |  Branch (246:32): [True: 2.84M, False: 117k]
  ------------------
  247|   900k|      if(j == plen) { diff = false; }
  ------------------
  |  Branch (247:10): [True: 783k, False: 117k]
  ------------------
  248|   900k|    }
  249|  1.51M|    if(diff != false) { ++name, q = p, qlen = plen; }
  ------------------
  |  Branch (249:8): [True: 733k, False: 783k]
  ------------------
  250|  1.51M|    SA[m + (p >> 1)] = name;
  251|  1.51M|  }
  252|       |
  253|       |  /* stage 2: solve the reduced problem
  254|       |     recurse if names are not yet unique */
  255|  5.83k|  if(name < m) {
  ------------------
  |  Branch (255:6): [True: 3.77k, False: 2.06k]
  ------------------
  256|  3.77k|    RA = SA + n + fs - m;
  257|  3.04M|    for(i = m + (n >> 1) - 1, j = m - 1; m <= i; --i) {
  ------------------
  |  Branch (257:42): [True: 3.03M, False: 3.77k]
  ------------------
  258|  3.03M|      if(SA[i] != 0) { RA[j--] = SA[i] - 1; }
  ------------------
  |  Branch (258:10): [True: 1.49M, False: 1.53M]
  ------------------
  259|  3.03M|    }
  260|  3.77k|    if(suffixsort(RA, SA, fs + n - m * 2, m, name, false) != 0) { return -2; }
  ------------------
  |  Branch (260:8): [True: 0, False: 3.77k]
  ------------------
  261|  6.07M|    for(i = n - 2, j = m - 1, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (261:53): [True: 6.07M, False: 3.77k]
  ------------------
  262|  6.07M|      if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (262:10): [True: 2.69M, False: 3.37M]
  ------------------
  263|  3.37M|      else if(c != 0) { RA[j--] = i + 1, c = 0; } /* get p1 */
  ------------------
  |  Branch (263:15): [True: 1.49M, False: 1.87M]
  ------------------
  264|  6.07M|    }
  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.49M, False: 3.77k]
  ------------------
  269|  3.77k|  }
  270|       |
  271|       |  /* stage 3: induce the result for the original problem */
  272|  5.83k|  if(fs < (maxthreads * k)) {
  ------------------
  |  |  174|  5.83k|# define maxthreads 1
  ------------------
  |  Branch (272:6): [True: 5.83k, False: 0]
  ------------------
  273|  5.83k|    index_type *B, *C;
  274|  5.83k|    C = new index_type[maxthreads * k];
  ------------------
  |  |  174|  5.83k|# define maxthreads 1
  ------------------
  275|  5.83k|    B = (1 < maxthreads) ? C + k : C;
  ------------------
  |  |  174|  5.83k|# define maxthreads 1
  ------------------
  |  Branch (275:9): [Folded, False: 5.83k]
  ------------------
  276|       |    /* put all left-most S characters into their buckets */
  277|  5.83k|    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.68M|    for(i = m; i < n; ++i) { SA[i] = 0; } /* init SA[m..n-1] */
  ------------------
  |  Branch (281:16): [True: 4.68M, False: 5.83k]
  ------------------
  282|  1.52M|    for(i = m - 1; 0 <= i; --i) {
  ------------------
  |  Branch (282:20): [True: 1.51M, False: 5.83k]
  ------------------
  283|  1.51M|      j = SA[i], SA[i] = 0;
  284|  1.51M|      SA[--B[T[j]]] = j;
  285|  1.51M|    }
  286|  5.83k|    if(isbwt == false) { induceSA(T, SA, C, B, n, k); }
  ------------------
  |  Branch (286:8): [True: 5.83k, False: 0]
  ------------------
  287|      0|    else { pidx = computeBWT(T, SA, C, B, n, k); }
  288|  5.83k|    delete [] C;
  289|  5.83k|  } 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|  5.83k|  return pidx;
  308|  5.83k|#ifndef _OPENMP
  309|  5.83k|# undef maxthreads
  310|  5.83k|#endif
  311|  5.83k|}
_ZN14saisxx_private9getCountsINSt3__111__wrap_iterIPDiEEPiiEEvT_T0_T1_S8_:
   47|  35.0k|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|  35.0k|  index_type i;
   72|  39.0G|  for(i = 0; i < k; ++i) { C[i] = 0; }
  ------------------
  |  Branch (72:14): [True: 39.0G, False: 35.0k]
  ------------------
   73|  37.2M|  for(i = 0; i < n; ++i) { ++C[T[i]]; }
  ------------------
  |  Branch (73:14): [True: 37.1M, False: 35.0k]
  ------------------
   74|  35.0k|#endif
   75|  35.0k|}
_ZN14saisxx_private10getBucketsIPiiEEvT_S2_T0_b:
   78|  35.9k|getBuckets(const bucket_type C, bucket_type B, index_type k, bool end) {
   79|  35.9k|  index_type i, sum = 0;
   80|  26.0G|  if(end) { for(i = 0; i < k; ++i) { sum += C[i]; B[i] = sum; } }
  ------------------
  |  Branch (80:6): [True: 23.9k, False: 11.9k]
  |  Branch (80:24): [True: 26.0G, False: 23.9k]
  ------------------
   81|  13.0G|  else { for(i = 0; i < k; ++i) { sum += C[i]; B[i] = sum - C[i]; } }
  ------------------
  |  Branch (81:21): [True: 13.0G, False: 11.9k]
  ------------------
   82|  35.9k|}
_ZN14saisxx_private8induceSAINSt3__111__wrap_iterIPDiEENS2_IPiEES5_iEEvT_T0_T1_S9_T2_SA_:
   89|  11.6k|         index_type n, index_type k) {
   90|  11.6k|typedef typename std::iterator_traits<string_type>::value_type char_type;
   91|  11.6k|  sarray_type b;
   92|  11.6k|  index_type i, j;
   93|  11.6k|  char_type c0, c1;
   94|       |  /* compute SAl */
   95|  11.6k|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (95:6): [True: 11.6k, False: 0]
  ------------------
   96|  11.6k|  getBuckets(C, B, k, false); /* find starts of buckets */
   97|  11.6k|  b = SA + B[c1 = T[j = n - 1]];
   98|  11.6k|  *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (98:11): [True: 11.6k, False: 0]
  |  Branch (98:22): [True: 0, False: 11.6k]
  ------------------
   99|  12.4M|  for(i = 0; i < n; ++i) {
  ------------------
  |  Branch (99:14): [True: 12.3M, False: 11.6k]
  ------------------
  100|  12.3M|    j = SA[i], SA[i] = ~j;
  101|  12.3M|    if(0 < j) {
  ------------------
  |  Branch (101:8): [True: 6.89M, False: 5.49M]
  ------------------
  102|  6.89M|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (102:10): [True: 2.42M, False: 4.47M]
  ------------------
  103|  6.89M|      *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (103:15): [True: 6.89M, False: 7.47k]
  |  Branch (103:26): [True: 3.03M, False: 3.85M]
  ------------------
  104|  6.89M|    }
  105|  12.3M|  }
  106|       |  /* compute SAs */
  107|  11.6k|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (107:6): [True: 11.6k, False: 0]
  ------------------
  108|  11.6k|  getBuckets(C, B, k, true); /* find ends of buckets */
  109|  12.4M|  for(i = n - 1, b = SA + B[c1 = 0]; 0 <= i; --i) {
  ------------------
  |  Branch (109:38): [True: 12.3M, False: 11.6k]
  ------------------
  110|  12.3M|    if(0 < (j = SA[i])) {
  ------------------
  |  Branch (110:8): [True: 5.48M, False: 6.91M]
  ------------------
  111|  5.48M|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (111:10): [True: 2.55M, False: 2.93M]
  ------------------
  112|  5.48M|      *--b = ((j == 0) || (T[j - 1] > c1)) ? ~j : j;
  ------------------
  |  Branch (112:15): [True: 4.20k, False: 5.48M]
  |  Branch (112:27): [True: 3.03M, False: 2.45M]
  ------------------
  113|  6.91M|    } else {
  114|  6.91M|      SA[i] = ~j;
  115|  6.91M|    }
  116|  12.3M|  }
  117|  11.6k|}
_ZN14saisxx_private10getBucketsINSt3__111__wrap_iterIPiEEiEEvT_S5_T0_b:
   78|  40.7k|getBuckets(const bucket_type C, bucket_type B, index_type k, bool end) {
   79|  40.7k|  index_type i, sum = 0;
   80|  4.48M|  if(end) { for(i = 0; i < k; ++i) { sum += C[i]; B[i] = sum; } }
  ------------------
  |  Branch (80:6): [True: 27.1k, False: 13.5k]
  |  Branch (80:24): [True: 4.45M, False: 27.1k]
  ------------------
   81|  2.24M|  else { for(i = 0; i < k; ++i) { sum += C[i]; B[i] = sum - C[i]; } }
  ------------------
  |  Branch (81:21): [True: 2.22M, False: 13.5k]
  ------------------
   82|  40.7k|}
_ZN14saisxx_private10suffixsortINSt3__111__wrap_iterIPiEES4_iEEiT_T0_T1_S7_S7_b:
  164|  6.94k|           bool isbwt) {
  165|  6.94k|typedef typename std::iterator_traits<string_type>::value_type char_type;
  166|  6.94k|  sarray_type RA;
  167|  6.94k|  index_type i, j, m, p, q, plen, qlen, name;
  168|  6.94k|  int pidx = 0;
  169|  6.94k|  bool diff;
  170|  6.94k|  int c;
  171|       |#ifdef _OPENMP
  172|       |  int maxthreads = omp_get_max_threads();
  173|       |#else
  174|  6.94k|# define maxthreads 1
  175|  6.94k|#endif
  176|  6.94k|  char_type c0, c1;
  177|       |
  178|       |  /* stage 1: reduce the problem by at least 1/2
  179|       |     sort all the S-substrings */
  180|  6.94k|  if(fs < (maxthreads * k)) {
  ------------------
  |  |  174|  6.94k|# define maxthreads 1
  ------------------
  |  Branch (180:6): [True: 155, False: 6.79k]
  ------------------
  181|    155|    index_type *C, *B;
  182|    155|    C = new index_type[maxthreads * k];
  ------------------
  |  |  174|    155|# define maxthreads 1
  ------------------
  183|    155|    B = (1 < maxthreads) ? C + k : C;
  ------------------
  |  |  174|    155|# define maxthreads 1
  ------------------
  |  Branch (183:9): [Folded, False: 155]
  ------------------
  184|    155|    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|  18.5k|    for(i = 0; i < n; ++i) { SA[i] = 0; }
  ------------------
  |  Branch (188:16): [True: 18.4k, False: 155]
  ------------------
  189|  18.4k|    for(i = n - 2, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (189:42): [True: 18.2k, False: 155]
  ------------------
  190|  18.2k|      if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (190:10): [True: 12.7k, False: 5.48k]
  ------------------
  191|  5.48k|      else if(c != 0) { SA[--B[c1]] = i + 1, c = 0; }
  ------------------
  |  Branch (191:15): [True: 3.32k, False: 2.15k]
  ------------------
  192|  18.2k|    }
  193|    155|    induceSA(T, SA, C, B, n, k);
  194|    155|    delete [] C;
  195|  6.79k|  } else {
  196|  6.79k|    sarray_type C, B;
  197|  6.79k|    C = SA + n;
  198|  6.79k|    B = ((1 < maxthreads) || (k <= (fs - k))) ? C + k : C;
  ------------------
  |  |  174|  6.79k|# define maxthreads 1
  ------------------
  |  Branch (198:10): [Folded, False: 6.79k]
  |  Branch (198:30): [True: 5.85k, False: 936]
  ------------------
  199|  6.79k|    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.98M|    for(i = 0; i < n; ++i) { SA[i] = 0; }
  ------------------
  |  Branch (203:16): [True: 1.97M, False: 6.79k]
  ------------------
  204|  1.97M|    for(i = n - 2, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (204:42): [True: 1.96M, False: 6.79k]
  ------------------
  205|  1.96M|      if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (205:10): [True: 1.00M, False: 965k]
  ------------------
  206|   965k|      else if(c != 0) { SA[--B[c1]] = i + 1, c = 0; }
  ------------------
  |  Branch (206:15): [True: 613k, False: 351k]
  ------------------
  207|  1.96M|    }
  208|  6.79k|    induceSA(T, SA, C, B, n, k);
  209|  6.79k|  }
  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: 6.94k]
  ------------------
  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: 6.94k]
  |  Branch (226:19): [True: 939k, False: 1.04M]
  ------------------
  227|  1.00M|      for(j = p + 1; (j < n) && (c0 == (c1 = T[j])); ++j) { }
  ------------------
  |  Branch (227:22): [True: 1.00M, False: 4.07k]
  |  Branch (227:33): [True: 68.5k, False: 935k]
  ------------------
  228|   939k|      if((j < n) && (c0 < c1)) { SA[m++] = p; }
  ------------------
  |  Branch (228:10): [True: 935k, False: 4.07k]
  |  Branch (228:21): [True: 616k, False: 319k]
  ------------------
  229|   939k|    }
  230|  1.99M|  }
  231|  6.94k|#endif
  232|  6.94k|  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: 995k, False: 6.94k]
  ------------------
  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: 6.94k]
  ------------------
  239|  1.98M|    if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (239:8): [True: 1.01M, False: 970k]
  ------------------
  240|   970k|    else if(c != 0) { SA[m + ((i + 1) >> 1)] = j - i - 1; j = i + 1; c = 0; }
  ------------------
  |  Branch (240:13): [True: 616k, False: 354k]
  ------------------
  241|  1.98M|  }
  242|       |  /* find the lexicographic names of all substrings */
  243|   623k|  for(i = 0, name = 0, q = n, qlen = 0; i < m; ++i) {
  ------------------
  |  Branch (243:41): [True: 616k, False: 6.94k]
  ------------------
  244|   616k|    p = SA[i], plen = SA[m + (p >> 1)], diff = true;
  245|   616k|    if(plen == qlen) {
  ------------------
  |  Branch (245:8): [True: 246k, False: 369k]
  ------------------
  246|   600k|      for(j = 0; (j < plen) && (T[p + j] == T[q + j]); ++j) { }
  ------------------
  |  Branch (246:18): [True: 505k, False: 94.6k]
  |  Branch (246:32): [True: 353k, False: 152k]
  ------------------
  247|   246k|      if(j == plen) { diff = false; }
  ------------------
  |  Branch (247:10): [True: 94.6k, False: 152k]
  ------------------
  248|   246k|    }
  249|   616k|    if(diff != false) { ++name, q = p, qlen = plen; }
  ------------------
  |  Branch (249:8): [True: 521k, False: 94.6k]
  ------------------
  250|   616k|    SA[m + (p >> 1)] = name;
  251|   616k|  }
  252|       |
  253|       |  /* stage 2: solve the reduced problem
  254|       |     recurse if names are not yet unique */
  255|  6.94k|  if(name < m) {
  ------------------
  |  Branch (255:6): [True: 3.17k, False: 3.77k]
  ------------------
  256|  3.17k|    RA = SA + n + fs - m;
  257|   802k|    for(i = m + (n >> 1) - 1, j = m - 1; m <= i; --i) {
  ------------------
  |  Branch (257:42): [True: 799k, False: 3.17k]
  ------------------
  258|   799k|      if(SA[i] != 0) { RA[j--] = SA[i] - 1; }
  ------------------
  |  Branch (258:10): [True: 494k, False: 304k]
  ------------------
  259|   799k|    }
  260|  3.17k|    if(suffixsort(RA, SA, fs + n - m * 2, m, name, false) != 0) { return -2; }
  ------------------
  |  Branch (260:8): [True: 0, False: 3.17k]
  ------------------
  261|  1.59M|    for(i = n - 2, j = m - 1, c = 0, c1 = T[n - 1]; 0 <= i; --i, c1 = c0) {
  ------------------
  |  Branch (261:53): [True: 1.59M, False: 3.17k]
  ------------------
  262|  1.59M|      if((c0 = T[i]) < (c1 + c)) { c = 1; }
  ------------------
  |  Branch (262:10): [True: 819k, False: 777k]
  ------------------
  263|   777k|      else if(c != 0) { RA[j--] = i + 1, c = 0; } /* get p1 */
  ------------------
  |  Branch (263:15): [True: 494k, False: 282k]
  ------------------
  264|  1.59M|    }
  265|       |#ifdef _OPENMP
  266|       |#pragma omp parallel for default(shared) private(i)
  267|       |#endif
  268|   497k|    for(i = 0; i < m; ++i) { SA[i] = RA[SA[i]]; } /* get index in s */
  ------------------
  |  Branch (268:16): [True: 494k, False: 3.17k]
  ------------------
  269|  3.17k|  }
  270|       |
  271|       |  /* stage 3: induce the result for the original problem */
  272|  6.94k|  if(fs < (maxthreads * k)) {
  ------------------
  |  |  174|  6.94k|# define maxthreads 1
  ------------------
  |  Branch (272:6): [True: 155, False: 6.79k]
  ------------------
  273|    155|    index_type *B, *C;
  274|    155|    C = new index_type[maxthreads * k];
  ------------------
  |  |  174|    155|# define maxthreads 1
  ------------------
  275|    155|    B = (1 < maxthreads) ? C + k : C;
  ------------------
  |  |  174|    155|# define maxthreads 1
  ------------------
  |  Branch (275:9): [Folded, False: 155]
  ------------------
  276|       |    /* put all left-most S characters into their buckets */
  277|    155|    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|  15.2k|    for(i = m; i < n; ++i) { SA[i] = 0; } /* init SA[m..n-1] */
  ------------------
  |  Branch (281:16): [True: 15.1k, False: 155]
  ------------------
  282|  3.47k|    for(i = m - 1; 0 <= i; --i) {
  ------------------
  |  Branch (282:20): [True: 3.32k, False: 155]
  ------------------
  283|  3.32k|      j = SA[i], SA[i] = 0;
  284|  3.32k|      SA[--B[T[j]]] = j;
  285|  3.32k|    }
  286|    155|    if(isbwt == false) { induceSA(T, SA, C, B, n, k); }
  ------------------
  |  Branch (286:8): [True: 155, False: 0]
  ------------------
  287|      0|    else { pidx = computeBWT(T, SA, C, B, n, k); }
  288|    155|    delete [] C;
  289|  6.79k|  } else {
  290|  6.79k|    sarray_type C, B;
  291|  6.79k|    C = SA + n;
  292|  6.79k|    B = ((1 < maxthreads) || (k <= (fs - k))) ? C + k : C;
  ------------------
  |  |  174|  6.79k|# define maxthreads 1
  ------------------
  |  Branch (292:10): [Folded, False: 6.79k]
  |  Branch (292:30): [True: 5.85k, False: 936]
  ------------------
  293|       |    /* put all left-most S characters into their buckets */
  294|  6.79k|    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.36M|    for(i = m; i < n; ++i) { SA[i] = 0; } /* init SA[m..n-1] */
  ------------------
  |  Branch (298:16): [True: 1.36M, False: 6.79k]
  ------------------
  299|   620k|    for(i = m - 1; 0 <= i; --i) {
  ------------------
  |  Branch (299:20): [True: 613k, False: 6.79k]
  ------------------
  300|   613k|      j = SA[i], SA[i] = 0;
  301|   613k|      SA[--B[T[j]]] = j;
  302|   613k|    }
  303|  6.79k|    if(isbwt == false) { induceSA(T, SA, C, B, n, k); }
  ------------------
  |  Branch (303:8): [True: 6.79k, False: 0]
  ------------------
  304|      0|    else { pidx = computeBWT(T, SA, C, B, n, k); }
  305|  6.79k|  }
  306|       |
  307|  6.94k|  return pidx;
  308|  6.94k|#ifndef _OPENMP
  309|  6.94k|# undef maxthreads
  310|  6.94k|#endif
  311|  6.94k|}
_ZN14saisxx_private9getCountsINSt3__111__wrap_iterIPiEES3_iEEvT_T0_T1_S7_:
   47|    930|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|    930|  index_type i;
   72|  12.3k|  for(i = 0; i < k; ++i) { C[i] = 0; }
  ------------------
  |  Branch (72:14): [True: 11.4k, False: 930]
  ------------------
   73|   111k|  for(i = 0; i < n; ++i) { ++C[T[i]]; }
  ------------------
  |  Branch (73:14): [True: 110k, False: 930]
  ------------------
   74|    930|#endif
   75|    930|}
_ZN14saisxx_private8induceSAINSt3__111__wrap_iterIPiEES4_S3_iEEvT_T0_T1_S7_T2_S8_:
   89|    310|         index_type n, index_type k) {
   90|    310|typedef typename std::iterator_traits<string_type>::value_type char_type;
   91|    310|  sarray_type b;
   92|    310|  index_type i, j;
   93|    310|  char_type c0, c1;
   94|       |  /* compute SAl */
   95|    310|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (95:6): [True: 310, False: 0]
  ------------------
   96|    310|  getBuckets(C, B, k, false); /* find starts of buckets */
   97|    310|  b = SA + B[c1 = T[j = n - 1]];
   98|    310|  *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (98:11): [True: 310, False: 0]
  |  Branch (98:22): [True: 124, False: 186]
  ------------------
   99|  37.1k|  for(i = 0; i < n; ++i) {
  ------------------
  |  Branch (99:14): [True: 36.8k, False: 310]
  ------------------
  100|  36.8k|    j = SA[i], SA[i] = ~j;
  101|  36.8k|    if(0 < j) {
  ------------------
  |  Branch (101:8): [True: 10.9k, False: 25.9k]
  ------------------
  102|  10.9k|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (102:10): [True: 3.89k, False: 7.06k]
  ------------------
  103|  10.9k|      *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (103:15): [True: 10.7k, False: 216]
  |  Branch (103:26): [True: 6.61k, False: 4.12k]
  ------------------
  104|  10.9k|    }
  105|  36.8k|  }
  106|       |  /* compute SAs */
  107|    310|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (107:6): [True: 310, False: 0]
  ------------------
  108|    310|  getBuckets(C, B, k, true); /* find ends of buckets */
  109|  37.1k|  for(i = n - 1, b = SA + B[c1 = 0]; 0 <= i; --i) {
  ------------------
  |  Branch (109:38): [True: 36.8k, False: 310]
  ------------------
  110|  36.8k|    if(0 < (j = SA[i])) {
  ------------------
  |  Branch (110:8): [True: 25.5k, False: 11.2k]
  ------------------
  111|  25.5k|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (111:10): [True: 2.41k, False: 23.1k]
  ------------------
  112|  25.5k|      *--b = ((j == 0) || (T[j - 1] > c1)) ? ~j : j;
  ------------------
  |  Branch (112:15): [True: 94, False: 25.4k]
  |  Branch (112:27): [True: 6.64k, False: 18.8k]
  ------------------
  113|  25.5k|    } else {
  114|  11.2k|      SA[i] = ~j;
  115|  11.2k|    }
  116|  36.8k|  }
  117|    310|}
_ZN14saisxx_private9getCountsINSt3__111__wrap_iterIPiEES4_iEEvT_T0_T1_S7_:
   47|  17.3k|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|  17.3k|  index_type i;
   72|  2.66M|  for(i = 0; i < k; ++i) { C[i] = 0; }
  ------------------
  |  Branch (72:14): [True: 2.64M, False: 17.3k]
  ------------------
   73|  4.60M|  for(i = 0; i < n; ++i) { ++C[T[i]]; }
  ------------------
  |  Branch (73:14): [True: 4.58M, False: 17.3k]
  ------------------
   74|  17.3k|#endif
   75|  17.3k|}
_ZN14saisxx_private8induceSAINSt3__111__wrap_iterIPiEES4_S4_iEEvT_T0_T1_S7_T2_S8_:
   89|  13.5k|         index_type n, index_type k) {
   90|  13.5k|typedef typename std::iterator_traits<string_type>::value_type char_type;
   91|  13.5k|  sarray_type b;
   92|  13.5k|  index_type i, j;
   93|  13.5k|  char_type c0, c1;
   94|       |  /* compute SAl */
   95|  13.5k|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (95:6): [True: 1.87k, False: 11.7k]
  ------------------
   96|  13.5k|  getBuckets(C, B, k, false); /* find starts of buckets */
   97|  13.5k|  b = SA + B[c1 = T[j = n - 1]];
   98|  13.5k|  *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (98:11): [True: 13.5k, False: 0]
  |  Branch (98:22): [True: 5.63k, False: 7.95k]
  ------------------
   99|  3.96M|  for(i = 0; i < n; ++i) {
  ------------------
  |  Branch (99:14): [True: 3.94M, False: 13.5k]
  ------------------
  100|  3.94M|    j = SA[i], SA[i] = ~j;
  101|  3.94M|    if(0 < j) {
  ------------------
  |  Branch (101:8): [True: 1.93M, False: 2.01M]
  ------------------
  102|  1.93M|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (102:10): [True: 1.48M, False: 444k]
  ------------------
  103|  1.93M|      *b++ = ((0 < j) && (T[j - 1] < c1)) ? ~j : j;
  ------------------
  |  Branch (103:15): [True: 1.92M, False: 6.62k]
  |  Branch (103:26): [True: 1.22M, False: 695k]
  ------------------
  104|  1.93M|    }
  105|  3.94M|  }
  106|       |  /* compute SAs */
  107|  13.5k|  if(C == B) { getCounts(T, C, n, k); }
  ------------------
  |  Branch (107:6): [True: 1.87k, False: 11.7k]
  ------------------
  108|  13.5k|  getBuckets(C, B, k, true); /* find ends of buckets */
  109|  3.96M|  for(i = n - 1, b = SA + B[c1 = 0]; 0 <= i; --i) {
  ------------------
  |  Branch (109:38): [True: 3.94M, False: 13.5k]
  ------------------
  110|  3.94M|    if(0 < (j = SA[i])) {
  ------------------
  |  Branch (110:8): [True: 2.00M, False: 1.94M]
  ------------------
  111|  2.00M|      if((c0 = T[--j]) != c1) { B[c1] = b - SA; b = SA + B[c1 = c0]; }
  ------------------
  |  Branch (111:10): [True: 1.49M, False: 512k]
  ------------------
  112|  2.00M|      *--b = ((j == 0) || (T[j - 1] > c1)) ? ~j : j;
  ------------------
  |  Branch (112:15): [True: 6.96k, False: 1.99M]
  |  Branch (112:27): [True: 1.22M, False: 772k]
  ------------------
  113|  2.00M|    } else {
  114|  1.94M|      SA[i] = ~j;
  115|  1.94M|    }
  116|  3.94M|  }
  117|  13.5k|}

_ZNK6google8protobuf8internal10LazyString4InitEv:
   50|      5|const std::string& LazyString::Init() const {
   51|      5|  static WrappedMutex mu{GOOGLE_PROTOBUF_LINKER_INITIALIZED};
   52|      5|  mu.Lock();
   53|      5|  const std::string* res = inited_.load(std::memory_order_acquire);
   54|      5|  if (res == nullptr) {
  ------------------
  |  Branch (54:7): [True: 5, False: 0]
  ------------------
   55|      5|    auto init_value = init_value_;
   56|      5|    res = ::new (static_cast<void*>(string_buf_))
   57|      5|        std::string(init_value.ptr, init_value.size);
   58|      5|    inited_.store(res, std::memory_order_release);
   59|      5|  }
   60|      5|  mu.Unlock();
   61|      5|  return *res;
   62|      5|}
_ZN6google8protobuf8internal14ArenaStringPtr3SetEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERSA_PNS0_5ArenaE:
   66|   402k|                         ConstStringParam value, ::google::protobuf::Arena* arena) {
   67|   402k|  if (IsDefault(default_value)) {
  ------------------
  |  Branch (67:7): [True: 402k, False: 0]
  ------------------
   68|   402k|    tagged_ptr_.Set(Arena::Create<std::string>(arena, value));
   69|   402k|  } else {
   70|      0|    UnsafeMutablePointer()->assign(value.data(), value.length());
   71|      0|  }
   72|   402k|}
_ZN6google8protobuf8internal14ArenaStringPtr3SetEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEOS9_PNS0_5ArenaE:
   75|  7.42M|                         ::google::protobuf::Arena* arena) {
   76|  7.42M|  if (IsDefault(default_value)) {
  ------------------
  |  Branch (76:7): [True: 1.96M, False: 5.45M]
  ------------------
   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.45M|  } else if (IsDonatedString()) {
  ------------------
  |  Branch (82:14): [True: 0, False: 5.45M]
  ------------------
   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.45M|  } else /* !IsDonatedString() */ {
   88|  5.45M|    *UnsafeMutablePointer() = std::move(value);
   89|  5.45M|  }
   90|  7.42M|}
_ZN6google8protobuf8internal14ArenaStringPtr3SetENS2_12EmptyDefaultERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaE:
   93|   402k|                         ::google::protobuf::Arena* arena) {
   94|   402k|  Set(&GetEmptyStringAlreadyInited(), value, arena);
   95|   402k|}
_ZN6google8protobuf8internal14ArenaStringPtr3SetENS2_12EmptyDefaultEONSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaE:
   98|  7.42M|                         ::google::protobuf::Arena* arena) {
   99|  7.42M|  Set(&GetEmptyStringAlreadyInited(), std::move(value), arena);
  100|  7.42M|}
_ZN6google8protobuf8internal14ArenaStringPtr7MutableENS2_12EmptyDefaultEPNS0_5ArenaE:
  112|  8.54k|std::string* ArenaStringPtr::Mutable(EmptyDefault, ::google::protobuf::Arena* arena) {
  113|  8.54k|  if (!IsDonatedString() && !IsDefault(&GetEmptyStringAlreadyInited())) {
  ------------------
  |  Branch (113:7): [True: 8.54k, False: 0]
  |  Branch (113:29): [True: 0, False: 8.54k]
  ------------------
  114|      0|    return UnsafeMutablePointer();
  115|  8.54k|  } else {
  116|  8.54k|    return MutableSlow(arena);
  117|  8.54k|  }
  118|  8.54k|}
_ZN6google8protobuf8internal14ArenaStringPtr11MutableSlowIJEEEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaEDpRKT_:
  144|  8.54k|                                         const Lazy&... lazy_default) {
  145|  8.54k|  const std::string* const default_value =
  146|  8.54k|      sizeof...(Lazy) == 0 ? &GetEmptyStringAlreadyInited() : nullptr;
  ------------------
  |  Branch (146:7): [True: 8.54k, Folded]
  ------------------
  147|  8.54k|  GOOGLE_DCHECK(IsDefault(default_value));
  ------------------
  |  |  181|  8.54k|#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.54k]
  |  |  ------------------
  ------------------
  148|  8.54k|  std::string* new_string =
  149|  8.54k|      Arena::Create<std::string>(arena, lazy_default.get()...);
  150|  8.54k|  tagged_ptr_.Set(new_string);
  151|  8.54k|  return new_string;
  152|  8.54k|}

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

_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.39M|    : arena_(arena),
  189|  2.39M|      flat_capacity_(0),
  190|  2.39M|      flat_size_(0),
  191|  2.39M|      map_{flat_capacity_ == 0
  ------------------
  |  Branch (191:12): [True: 2.39M, False: 0]
  ------------------
  192|  2.39M|               ? NULL
  193|  2.39M|               : Arena::CreateArray<KeyValue>(arena_, flat_capacity_)} {}
_ZN6google8protobuf8internal12ExtensionSetD2Ev:
  195|  2.45M|ExtensionSet::~ExtensionSet() {
  196|       |  // Deletes all allocated extensions.
  197|  2.45M|  if (arena_ == NULL) {
  ------------------
  |  Branch (197:7): [True: 2.45M, False: 0]
  ------------------
  198|  2.45M|    ForEach([](int /* number */, Extension& ext) { ext.Free(); });
  199|  2.45M|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  2.45M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 2.45M]
  |  |  ------------------
  ------------------
  200|      0|      delete map_.large;
  201|  2.45M|    } else {
  202|  2.45M|      DeleteFlatMap(map_.flat, flat_capacity_);
  203|  2.45M|    }
  204|  2.45M|  }
  205|  2.45M|}
_ZN6google8protobuf8internal12ExtensionSet13DeleteFlatMapEPKNS2_8KeyValueEt:
  208|  2.45M|                                 uint16 flat_capacity) {
  209|  2.45M|#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.45M|  static_assert(std::is_trivially_destructible<KeyValue>::value,
  213|  2.45M|                "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.45M|  ::operator delete[](const_cast<ExtensionSet::KeyValue*>(flat),
  217|  2.45M|                      sizeof(*flat) * flat_capacity);
  218|       |#else   // !__cpp_sized_deallocation
  219|       |  delete[] flat;
  220|       |#endif  // !__cpp_sized_deallocation
  221|  2.45M|}
_ZN6google8protobuf8internal12ExtensionSet5ClearEv:
  877|  7.24M|void ExtensionSet::Clear() {
  878|  7.24M|  ForEach([](int /* number */, Extension& ext) { ext.Clear(); });
  879|  7.24M|}
_ZN6google8protobuf8internal12ExtensionSet9MergeFromERKS2_:
  903|  71.3k|void ExtensionSet::MergeFrom(const ExtensionSet& other) {
  904|  71.3k|  if (PROTOBUF_PREDICT_TRUE(!is_large())) {
  ------------------
  |  |  236|  71.3k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 71.3k, False: 0]
  |  |  ------------------
  ------------------
  905|  71.3k|    if (PROTOBUF_PREDICT_TRUE(!other.is_large())) {
  ------------------
  |  |  236|  71.3k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 71.3k, False: 0]
  |  |  ------------------
  ------------------
  906|  71.3k|      GrowCapacity(SizeOfUnion(flat_begin(), flat_end(), other.flat_begin(),
  907|  71.3k|                               other.flat_end()));
  908|  71.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|  71.3k|  }
  914|  71.3k|  other.ForEach([this](int number, const Extension& ext) {
  915|  71.3k|    this->InternalExtensionMergeFrom(number, ext);
  916|  71.3k|  });
  917|  71.3k|}
_ZN6google8protobuf8internal12ExtensionSet4SwapEPS2_:
 1057|  25.6k|void ExtensionSet::Swap(ExtensionSet* x) {
 1058|  25.6k|  if (GetArena() == x->GetArena()) {
  ------------------
  |  Branch (1058:7): [True: 25.6k, False: 0]
  ------------------
 1059|  25.6k|    using std::swap;
 1060|  25.6k|    swap(flat_capacity_, x->flat_capacity_);
 1061|  25.6k|    swap(flat_size_, x->flat_size_);
 1062|  25.6k|    swap(map_, x->map_);
 1063|  25.6k|  } else {
 1064|       |    // TODO(cfallin, rohananil): We maybe able to optimize a case where we are
 1065|       |    // swapping from heap to arena-allocated extension set, by just Own()'ing
 1066|       |    // the extensions.
 1067|      0|    ExtensionSet extension_set;
 1068|      0|    extension_set.MergeFrom(*x);
 1069|      0|    x->Clear();
 1070|      0|    x->MergeFrom(*this);
 1071|      0|    Clear();
 1072|      0|    MergeFrom(extension_set);
 1073|      0|  }
 1074|  25.6k|}
_ZNK6google8protobuf8internal12ExtensionSet18_InternalSerializeEiiPhPNS0_2io19EpsCopyOutputStreamE:
 1460|   269k|                                        io::EpsCopyOutputStream* stream) const {
 1461|   269k|  if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|   269k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 269k]
  |  |  ------------------
  ------------------
 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|   269k|  const KeyValue* end = flat_end();
 1471|   269k|  for (const KeyValue* it = std::lower_bound(
 1472|   269k|           flat_begin(), end, start_field_number, KeyValue::FirstComparator());
 1473|   269k|       it != end && it->first < end_field_number; ++it) {
  ------------------
  |  Branch (1473:8): [True: 0, False: 269k]
  |  Branch (1473:21): [True: 0, False: 0]
  ------------------
 1474|      0|    target = it->second.InternalSerializeFieldWithCachedSizesToArray(
 1475|      0|        it->first, target, stream);
 1476|      0|  }
 1477|   269k|  return target;
 1478|   269k|}
_ZNK6google8protobuf8internal12ExtensionSet8ByteSizeEv:
 1489|   269k|size_t ExtensionSet::ByteSize() const {
 1490|   269k|  size_t total_size = 0;
 1491|   269k|  ForEach([&total_size](int number, const Extension& ext) {
 1492|   269k|    total_size += ext.ByteSize(number);
 1493|   269k|  });
 1494|   269k|  return total_size;
 1495|   269k|}
_ZN6google8protobuf8internal12ExtensionSet12GrowCapacityEm:
 1857|  71.3k|void ExtensionSet::GrowCapacity(size_t minimum_new_capacity) {
 1858|  71.3k|  if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|  71.3k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 71.3k]
  |  |  ------------------
  ------------------
 1859|      0|    return;  // LargeMap does not have a "reserve" method.
 1860|      0|  }
 1861|  71.3k|  if (flat_capacity_ >= minimum_new_capacity) {
  ------------------
  |  Branch (1861:7): [True: 71.3k, False: 0]
  ------------------
 1862|  71.3k|    return;
 1863|  71.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|  71.3k|size_t SizeOfUnion(ItX it_xs, ItX end_xs, ItY it_ys, ItY end_ys) {
  885|  71.3k|  size_t result = 0;
  886|  71.3k|  while (it_xs != end_xs && it_ys != end_ys) {
  ------------------
  |  Branch (886:10): [True: 0, False: 71.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|  71.3k|  result += std::distance(it_xs, end_xs);
  898|  71.3k|  result += std::distance(it_ys, end_ys);
  899|  71.3k|  return result;
  900|  71.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|  8.54k|  PROTOBUF_ALWAYS_INLINE static T* Create(Arena* arena, Args&&... args) {
  293|  8.54k|    return CreateNoMessage<T>(arena, is_arena_constructable<T>(),
  294|  8.54k|                              std::forward<Args>(args)...);
  295|  8.54k|  }
_ZN6google8protobuf5Arena15CreateNoMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  547|  8.54k|                                                   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|  8.54k|    return CreateMaybeMessage<T>(arena, std::forward<Args>(args)...);
  552|  8.54k|  }
_ZN6google8protobuf5Arena18CreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_:
  530|  8.54k|                                                      Args&&... args) {
  531|  8.54k|    return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(),
  532|  8.54k|                                   std::forward<Args>(args)...);
  533|  8.54k|  }
_ZN6google8protobuf5Arena20DoCreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  524|  8.54k|                                                        Args&&... args) {
  525|  8.54k|    return CreateInternal<T>(arena, std::forward<Args>(args)...);
  526|  8.54k|  }
_ZN6google8protobuf5Arena14CreateInternalINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_:
  472|  8.54k|                                                  Args&&... args) {
  473|  8.54k|    if (arena == NULL) {
  ------------------
  |  Branch (473:9): [True: 8.54k, False: 0]
  ------------------
  474|  8.54k|      return new T(std::forward<Args>(args)...);
  475|  8.54k|    } else {
  476|      0|      return arena->DoCreate<T>(std::is_trivially_destructible<T>::value,
  477|      0|                                std::forward<Args>(args)...);
  478|      0|    }
  479|  8.54k|  }
_ZN6google8protobuf5Arena6CreateINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_DpOT0_:
  292|   402k|  PROTOBUF_ALWAYS_INLINE static T* Create(Arena* arena, Args&&... args) {
  293|   402k|    return CreateNoMessage<T>(arena, is_arena_constructable<T>(),
  294|   402k|                              std::forward<Args>(args)...);
  295|   402k|  }
_ZN6google8protobuf5Arena15CreateNoMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  547|   402k|                                                   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|   402k|    return CreateMaybeMessage<T>(arena, std::forward<Args>(args)...);
  552|   402k|  }
_ZN6google8protobuf5Arena18CreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_DpOT0_:
  530|   402k|                                                      Args&&... args) {
  531|   402k|    return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(),
  532|   402k|                                   std::forward<Args>(args)...);
  533|   402k|  }
_ZN6google8protobuf5Arena20DoCreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  524|   402k|                                                        Args&&... args) {
  525|   402k|    return CreateInternal<T>(arena, std::forward<Args>(args)...);
  526|   402k|  }
_ZN6google8protobuf5Arena14CreateInternalINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEPT_PS1_DpOT0_:
  472|   402k|                                                  Args&&... args) {
  473|   402k|    if (arena == NULL) {
  ------------------
  |  Branch (473:9): [True: 402k, False: 0]
  ------------------
  474|   402k|      return new T(std::forward<Args>(args)...);
  475|   402k|    } else {
  476|      0|      return arena->DoCreate<T>(std::is_trivially_destructible<T>::value,
  477|      0|                                std::forward<Args>(args)...);
  478|      0|    }
  479|   402k|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece11TrainerSpecEEEPT_PS1_:
  459|  8.41k|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  8.41k|    static_assert(
  461|  8.41k|        InternalHelper<T>::is_arena_constructable::value,
  462|  8.41k|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  8.41k|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 8.41k, False: 0]
  ------------------
  464|  8.41k|      return new T();
  465|  8.41k|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  8.41k|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece14NormalizerSpecEEEPT_PS1_:
  459|  8.41k|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  8.41k|    static_assert(
  461|  8.41k|        InternalHelper<T>::is_arena_constructable::value,
  462|  8.41k|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  8.41k|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 8.41k, False: 0]
  ------------------
  464|  8.41k|      return new T();
  465|  8.41k|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  8.41k|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece24ModelProto_SentencePieceEEEPT_PS1_:
  459|  2.30M|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|  2.30M|    static_assert(
  461|  2.30M|        InternalHelper<T>::is_arena_constructable::value,
  462|  2.30M|        "CreateMessage can only construct types that are ArenaConstructable");
  463|  2.30M|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 2.30M, False: 0]
  ------------------
  464|  2.30M|      return new T();
  465|  2.30M|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|  2.30M|  }

_ZNK6google8protobuf8internal14ArenaStringPtr3GetEv:
  194|  1.88M|  const std::string& Get() const PROTOBUF_ALWAYS_INLINE {
  195|       |    // Unconditionally mask away the tag.
  196|  1.88M|    return *tagged_ptr_.Get();
  197|  1.88M|  }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEv:
   99|  9.05M|  T* Get() const { return reinterpret_cast<T*>(as_int() & -2); }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE6as_intEv:
  109|  9.05M|  uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
_ZNK6google8protobuf8internal14ArenaStringPtr9IsDefaultEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  279|  11.0M|  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.0M|    return tagged_ptr_.UnsafeGet() == default_value;
  285|  11.0M|  }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE9UnsafeGetEv:
  104|  18.8M|  T* UnsafeGet() const { return static_cast<T*>(ptr_); }
_ZNK6google8protobuf8internal10LazyString3getEv:
   74|   248k|  const std::string& get() const {
   75|       |    // This check generates less code than a call-once invocation.
   76|   248k|    auto* res = inited_.load(std::memory_order_acquire);
   77|   248k|    if (PROTOBUF_PREDICT_FALSE(res == nullptr)) return Init();
  ------------------
  |  |  247|   248k|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 5, False: 248k]
  |  |  ------------------
  ------------------
   78|   248k|    return *res;
   79|   248k|  }
_ZNK6google8protobuf8internal14ArenaStringPtr15IsDonatedStringEv:
  290|  5.46M|  bool IsDonatedString() const { return false; }
_ZN6google8protobuf8internal14ArenaStringPtr16UnsafeSetDefaultEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  301|  2.97M|inline void ArenaStringPtr::UnsafeSetDefault(const std::string* value) {
  302|  2.97M|  tagged_ptr_.Set(const_cast<std::string*>(value));
  303|  2.97M|}
_ZN6google8protobuf8internal14ArenaStringPtr4SwapEPS2_PKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaE:
  307|   136k|                                 Arena* arena) {
  308|       |#ifndef NDEBUG
  309|       |  // For debug builds, we swap the contents of the string, rather than the
  310|       |  // std::string instances themselves.  This invalidates previously taken const
  311|       |  // references that are (per our documentation) invalidated by calling Swap()
  312|       |  // on the message.
  313|       |  //
  314|       |  // If both strings are the default_value, swapping is uninteresting.
  315|       |  // Otherwise, we use ArenaStringPtr::Mutable() to access the std::string, to
  316|       |  // ensure that we do not try to mutate default_value itself.
  317|       |  if (IsDefault(default_value) && other->IsDefault(default_value)) {
  318|       |    return;
  319|       |  }
  320|       |
  321|       |  if (default_value == nullptr) {
  322|       |    // If we have non-empty default, then `default_value` is null and we can't
  323|       |    // call Mutable the same way. Just do the regular swap.
  324|       |    std::swap(tagged_ptr_, other->tagged_ptr_);
  325|       |  } else {
  326|       |    std::string* this_ptr = Mutable(EmptyDefault{}, arena);
  327|       |    std::string* other_ptr = other->Mutable(EmptyDefault{}, arena);
  328|       |
  329|       |    this_ptr->swap(*other_ptr);
  330|       |  }
  331|       |#else
  332|   136k|  std::swap(tagged_ptr_, other->tagged_ptr_);
  333|   136k|#endif
  334|   136k|}
_ZN6google8protobuf8internal14ArenaStringPtr22ClearNonDefaultToEmptyEv:
  336|  7.17M|inline void ArenaStringPtr::ClearNonDefaultToEmpty() {
  337|       |  // Unconditionally mask away the tag.
  338|  7.17M|  tagged_ptr_.Get()->clear();
  339|  7.17M|}
_ZN6google8protobuf8internal14ArenaStringPtr14DestroyNoArenaEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  356|  2.97M|inline void ArenaStringPtr::DestroyNoArena(const std::string* default_value) {
  357|  2.97M|  if (!IsDefault(default_value)) {
  ------------------
  |  Branch (357:7): [True: 2.37M, False: 601k]
  ------------------
  358|  2.37M|    delete UnsafeMutablePointer();
  359|  2.37M|  }
  360|  2.97M|}
_ZN6google8protobuf8internal14ArenaStringPtr20UnsafeMutablePointerEv:
  362|  7.83M|inline std::string* ArenaStringPtr::UnsafeMutablePointer() {
  363|  7.83M|  GOOGLE_DCHECK(!tagged_ptr_.IsTagged());
  ------------------
  |  |  181|  7.83M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 7.83M]
  |  |  ------------------
  ------------------
  364|  7.83M|  GOOGLE_DCHECK(tagged_ptr_.UnsafeGet() != nullptr);
  ------------------
  |  |  181|  7.83M|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 7.83M]
  |  |  ------------------
  ------------------
  365|  7.83M|  return tagged_ptr_.UnsafeGet();
  366|  7.83M|}
_ZN6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3SetEPS9_:
   98|  5.35M|  void Set(T* p) { ptr_ = p; }

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

_ZNK6google8protobuf8internal10CachedSize3GetEv:
  188|   265k|  int Get() const { return size_.load(std::memory_order_relaxed); }
_ZN6google8protobuf8internal10CachedSize3SetEi:
  189|   269k|  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.39M|inline void InitSCC(SCCInfoBase* scc) {
  248|  2.39M|  auto status = scc->visit_status.load(std::memory_order_acquire);
  249|  2.39M|  if (PROTOBUF_PREDICT_FALSE(status != SCCInfoBase::kInitialized))
  ------------------
  |  |  247|  2.39M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 9, False: 2.39M]
  |  |  ------------------
  ------------------
  250|      9|    InitSCCImpl(scc);
  251|  2.39M|}
_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|   108k|  uint32& operator[](int index) PROTOBUF_ALWAYS_INLINE {
   57|   108k|    return has_bits_[index];
   58|   108k|  }
_ZN6google8protobuf8internal7HasBitsILm1EEixEi:
   56|  22.8M|  uint32& operator[](int index) PROTOBUF_ALWAYS_INLINE {
   57|  22.8M|    return has_bits_[index];
   58|  22.8M|  }
_ZNK6google8protobuf8internal7HasBitsILm2EEixEi:
   60|   200k|  const uint32& operator[](int index) const PROTOBUF_ALWAYS_INLINE {
   61|   200k|    return has_bits_[index];
   62|   200k|  }
_ZNK6google8protobuf8internal7HasBitsILm1EEixEi:
   60|   659k|  const uint32& operator[](int index) const PROTOBUF_ALWAYS_INLINE {
   61|   659k|    return has_bits_[index];
   62|   659k|  }
_ZN6google8protobuf8internal7HasBitsILm1EEC2Ev:
   50|  2.37M|  constexpr HasBits() PROTOBUF_ALWAYS_INLINE : has_bits_{} {}
_ZN6google8protobuf8internal7HasBitsILm1EE5ClearEv:
   52|  7.23M|  void Clear() PROTOBUF_ALWAYS_INLINE {
   53|  7.23M|    memset(has_bits_, 0, sizeof(has_bits_));
   54|  7.23M|  }
_ZN6google8protobuf8internal7HasBitsILm2EEC2Ev:
   50|  25.5k|  constexpr HasBits() PROTOBUF_ALWAYS_INLINE : has_bits_{} {}
_ZN6google8protobuf8internal7HasBitsILm2EE5ClearEv:
   52|  8.41k|  void Clear() PROTOBUF_ALWAYS_INLINE {
   53|  8.41k|    memset(has_bits_, 0, sizeof(has_bits_));
   54|  8.41k|  }

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

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

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

_ZNK6google8protobuf8internal16InternalMetadata5arenaEv:
   72|  8.03M|  PROTOBUF_ALWAYS_INLINE Arena* arena() const {
   73|  8.03M|    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
  ------------------
  |  |  247|  8.03M|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 8.03M]
  |  |  ------------------
  ------------------
   74|      0|      return PtrValue<ContainerBase>()->arena;
   75|  8.03M|    } else {
   76|  8.03M|      return PtrValue<Arena>();
   77|  8.03M|    }
   78|  8.03M|  }
_ZNK6google8protobuf8internal16InternalMetadata19have_unknown_fieldsEv:
   80|  18.3M|  PROTOBUF_ALWAYS_INLINE bool have_unknown_fields() const {
   81|  18.3M|    return PtrTag() == kTagContainer;
   82|  18.3M|  }
_ZNK6google8protobuf8internal16InternalMetadata6PtrTagEv:
  146|  18.3M|  PROTOBUF_ALWAYS_INLINE int PtrTag() const {
  147|  18.3M|    return reinterpret_cast<intptr_t>(ptr_) & kPtrTagMask;
  148|  18.3M|  }
_ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS0_5ArenaEEEPT_v:
  151|  8.03M|  U* PtrValue() const {
  152|  8.03M|    return reinterpret_cast<U*>(reinterpret_cast<intptr_t>(ptr_) &
  153|  8.03M|                                kPtrValueMask);
  154|  8.03M|  }
_ZN6google8protobuf8internal16InternalMetadataC2Ev:
   61|  54.5k|  constexpr InternalMetadata() : ptr_(nullptr) {}
_ZN6google8protobuf8internal16InternalMetadataC2EPNS0_5ArenaE:
   62|  2.39M|  explicit InternalMetadata(Arena* arena) : ptr_(arena) {}
_ZN6google8protobuf8internal16InternalMetadata9MergeFromINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvRKS2_:
  119|  71.3k|  PROTOBUF_ALWAYS_INLINE void MergeFrom(const InternalMetadata& other) {
  120|  71.3k|    if (other.have_unknown_fields()) {
  ------------------
  |  Branch (120:9): [True: 0, False: 71.3k]
  ------------------
  121|      0|      DoMergeFrom<T>(other.unknown_fields<T>(nullptr));
  122|      0|    }
  123|  71.3k|  }
_ZN6google8protobuf8internal16InternalMetadata6DeleteINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvv:
   65|  2.45M|  void Delete() {
   66|       |    // Note that Delete<> should be called not more than once.
   67|  2.45M|    if (have_unknown_fields() && arena() == NULL) {
  ------------------
  |  Branch (67:9): [True: 0, False: 2.45M]
  |  Branch (67:34): [True: 0, False: 0]
  ------------------
   68|      0|      delete PtrValue<Container<T>>();
   69|      0|    }
   70|  2.45M|  }
_ZN6google8protobuf8internal16InternalMetadata5ClearINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvv:
  126|  7.24M|  PROTOBUF_ALWAYS_INLINE void Clear() {
  127|  7.24M|    if (have_unknown_fields()) {
  ------------------
  |  Branch (127:9): [True: 0, False: 7.24M]
  ------------------
  128|      0|      DoClear<T>();
  129|      0|    }
  130|  7.24M|  }
_ZN6google8protobuf8internal16InternalMetadata4SwapINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvPS2_:
  106|  25.6k|  PROTOBUF_ALWAYS_INLINE void Swap(InternalMetadata* other) {
  107|       |    // Semantics here are that we swap only the unknown fields, not the arena
  108|       |    // pointer. We cannot simply swap ptr_ with other->ptr_ because we need to
  109|       |    // maintain our own arena ptr. Also, our ptr_ and other's ptr_ may be in
  110|       |    // different states (direct arena pointer vs. container with UFS) so we
  111|       |    // cannot simply swap ptr_ and then restore the arena pointers. We reuse
  112|       |    // UFS's swap implementation instead.
  113|  25.6k|    if (have_unknown_fields() || other->have_unknown_fields()) {
  ------------------
  |  Branch (113:9): [True: 0, False: 25.6k]
  |  Branch (113:34): [True: 0, False: 25.6k]
  ------------------
  114|      0|      DoSwap<T>(other->mutable_unknown_fields<T>());
  115|      0|    }
  116|  25.6k|  }

_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5beginEv:
 2613|  51.2k|RepeatedPtrField<Element>::begin() const {
 2614|  51.2k|  return iterator(raw_data());
 2615|  51.2k|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8raw_dataEv:
 1857|   111k|inline void* const* RepeatedPtrFieldBase::raw_data() const {
 1858|   111k|  return rep_ ? rep_->elements : NULL;
  ------------------
  |  Branch (1858:10): [True: 8.61k, False: 102k]
  ------------------
 1859|   111k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEC2EPKPv:
 2432|   102k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEC2IS9_EERKNS2_IT_EE:
 2438|   102k|      : it_(other.it_) {
 2439|       |    // Force a compiler error if the other type is not convertible to ours.
 2440|   102k|    if (false) {
  ------------------
  |  Branch (2440:9): [Folded, False: 102k]
  ------------------
 2441|      0|      implicit_cast<Element*>(static_cast<OtherElement*>(nullptr));
 2442|      0|    }
 2443|   102k|  }
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE3endEv:
 2628|  51.2k|RepeatedPtrField<Element>::end() const {
 2629|  51.2k|  return iterator(raw_data() + size());
 2630|  51.2k|}
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE4sizeEv:
 2167|   102k|inline int RepeatedPtrField<Element>::size() const {
 2168|   102k|  return RepeatedPtrFieldBase::size();
 2169|   102k|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv:
 1700|   263k|inline int RepeatedPtrFieldBase::size() const { return current_size_; }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEneERKSB_:
 2463|  51.2k|  bool operator!=(const iterator& x) const { return it_ != x.it_; }
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseD2Ev:
  582|   174k|  ~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|   174k|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8GetArenaEv:
  719|  69.8k|  inline Arena* GetArena() const { return arena_; }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase5emptyEv:
 1698|  8.53k|inline bool RepeatedPtrFieldBase::empty() const { return current_size_ == 0; }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase12InternalSwapEPS2_:
 2589|  34.1k|void RepeatedPtrFieldBase::InternalSwap(RepeatedPtrFieldBase* other) {
 2590|  34.1k|  GOOGLE_DCHECK(this != other);
  ------------------
  |  |  181|  34.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: 34.1k]
  |  |  ------------------
  ------------------
 2591|  34.1k|  GOOGLE_DCHECK(GetArena() == other->GetArena());
  ------------------
  |  |  181|  34.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: 34.1k]
  |  |  ------------------
  ------------------
 2592|       |
 2593|       |  // Swap all fields at once.
 2594|  34.1k|  static_assert(std::is_standard_layout<RepeatedPtrFieldBase>::value,
 2595|  34.1k|                "offsetof() requires standard layout before c++17");
 2596|  34.1k|  internal::memswap<offsetof(RepeatedPtrFieldBase, rep_) + sizeof(this->rep_) -
 2597|  34.1k|                    offsetof(RepeatedPtrFieldBase, current_size_)>(
 2598|  34.1k|      reinterpret_cast<char*>(this) +
 2599|  34.1k|          offsetof(RepeatedPtrFieldBase, current_size_),
 2600|  34.1k|      reinterpret_cast<char*>(other) +
 2601|       |          offsetof(RepeatedPtrFieldBase, current_size_));
 2602|  34.1k|}
_ZN6google8protobuf8internal7memswapILi16EEENSt3__19enable_ifIXaageT_Lm16EltT_lsLj1ELi31EEvE4typeEPcS7_:
  140|  42.7k|  memswap(char* p, char* q) {                                                \
  141|  42.7k|    SwapBlock<reg_type>(p, q);                                               \
  142|  42.7k|    memswap<kSize - sizeof(reg_type)>(p + sizeof(reg_type),                  \
  143|  42.7k|                                      q + sizeof(reg_type));                 \
  144|  42.7k|  }
_ZN6google8protobuf8internal9SwapBlockIoEEvPcS3_:
  122|  59.8k|inline void SwapBlock(char* p, char* q) {
  123|  59.8k|  T tmp;
  124|  59.8k|  memcpy(&tmp, p, sizeof(T));
  125|  59.8k|  memcpy(p, q, sizeof(T));
  126|  59.8k|  memcpy(q, &tmp, sizeof(T));
  127|  59.8k|}
_ZN6google8protobuf8internal7memswapILi0EEENSt3__19enable_ifIXeqT_Li0EEvE4typeEPcS7_:
  133|  42.7k|inline typename std::enable_if<(kSize == 0), void>::type memswap(char*, char*) {
  134|  42.7k|}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5ClearEv:
 2293|  33.6k|inline void RepeatedPtrField<Element>::Clear() {
 2294|  33.6k|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 2295|  33.6k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEvv:
 1778|  33.6k|void RepeatedPtrFieldBase::Clear() {
 1779|  33.6k|  const int n = current_size_;
 1780|  33.6k|  GOOGLE_DCHECK_GE(n, 0);
  ------------------
  |  |  188|  33.6k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|  33.6k|#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: 33.6k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1781|  33.6k|  if (n > 0) {
  ------------------
  |  Branch (1781:7): [True: 0, False: 33.6k]
  ------------------
 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|  33.6k|}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE4sizeEv:
 2167|   160k|inline int RepeatedPtrField<Element>::size() const {
 2168|   160k|  return RepeatedPtrFieldBase::size();
 2169|   160k|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE5ClearEv:
 2293|  55.5k|inline void RepeatedPtrField<Element>::Clear() {
 2294|  55.5k|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 2295|  55.5k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEvv:
 1778|  55.5k|void RepeatedPtrFieldBase::Clear() {
 1779|  55.5k|  const int n = current_size_;
 1780|  55.5k|  GOOGLE_DCHECK_GE(n, 0);
  ------------------
  |  |  188|  55.5k|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|  55.5k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 55.5k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1781|  55.5k|  if (n > 0) {
  ------------------
  |  Branch (1781:7): [True: 41.2k, False: 14.2k]
  ------------------
 1782|  41.2k|    void* const* elements = rep_->elements;
 1783|  41.2k|    int i = 0;
 1784|  7.17M|    do {
 1785|  7.17M|      TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
 1786|  7.17M|    } while (i < n);
  ------------------
  |  Branch (1786:14): [True: 7.13M, False: 41.2k]
  ------------------
 1787|  41.2k|    current_size_ = 0;
 1788|  41.2k|  }
 1789|  55.5k|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE5ClearEPS4_:
  826|  7.17M|  static inline void Clear(GenericType* value) { value->Clear(); }
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEPNT_4TypeEPv:
  748|   650M|  static inline typename TypeHandler::Type* cast(void* element) {
  749|   650M|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  750|   650M|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3GetEi:
 2172|   635M|inline const Element& RepeatedPtrField<Element>::Get(int index) const {
 2173|   635M|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 2174|   635M|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEERKNT_4TypeEi:
 1704|   635M|    int index) const {
 1705|   635M|  GOOGLE_DCHECK_GE(index, 0);
  ------------------
  |  |  188|   635M|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|   635M|#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: 635M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1706|   635M|  GOOGLE_DCHECK_LT(index, current_size_);
  ------------------
  |  |  185|   635M|#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
  |  |  ------------------
  |  |  |  |  181|   635M|#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: 635M]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1707|   635M|  return *cast<TypeHandler>(rep_->elements[index]);
 1708|   635M|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3AddEv:
 2193|  7.76M|inline Element* RepeatedPtrField<Element>::Add() {
 2194|  7.76M|  return RepeatedPtrFieldBase::Add<TypeHandler>();
 2195|  7.76M|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEPNT_4TypeESB_:
 1741|  7.76M|    typename TypeHandler::Type* prototype) {
 1742|  7.76M|  if (rep_ != NULL && current_size_ < rep_->allocated_size) {
  ------------------
  |  Branch (1742:7): [True: 7.74M, False: 14.2k]
  |  Branch (1742:23): [True: 5.45M, False: 2.29M]
  ------------------
 1743|  5.45M|    return cast<TypeHandler>(rep_->elements[current_size_++]);
 1744|  5.45M|  }
 1745|  2.30M|  if (!rep_ || rep_->allocated_size == total_size_) {
  ------------------
  |  Branch (1745:7): [True: 14.2k, False: 2.29M]
  |  Branch (1745:16): [True: 55.5k, False: 2.23M]
  ------------------
 1746|  69.8k|    Reserve(total_size_ + 1);
 1747|  69.8k|  }
 1748|  2.30M|  ++rep_->allocated_size;
 1749|  2.30M|  typename TypeHandler::Type* result =
 1750|  2.30M|      TypeHandler::NewFromPrototype(prototype, arena_);
 1751|  2.30M|  rep_->elements[current_size_++] = result;
 1752|  2.30M|  return result;
 1753|  7.76M|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE16NewFromPrototypeEPKS4_PNS0_5ArenaE:
  836|  2.30M|    const GenericType* /* prototype */, Arena* arena) {
  837|  2.30M|  return New(arena);
  838|  2.30M|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE3NewEPNS0_5ArenaE:
  806|  2.30M|  static inline GenericType* New(Arena* arena) {
  807|  2.30M|    return Arena::CreateMaybeMessage<Type>(arena);
  808|  2.30M|  }
_ZNK6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE5emptyEv:
 2162|  8.53k|inline bool RepeatedPtrField<Element>::empty() const {
 2163|  8.53k|  return RepeatedPtrFieldBase::empty();
 2164|  8.53k|}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE5beginEv:
 2613|  4.30k|RepeatedPtrField<Element>::begin() const {
 2614|  4.30k|  return iterator(raw_data());
 2615|  4.30k|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN13sentencepiece24ModelProto_SentencePieceEEC2EPKPv:
 2432|  8.61k|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEC2IS4_EERKNS2_IT_EE:
 2438|  8.61k|      : it_(other.it_) {
 2439|       |    // Force a compiler error if the other type is not convertible to ours.
 2440|  8.61k|    if (false) {
  ------------------
  |  Branch (2440:9): [Folded, False: 8.61k]
  ------------------
 2441|      0|      implicit_cast<Element*>(static_cast<OtherElement*>(nullptr));
 2442|      0|    }
 2443|  8.61k|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3endEv:
 2628|  4.30k|RepeatedPtrField<Element>::end() const {
 2629|  4.30k|  return iterator(raw_data() + size());
 2630|  4.30k|}
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEneERKS6_:
 2463|   260k|  bool operator!=(const iterator& x) const { return it_ != x.it_; }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEppEv:
 2450|   256k|  iterator& operator++() {
 2451|   256k|    ++it_;
 2452|   256k|    return *this;
 2453|   256k|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEdeEv:
 2446|   256k|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPNS0_5ArenaE:
 2098|   102k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2ERKS9_:
 2103|  57.8k|    : RepeatedPtrFieldBase() {
 2104|  57.8k|  MergeFrom(other);
 2105|  57.8k|}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEED2Ev:
 2121|   159k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 2122|   159k|  Destroy<TypeHandler>();
 2123|   159k|}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE9MergeFromERKS9_:
 2299|  91.4k|    const RepeatedPtrField& other) {
 2300|  91.4k|  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
 2301|  91.4k|}
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE12InternalSwapEPS9_:
 1154|  34.1k|  void InternalSwap(RepeatedPtrField* other) {
 1155|  34.1k|    internal::RepeatedPtrFieldBase::InternalSwap(other);
 1156|  34.1k|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2Ev:
 1651|  57.8k|    : arena_(NULL), current_size_(0), total_size_(0), rep_(NULL) {}
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2EPNS0_5ArenaE:
 1654|   116k|    : arena_(arena), current_size_(0), total_size_(0), rep_(NULL) {}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7DestroyINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEvv:
 1657|   159k|void RepeatedPtrFieldBase::Destroy() {
 1658|   159k|  if (rep_ != NULL && arena_ == NULL) {
  ------------------
  |  Branch (1658:7): [True: 0, False: 159k]
  |  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|   159k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase9MergeFromINS0_16RepeatedPtrFieldINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEE11TypeHandlerEEEvRKS2_:
 1798|  91.4k|inline void RepeatedPtrFieldBase::MergeFrom(const RepeatedPtrFieldBase& other) {
 1799|  91.4k|  GOOGLE_DCHECK_NE(&other, this);
  ------------------
  |  |  184|  91.4k|#define GOOGLE_DCHECK_NE(A, B) GOOGLE_DCHECK((A) != (B))
  |  |  ------------------
  |  |  |  |  181|  91.4k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 91.4k]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1800|  91.4k|  if (other.current_size_ == 0) return;
  ------------------
  |  Branch (1800:7): [True: 91.4k, False: 0]
  ------------------
 1801|      0|  MergeFromInternal(other,
 1802|      0|                    &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
 1803|      0|}
_ZN6google8protobuf8internal7memswapILi48EEENSt3__19enable_ifIXaageT_Lm16EltT_lsLj1ELi31EEvE4typeEPcS7_:
  140|  8.54k|  memswap(char* p, char* q) {                                                \
  141|  8.54k|    SwapBlock<reg_type>(p, q);                                               \
  142|  8.54k|    memswap<kSize - sizeof(reg_type)>(p + sizeof(reg_type),                  \
  143|  8.54k|                                      q + sizeof(reg_type));                 \
  144|  8.54k|  }
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEEC2EPNS0_5ArenaE:
 2098|      1|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEEC2EPNS0_5ArenaE:
 2098|  14.4k|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEED2Ev:
 2121|  14.4k|RepeatedPtrField<Element>::~RepeatedPtrField() {
 2122|  14.4k|  Destroy<TypeHandler>();
 2123|  14.4k|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7DestroyINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEvv:
 1657|  14.4k|void RepeatedPtrFieldBase::Destroy() {
 1658|  14.4k|  if (rep_ != NULL && arena_ == NULL) {
  ------------------
  |  Branch (1658:7): [True: 14.2k, False: 202]
  |  Branch (1658:23): [True: 14.2k, False: 0]
  ------------------
 1659|  14.2k|    int n = rep_->allocated_size;
 1660|  14.2k|    void* const* elements = rep_->elements;
 1661|  2.31M|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1661:21): [True: 2.30M, False: 14.2k]
  ------------------
 1662|  2.30M|      TypeHandler::Delete(cast<TypeHandler>(elements[i]), NULL);
 1663|  2.30M|    }
 1664|  14.2k|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
 1665|  14.2k|    const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
 1666|  14.2k|    ::operator delete(static_cast<void*>(rep_), size);
 1667|       |#else
 1668|       |    ::operator delete(static_cast<void*>(rep_));
 1669|       |#endif
 1670|  14.2k|  }
 1671|       |  rep_ = NULL;
 1672|  14.4k|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE6DeleteEPS4_PNS0_5ArenaE:
  814|  2.30M|  static inline void Delete(GenericType* value, Arena* arena) {
  815|  2.30M|    if (arena == NULL) {
  ------------------
  |  Branch (815:9): [True: 2.30M, False: 0]
  ------------------
  816|  2.30M|      delete value;
  817|  2.30M|    }
  818|  2.30M|  }
_ZN6google8protobuf8internal7memswapILi32EEENSt3__19enable_ifIXaageT_Lm16EltT_lsLj1ELi31EEvE4typeEPcS7_:
  140|  8.54k|  memswap(char* p, char* q) {                                                \
  141|  8.54k|    SwapBlock<reg_type>(p, q);                                               \
  142|  8.54k|    memswap<kSize - sizeof(reg_type)>(p + sizeof(reg_type),                  \
  143|  8.54k|                                      q + sizeof(reg_type));                 \
  144|  8.54k|  }

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

_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|   556k|  static uint32 Log2FloorNonZero(uint32 n) {
  283|   556k|#if defined(__GNUC__)
  284|   556k|  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|   556k|  }
_ZN6google8protobuf4Bits18Log2FloorNonZero64Em:
  294|  1.04k|  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.04k|#if defined(__GNUC__) && !defined(GOOGLE_PROTOBUF_USE_PORTABLE_LOG2)
  302|  1.04k|  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.04k|  }

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

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

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

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

_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|  8.54k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   24|  8.54k|  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|  8.54k|  int vocab_size = fdp.ConsumeIntegralInRange<int>(10, 100);
   30|  8.54k|  std::string model_type;
   31|  8.54k|  switch (fdp.ConsumeIntegralInRange<int>(0, 3)) {
  ------------------
  |  Branch (31:11): [True: 8.54k, False: 0]
  ------------------
   32|  5.91k|    case 0: model_type = "unigram"; break;
  ------------------
  |  Branch (32:5): [True: 5.91k, False: 2.63k]
  ------------------
   33|  1.44k|    case 1: model_type = "bpe"; break;
  ------------------
  |  Branch (33:5): [True: 1.44k, False: 7.10k]
  ------------------
   34|    933|    case 2: model_type = "word"; break;
  ------------------
  |  Branch (34:5): [True: 933, False: 7.61k]
  ------------------
   35|    260|    case 3: model_type = "char"; break;
  ------------------
  |  Branch (35:5): [True: 260, False: 8.28k]
  ------------------
   36|  8.54k|  }
   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|  8.54k|  std::string args = "--vocab_size=" + std::to_string(vocab_size) +
   41|  8.54k|                     " --model_type=" + model_type;
   42|       |
   43|       |  // Randomly add some other common flags
   44|  8.54k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (44:7): [True: 2.17k, False: 6.37k]
  ------------------
   45|  2.17k|    args += " --character_coverage=" + std::to_string(fdp.ConsumeFloatingPointInRange<float>(0.98, 1.0));
   46|  2.17k|  }
   47|  8.54k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (47:7): [True: 1.76k, False: 6.78k]
  ------------------
   48|  1.76k|    args += " --input_sentence_size=" + std::to_string(fdp.ConsumeIntegralInRange<int>(100, 500));
   49|  1.76k|  }
   50|  8.54k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (50:7): [True: 2.06k, False: 6.47k]
  ------------------
   51|  2.06k|    args += " --shuffle_input_sentence=" + std::string(fdp.ConsumeBool() ? "true" : "false");
  ------------------
  |  Branch (51:56): [True: 882, False: 1.18k]
  ------------------
   52|  2.06k|  }
   53|  8.54k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (53:7): [True: 3.10k, False: 5.44k]
  ------------------
   54|  3.10k|    args += " --split_by_unicode_script=" + std::string(fdp.ConsumeBool() ? "true" : "false");
  ------------------
  |  Branch (54:57): [True: 598, False: 2.50k]
  ------------------
   55|  3.10k|  }
   56|  8.54k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (56:7): [True: 2.30k, False: 6.23k]
  ------------------
   57|  2.30k|    args += " --split_by_whitespace=" + std::string(fdp.ConsumeBool() ? "true" : "false");
  ------------------
  |  Branch (57:53): [True: 1.13k, False: 1.17k]
  ------------------
   58|  2.30k|  }
   59|  8.54k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (59:7): [True: 2.31k, False: 6.23k]
  ------------------
   60|  2.31k|    args += " --split_by_number=" + std::string(fdp.ConsumeBool() ? "true" : "false");
  ------------------
  |  Branch (60:49): [True: 995, False: 1.31k]
  ------------------
   61|  2.31k|  }
   62|  8.54k|  if (fdp.ConsumeBool()) {
  ------------------
  |  Branch (62:7): [True: 1.48k, False: 7.06k]
  ------------------
   63|  1.48k|    args += " --byte_fallback=" + std::string(fdp.ConsumeBool() ? "true" : "false");
  ------------------
  |  Branch (63:47): [True: 68, False: 1.41k]
  ------------------
   64|  1.48k|  }
   65|       |  
   66|       |  // Mandatory for performance in fuzzing
   67|  8.54k|  args += " --num_threads=1";
   68|       |
   69|       |  // Generate a small number of training sentences
   70|  8.54k|  int num_sentences = fdp.ConsumeIntegralInRange<int>(1, 50);
   71|  8.54k|  std::vector<std::string> sentences;
   72|   234k|  for (int i = 0; i < num_sentences; ++i) {
  ------------------
  |  Branch (72:19): [True: 225k, False: 8.54k]
  ------------------
   73|       |    // Keep sentences relatively short
   74|   225k|    std::string s = fdp.ConsumeRandomLengthString(200);
   75|   225k|    if (!s.empty()) {
  ------------------
  |  Branch (75:9): [True: 58.8k, False: 166k]
  ------------------
   76|  58.8k|      sentences.push_back(s);
   77|  58.8k|    }
   78|   225k|  }
   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|  8.54k|  if (sentences.empty()) {
  ------------------
  |  Branch (82:7): [True: 439, False: 8.10k]
  ------------------
   83|    439|    sentences.push_back("the quick brown fox jumps over the lazy dog");
   84|    439|  }
   85|       |
   86|  8.54k|  std::string serialized_model_proto;
   87|       |  // Train can return various errors for invalid combinations of parameters,
   88|       |  // which is expected.
   89|  8.54k|  sentencepiece::SentencePieceTrainer::Train(args, sentences, &serialized_model_proto);
   90|       |
   91|  8.54k|  return 0;
   92|  8.54k|}