LLVMFuzzerInitialize:
   34|      1|extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) {
   35|      1|  g_processor = std::make_unique<sentencepiece::SentencePieceProcessor>();
   36|       |
   37|       |  // Load the model from the embedded byte array
   38|      1|  std::string model_data(
   39|      1|      reinterpret_cast<const char *>(kEmbeddedModelData),
   40|      1|      kEmbeddedModelSize);
   41|      1|  auto status = g_processor->LoadFromSerializedProto(model_data);
   42|      1|  if (!status.ok()) {
  ------------------
  |  Branch (42:7): [True: 0, False: 1]
  ------------------
   43|      0|    fprintf(stderr, "Failed to load embedded model: %s\n",
   44|      0|            status.ToString().c_str());
   45|      0|    abort();
   46|      0|  }
   47|       |
   48|      1|  return 0;
   49|      1|}

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

_ZN13sentencepiece29TrainerSpec_ModelType_IsValidEi:
  129|      1|bool TrainerSpec_ModelType_IsValid(int value) {
  130|      1|  switch (value) {
  131|      1|    case 1:
  ------------------
  |  Branch (131:5): [True: 1, False: 0]
  ------------------
  132|      1|    case 2:
  ------------------
  |  Branch (132:5): [True: 0, False: 1]
  ------------------
  133|      1|    case 3:
  ------------------
  |  Branch (133:5): [True: 0, False: 1]
  ------------------
  134|      1|    case 4:
  ------------------
  |  Branch (134:5): [True: 0, False: 1]
  ------------------
  135|      1|      return true;
  136|      0|    default:
  ------------------
  |  Branch (136:5): [True: 0, False: 1]
  ------------------
  137|      0|      return false;
  138|      1|  }
  139|      1|}
_ZN13sentencepiece37ModelProto_SentencePiece_Type_IsValidEi:
  197|    259|bool ModelProto_SentencePiece_Type_IsValid(int value) {
  198|    259|  switch (value) {
  199|      0|    case 1:
  ------------------
  |  Branch (199:5): [True: 0, False: 259]
  ------------------
  200|      1|    case 2:
  ------------------
  |  Branch (200:5): [True: 1, False: 258]
  ------------------
  201|      3|    case 3:
  ------------------
  |  Branch (201:5): [True: 2, False: 257]
  ------------------
  202|      3|    case 4:
  ------------------
  |  Branch (202:5): [True: 0, False: 259]
  ------------------
  203|      3|    case 5:
  ------------------
  |  Branch (203:5): [True: 0, False: 259]
  ------------------
  204|    259|    case 6:
  ------------------
  |  Branch (204:5): [True: 256, False: 3]
  ------------------
  205|    259|      return true;
  206|      0|    default:
  ------------------
  |  Branch (206:5): [True: 0, False: 259]
  ------------------
  207|      0|      return false;
  208|    259|  }
  209|    259|}
_ZN13sentencepiece11TrainerSpecC2EPN6google8protobuf5ArenaE:
  415|      2|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  416|      2|  _extensions_(arena),
  417|      2|  input_(arena),
  418|      2|  accept_language_(arena),
  419|      2|  control_symbols_(arena),
  420|      2|  user_defined_symbols_(arena) {
  421|      2|  SharedCtor();
  422|      2|  RegisterArenaDtor(arena);
  423|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.TrainerSpec)
  424|      2|}
_ZN13sentencepiece11TrainerSpec14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE:
  646|      1|const char* TrainerSpec::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
  647|      1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  648|      4|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (648:10): [True: 3, False: 1]
  ------------------
  649|      3|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
  650|      3|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
  651|      3|    CHK_(ptr);
  ------------------
  |  |  647|      3|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      3|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  652|      3|    switch (tag >> 3) {
  653|       |      // repeated string input = 1;
  654|      0|      case 1:
  ------------------
  |  Branch (654:7): [True: 0, False: 3]
  ------------------
  655|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  656|      0|          ptr -= 1;
  657|      0|          do {
  658|      0|            ptr += 1;
  659|      0|            auto str = _internal_add_input();
  660|      0|            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  661|      0|            CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  662|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (662:17): [True: 0, False: 0]
  ------------------
  663|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
  ------------------
  |  Branch (663:20): [True: 0, False: 0]
  ------------------
  664|      0|        } else goto handle_unusual;
  665|      0|        continue;
  666|       |      // optional string model_prefix = 2;
  667|      0|      case 2:
  ------------------
  |  Branch (667:7): [True: 0, False: 3]
  ------------------
  668|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  669|      0|          auto str = _internal_mutable_model_prefix();
  670|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  671|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  672|      0|        } else goto handle_unusual;
  673|      0|        continue;
  674|       |      // optional .sentencepiece.TrainerSpec.ModelType model_type = 3 [default = UNIGRAM];
  675|      1|      case 3:
  ------------------
  |  Branch (675:7): [True: 1, False: 2]
  ------------------
  676|      1|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
  ------------------
  |  |  236|      1|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  677|      1|          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  678|      1|          CHK_(ptr);
  ------------------
  |  |  647|      1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  679|      1|          if (PROTOBUF_PREDICT_TRUE(::sentencepiece::TrainerSpec_ModelType_IsValid(val))) {
  ------------------
  |  |  236|      1|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  680|      1|            _internal_set_model_type(static_cast<::sentencepiece::TrainerSpec_ModelType>(val));
  681|      1|          } else {
  682|      0|            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
  683|      0|          }
  684|      1|        } else goto handle_unusual;
  685|      1|        continue;
  686|       |      // optional int32 vocab_size = 4 [default = 8000];
  687|      1|      case 4:
  ------------------
  |  Branch (687:7): [True: 1, False: 2]
  ------------------
  688|      1|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
  ------------------
  |  |  236|      1|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  689|      1|          _Internal::set_has_vocab_size(&_has_bits_);
  690|      1|          vocab_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  691|      1|          CHK_(ptr);
  ------------------
  |  |  647|      1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  692|      1|        } else goto handle_unusual;
  693|      1|        continue;
  694|       |      // repeated string accept_language = 5;
  695|      1|      case 5:
  ------------------
  |  Branch (695:7): [True: 0, False: 3]
  ------------------
  696|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  697|      0|          ptr -= 1;
  698|      0|          do {
  699|      0|            ptr += 1;
  700|      0|            auto str = _internal_add_accept_language();
  701|      0|            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  702|      0|            CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  703|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (703:17): [True: 0, False: 0]
  ------------------
  704|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<42>(ptr));
  ------------------
  |  Branch (704:20): [True: 0, False: 0]
  ------------------
  705|      0|        } else goto handle_unusual;
  706|      0|        continue;
  707|       |      // optional int32 self_test_sample_size = 6 [default = 0];
  708|      0|      case 6:
  ------------------
  |  Branch (708:7): [True: 0, False: 3]
  ------------------
  709|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  710|      0|          _Internal::set_has_self_test_sample_size(&_has_bits_);
  711|      0|          self_test_sample_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  712|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  713|      0|        } else goto handle_unusual;
  714|      0|        continue;
  715|       |      // optional string input_format = 7;
  716|      0|      case 7:
  ------------------
  |  Branch (716:7): [True: 0, False: 3]
  ------------------
  717|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  718|      0|          auto str = _internal_mutable_input_format();
  719|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  720|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  721|      0|        } else goto handle_unusual;
  722|      0|        continue;
  723|       |      // optional float character_coverage = 10 [default = 0.9995];
  724|      0|      case 10:
  ------------------
  |  Branch (724:7): [True: 0, False: 3]
  ------------------
  725|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 85)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  726|      0|          _Internal::set_has_character_coverage(&_has_bits_);
  727|      0|          character_coverage_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
  728|      0|          ptr += sizeof(float);
  729|      0|        } else goto handle_unusual;
  730|      0|        continue;
  731|       |      // optional uint64 input_sentence_size = 11 [default = 0];
  732|      0|      case 11:
  ------------------
  |  Branch (732:7): [True: 0, False: 3]
  ------------------
  733|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  734|      0|          _Internal::set_has_input_sentence_size(&_has_bits_);
  735|      0|          input_sentence_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  736|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  737|      0|        } else goto handle_unusual;
  738|      0|        continue;
  739|       |      // optional int32 mining_sentence_size = 12 [deprecated = true];
  740|      0|      case 12:
  ------------------
  |  Branch (740:7): [True: 0, False: 3]
  ------------------
  741|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 96)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  742|      0|          _Internal::set_has_mining_sentence_size(&_has_bits_);
  743|      0|          mining_sentence_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  744|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  745|      0|        } else goto handle_unusual;
  746|      0|        continue;
  747|       |      // optional int32 training_sentence_size = 13 [deprecated = true];
  748|      0|      case 13:
  ------------------
  |  Branch (748:7): [True: 0, False: 3]
  ------------------
  749|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 104)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  750|      0|          _Internal::set_has_training_sentence_size(&_has_bits_);
  751|      0|          training_sentence_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  752|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  753|      0|        } else goto handle_unusual;
  754|      0|        continue;
  755|       |      // optional int32 seed_sentencepiece_size = 14 [default = 1000000];
  756|      0|      case 14:
  ------------------
  |  Branch (756:7): [True: 0, False: 3]
  ------------------
  757|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 112)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  758|      0|          _Internal::set_has_seed_sentencepiece_size(&_has_bits_);
  759|      0|          seed_sentencepiece_size_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  760|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  761|      0|        } else goto handle_unusual;
  762|      0|        continue;
  763|       |      // optional float shrinking_factor = 15 [default = 0.75];
  764|      0|      case 15:
  ------------------
  |  Branch (764:7): [True: 0, False: 3]
  ------------------
  765|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 125)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  766|      0|          _Internal::set_has_shrinking_factor(&_has_bits_);
  767|      0|          shrinking_factor_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
  768|      0|          ptr += sizeof(float);
  769|      0|        } else goto handle_unusual;
  770|      0|        continue;
  771|       |      // optional int32 num_threads = 16 [default = 16];
  772|      0|      case 16:
  ------------------
  |  Branch (772:7): [True: 0, False: 3]
  ------------------
  773|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 128)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  774|      0|          _Internal::set_has_num_threads(&_has_bits_);
  775|      0|          num_threads_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  776|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  777|      0|        } else goto handle_unusual;
  778|      0|        continue;
  779|       |      // optional int32 num_sub_iterations = 17 [default = 2];
  780|      0|      case 17:
  ------------------
  |  Branch (780:7): [True: 0, False: 3]
  ------------------
  781|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  782|      0|          _Internal::set_has_num_sub_iterations(&_has_bits_);
  783|      0|          num_sub_iterations_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  784|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  785|      0|        } else goto handle_unusual;
  786|      0|        continue;
  787|       |      // optional int32 max_sentence_length = 18 [default = 4192];
  788|      0|      case 18:
  ------------------
  |  Branch (788:7): [True: 0, False: 3]
  ------------------
  789|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  790|      0|          _Internal::set_has_max_sentence_length(&_has_bits_);
  791|      0|          max_sentence_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  792|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  793|      0|        } else goto handle_unusual;
  794|      0|        continue;
  795|       |      // optional bool shuffle_input_sentence = 19 [default = true];
  796|      0|      case 19:
  ------------------
  |  Branch (796:7): [True: 0, False: 3]
  ------------------
  797|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 152)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  798|      0|          _Internal::set_has_shuffle_input_sentence(&_has_bits_);
  799|      0|          shuffle_input_sentence_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  800|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  801|      0|        } else goto handle_unusual;
  802|      0|        continue;
  803|       |      // optional int32 max_sentencepiece_length = 20 [default = 16];
  804|      0|      case 20:
  ------------------
  |  Branch (804:7): [True: 0, False: 3]
  ------------------
  805|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 160)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  806|      0|          _Internal::set_has_max_sentencepiece_length(&_has_bits_);
  807|      0|          max_sentencepiece_length_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  808|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  809|      0|        } else goto handle_unusual;
  810|      0|        continue;
  811|       |      // optional bool split_by_unicode_script = 21 [default = true];
  812|      0|      case 21:
  ------------------
  |  Branch (812:7): [True: 0, False: 3]
  ------------------
  813|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 168)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  814|      0|          _Internal::set_has_split_by_unicode_script(&_has_bits_);
  815|      0|          split_by_unicode_script_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  816|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  817|      0|        } else goto handle_unusual;
  818|      0|        continue;
  819|       |      // optional bool split_by_whitespace = 22 [default = true];
  820|      0|      case 22:
  ------------------
  |  Branch (820:7): [True: 0, False: 3]
  ------------------
  821|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 176)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  822|      0|          _Internal::set_has_split_by_whitespace(&_has_bits_);
  823|      0|          split_by_whitespace_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  824|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  825|      0|        } else goto handle_unusual;
  826|      0|        continue;
  827|       |      // optional bool split_by_number = 23 [default = true];
  828|      0|      case 23:
  ------------------
  |  Branch (828:7): [True: 0, False: 3]
  ------------------
  829|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 184)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  830|      0|          _Internal::set_has_split_by_number(&_has_bits_);
  831|      0|          split_by_number_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  832|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  833|      0|        } else goto handle_unusual;
  834|      0|        continue;
  835|       |      // optional bool treat_whitespace_as_suffix = 24 [default = false];
  836|      0|      case 24:
  ------------------
  |  Branch (836:7): [True: 0, False: 3]
  ------------------
  837|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 192)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  838|      0|          _Internal::set_has_treat_whitespace_as_suffix(&_has_bits_);
  839|      0|          treat_whitespace_as_suffix_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  840|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  841|      0|        } else goto handle_unusual;
  842|      0|        continue;
  843|       |      // optional bool split_digits = 25 [default = false];
  844|      0|      case 25:
  ------------------
  |  Branch (844:7): [True: 0, False: 3]
  ------------------
  845|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 200)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  846|      0|          _Internal::set_has_split_digits(&_has_bits_);
  847|      0|          split_digits_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  848|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  849|      0|        } else goto handle_unusual;
  850|      0|        continue;
  851|       |      // optional bool allow_whitespace_only_pieces = 26 [default = false];
  852|      0|      case 26:
  ------------------
  |  Branch (852:7): [True: 0, False: 3]
  ------------------
  853|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 208)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  854|      0|          _Internal::set_has_allow_whitespace_only_pieces(&_has_bits_);
  855|      0|          allow_whitespace_only_pieces_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  856|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  857|      0|        } else goto handle_unusual;
  858|      0|        continue;
  859|       |      // repeated string control_symbols = 30;
  860|      0|      case 30:
  ------------------
  |  Branch (860:7): [True: 0, False: 3]
  ------------------
  861|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 242)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  862|      0|          ptr -= 2;
  863|      0|          do {
  864|      0|            ptr += 2;
  865|      0|            auto str = _internal_add_control_symbols();
  866|      0|            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  867|      0|            CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  868|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (868:17): [True: 0, False: 0]
  ------------------
  869|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<242>(ptr));
  ------------------
  |  Branch (869:20): [True: 0, False: 0]
  ------------------
  870|      0|        } else goto handle_unusual;
  871|      0|        continue;
  872|       |      // repeated string user_defined_symbols = 31;
  873|      0|      case 31:
  ------------------
  |  Branch (873:7): [True: 0, False: 3]
  ------------------
  874|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  875|      0|          ptr -= 2;
  876|      0|          do {
  877|      0|            ptr += 2;
  878|      0|            auto str = _internal_add_user_defined_symbols();
  879|      0|            ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  880|      0|            CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  881|      0|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (881:17): [True: 0, False: 0]
  ------------------
  882|      0|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<250>(ptr));
  ------------------
  |  Branch (882:20): [True: 0, False: 0]
  ------------------
  883|      0|        } else goto handle_unusual;
  884|      0|        continue;
  885|       |      // optional bool vocabulary_output_piece_score = 32 [default = true];
  886|      0|      case 32:
  ------------------
  |  Branch (886:7): [True: 0, False: 3]
  ------------------
  887|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 0)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  888|      0|          _Internal::set_has_vocabulary_output_piece_score(&_has_bits_);
  889|      0|          vocabulary_output_piece_score_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  890|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  891|      0|        } else goto handle_unusual;
  892|      0|        continue;
  893|       |      // optional bool hard_vocab_limit = 33 [default = true];
  894|      0|      case 33:
  ------------------
  |  Branch (894:7): [True: 0, False: 3]
  ------------------
  895|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 8)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  896|      0|          _Internal::set_has_hard_vocab_limit(&_has_bits_);
  897|      0|          hard_vocab_limit_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  898|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  899|      0|        } else goto handle_unusual;
  900|      0|        continue;
  901|       |      // optional bool use_all_vocab = 34 [default = false];
  902|      0|      case 34:
  ------------------
  |  Branch (902:7): [True: 0, False: 3]
  ------------------
  903|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 16)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  904|      0|          _Internal::set_has_use_all_vocab(&_has_bits_);
  905|      0|          use_all_vocab_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  906|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  907|      0|        } else goto handle_unusual;
  908|      0|        continue;
  909|       |      // optional bool byte_fallback = 35 [default = false];
  910|      1|      case 35:
  ------------------
  |  Branch (910:7): [True: 1, False: 2]
  ------------------
  911|      1|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
  ------------------
  |  |  236|      1|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  912|      1|          _Internal::set_has_byte_fallback(&_has_bits_);
  913|      1|          byte_fallback_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  914|      1|          CHK_(ptr);
  ------------------
  |  |  647|      1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  915|      1|        } else goto handle_unusual;
  916|      1|        continue;
  917|       |      // optional string required_chars = 36;
  918|      1|      case 36:
  ------------------
  |  Branch (918:7): [True: 0, False: 3]
  ------------------
  919|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  920|      0|          auto str = _internal_mutable_required_chars();
  921|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  922|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  923|      0|        } else goto handle_unusual;
  924|      0|        continue;
  925|       |      // optional int32 unk_id = 40 [default = 0];
  926|      0|      case 40:
  ------------------
  |  Branch (926:7): [True: 0, False: 3]
  ------------------
  927|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 64)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  928|      0|          _Internal::set_has_unk_id(&_has_bits_);
  929|      0|          unk_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  930|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  931|      0|        } else goto handle_unusual;
  932|      0|        continue;
  933|       |      // optional int32 bos_id = 41 [default = 1];
  934|      0|      case 41:
  ------------------
  |  Branch (934:7): [True: 0, False: 3]
  ------------------
  935|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  936|      0|          _Internal::set_has_bos_id(&_has_bits_);
  937|      0|          bos_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  938|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  939|      0|        } else goto handle_unusual;
  940|      0|        continue;
  941|       |      // optional int32 eos_id = 42 [default = 2];
  942|      0|      case 42:
  ------------------
  |  Branch (942:7): [True: 0, False: 3]
  ------------------
  943|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  944|      0|          _Internal::set_has_eos_id(&_has_bits_);
  945|      0|          eos_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  946|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  947|      0|        } else goto handle_unusual;
  948|      0|        continue;
  949|       |      // optional int32 pad_id = 43 [default = -1];
  950|      0|      case 43:
  ------------------
  |  Branch (950:7): [True: 0, False: 3]
  ------------------
  951|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 88)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  952|      0|          _Internal::set_has_pad_id(&_has_bits_);
  953|      0|          pad_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
  954|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  955|      0|        } else goto handle_unusual;
  956|      0|        continue;
  957|       |      // optional string unk_surface = 44 [default = " \342\201\207 "];
  958|      0|      case 44:
  ------------------
  |  Branch (958:7): [True: 0, False: 3]
  ------------------
  959|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  960|      0|          auto str = _internal_mutable_unk_surface();
  961|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  962|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  963|      0|        } else goto handle_unusual;
  964|      0|        continue;
  965|       |      // optional string unk_piece = 45 [default = "<unk>"];
  966|      0|      case 45:
  ------------------
  |  Branch (966:7): [True: 0, False: 3]
  ------------------
  967|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  968|      0|          auto str = _internal_mutable_unk_piece();
  969|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  970|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  971|      0|        } else goto handle_unusual;
  972|      0|        continue;
  973|       |      // optional string bos_piece = 46 [default = "<s>"];
  974|      0|      case 46:
  ------------------
  |  Branch (974:7): [True: 0, False: 3]
  ------------------
  975|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 114)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  976|      0|          auto str = _internal_mutable_bos_piece();
  977|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  978|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  979|      0|        } else goto handle_unusual;
  980|      0|        continue;
  981|       |      // optional string eos_piece = 47 [default = "</s>"];
  982|      0|      case 47:
  ------------------
  |  Branch (982:7): [True: 0, False: 3]
  ------------------
  983|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  984|      0|          auto str = _internal_mutable_eos_piece();
  985|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  986|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  987|      0|        } else goto handle_unusual;
  988|      0|        continue;
  989|       |      // optional string pad_piece = 48 [default = "<pad>"];
  990|      0|      case 48:
  ------------------
  |  Branch (990:7): [True: 0, False: 3]
  ------------------
  991|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  992|      0|          auto str = _internal_mutable_pad_piece();
  993|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
  994|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  995|      0|        } else goto handle_unusual;
  996|      0|        continue;
  997|       |      // optional bool train_extremely_large_corpus = 49 [default = false];
  998|      0|      case 49:
  ------------------
  |  Branch (998:7): [True: 0, False: 3]
  ------------------
  999|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 136)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1000|      0|          _Internal::set_has_train_extremely_large_corpus(&_has_bits_);
 1001|      0|          train_extremely_large_corpus_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 1002|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1003|      0|        } else goto handle_unusual;
 1004|      0|        continue;
 1005|       |      // optional bool enable_differential_privacy = 50 [default = false];
 1006|      0|      case 50:
  ------------------
  |  Branch (1006:7): [True: 0, False: 3]
  ------------------
 1007|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1008|      0|          _Internal::set_has_enable_differential_privacy(&_has_bits_);
 1009|      0|          enable_differential_privacy_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 1010|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1011|      0|        } else goto handle_unusual;
 1012|      0|        continue;
 1013|       |      // optional float differential_privacy_noise_level = 51 [default = 0];
 1014|      0|      case 51:
  ------------------
  |  Branch (1014:7): [True: 0, False: 3]
  ------------------
 1015|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 157)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1016|      0|          _Internal::set_has_differential_privacy_noise_level(&_has_bits_);
 1017|      0|          differential_privacy_noise_level_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
 1018|      0|          ptr += sizeof(float);
 1019|      0|        } else goto handle_unusual;
 1020|      0|        continue;
 1021|       |      // optional uint64 differential_privacy_clipping_threshold = 52 [default = 0];
 1022|      0|      case 52:
  ------------------
  |  Branch (1022:7): [True: 0, False: 3]
  ------------------
 1023|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 160)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1024|      0|          _Internal::set_has_differential_privacy_clipping_threshold(&_has_bits_);
 1025|      0|          differential_privacy_clipping_threshold_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 1026|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1027|      0|        } else goto handle_unusual;
 1028|      0|        continue;
 1029|       |      // optional string pretokenization_delimiter = 53 [default = ""];
 1030|      0|      case 53:
  ------------------
  |  Branch (1030:7): [True: 0, False: 3]
  ------------------
 1031|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1032|      0|          auto str = _internal_mutable_pretokenization_delimiter();
 1033|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 1034|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1035|      0|        } else goto handle_unusual;
 1036|      0|        continue;
 1037|       |      // optional string seed_sentencepieces_file = 54 [default = ""];
 1038|      0|      case 54:
  ------------------
  |  Branch (1038:7): [True: 0, False: 3]
  ------------------
 1039|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 178)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1040|      0|          auto str = _internal_mutable_seed_sentencepieces_file();
 1041|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 1042|      0|          CHK_(ptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1043|      0|        } else goto handle_unusual;
 1044|      0|        continue;
 1045|      0|      default: {
  ------------------
  |  Branch (1045:7): [True: 0, False: 3]
  ------------------
 1046|      0|      handle_unusual:
 1047|      0|        if ((tag & 7) == 4 || tag == 0) {
  ------------------
  |  Branch (1047:13): [True: 0, False: 0]
  |  Branch (1047:31): [True: 0, False: 0]
  ------------------
 1048|      0|          ctx->SetLastTag(tag);
 1049|      0|          goto success;
 1050|      0|        }
 1051|      0|      if ((1600u <= tag)) {
  ------------------
  |  Branch (1051:11): [True: 0, False: 0]
  ------------------
 1052|      0|        ptr = _extensions_.ParseField(tag, ptr,
 1053|      0|            internal_default_instance(), &_internal_metadata_, ctx);
 1054|      0|        CHK_(ptr != nullptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1055|      0|        continue;
 1056|      0|      }
 1057|      0|        ptr = UnknownFieldParse(tag,
 1058|      0|            _internal_metadata_.mutable_unknown_fields<std::string>(),
 1059|      0|            ptr, ctx);
 1060|      0|        CHK_(ptr != nullptr);
  ------------------
  |  |  647|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1061|      0|        continue;
 1062|      0|      }
 1063|      3|    }  // switch
 1064|      3|  }  // while
 1065|      1|success:
 1066|      1|  return ptr;
 1067|      0|failure:
 1068|      0|  ptr = nullptr;
 1069|      0|  goto success;
 1070|      1|#undef CHK_
 1071|      1|}
_ZNK13sentencepiece11TrainerSpec13IsInitializedEv:
 1872|      1|bool TrainerSpec::IsInitialized() const {
 1873|      1|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (1873:7): [True: 0, False: 1]
  ------------------
 1874|      0|    return false;
 1875|      0|  }
 1876|       |
 1877|      1|  return true;
 1878|      1|}
_ZN13sentencepiece14NormalizerSpecC2EPN6google8protobuf5ArenaE:
 1957|      2|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 1958|      2|  _extensions_(arena) {
 1959|      2|  SharedCtor();
 1960|      2|  RegisterArenaDtor(arena);
 1961|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.NormalizerSpec)
 1962|      2|}
_ZN13sentencepiece14NormalizerSpec14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE:
 2053|      1|const char* NormalizerSpec::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 2054|      1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 2055|      1|  _Internal::HasBits has_bits{};
 2056|      4|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (2056:10): [True: 3, False: 1]
  ------------------
 2057|      3|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 2058|      3|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 2059|      3|    CHK_(ptr);
  ------------------
  |  | 2054|      3|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      3|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2060|      3|    switch (tag >> 3) {
 2061|       |      // optional string name = 1;
 2062|      0|      case 1:
  ------------------
  |  Branch (2062:7): [True: 0, False: 3]
  ------------------
 2063|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2064|      0|          auto str = _internal_mutable_name();
 2065|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2066|      0|          CHK_(ptr);
  ------------------
  |  | 2054|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2067|      0|        } else goto handle_unusual;
 2068|      0|        continue;
 2069|       |      // optional bytes precompiled_charsmap = 2;
 2070|      0|      case 2:
  ------------------
  |  Branch (2070:7): [True: 0, False: 3]
  ------------------
 2071|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2072|      0|          auto str = _internal_mutable_precompiled_charsmap();
 2073|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2074|      0|          CHK_(ptr);
  ------------------
  |  | 2054|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2075|      0|        } else goto handle_unusual;
 2076|      0|        continue;
 2077|       |      // optional bool add_dummy_prefix = 3 [default = true];
 2078|      1|      case 3:
  ------------------
  |  Branch (2078:7): [True: 1, False: 2]
  ------------------
 2079|      1|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
  ------------------
  |  |  236|      1|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 2080|      1|          _Internal::set_has_add_dummy_prefix(&has_bits);
 2081|      1|          add_dummy_prefix_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2082|      1|          CHK_(ptr);
  ------------------
  |  | 2054|      1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2083|      1|        } else goto handle_unusual;
 2084|      1|        continue;
 2085|       |      // optional bool remove_extra_whitespaces = 4 [default = true];
 2086|      1|      case 4:
  ------------------
  |  Branch (2086:7): [True: 1, False: 2]
  ------------------
 2087|      1|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 32)) {
  ------------------
  |  |  236|      1|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 2088|      1|          _Internal::set_has_remove_extra_whitespaces(&has_bits);
 2089|      1|          remove_extra_whitespaces_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2090|      1|          CHK_(ptr);
  ------------------
  |  | 2054|      1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2091|      1|        } else goto handle_unusual;
 2092|      1|        continue;
 2093|       |      // optional bool escape_whitespaces = 5 [default = true];
 2094|      1|      case 5:
  ------------------
  |  Branch (2094:7): [True: 1, False: 2]
  ------------------
 2095|      1|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 40)) {
  ------------------
  |  |  236|      1|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 2096|      1|          _Internal::set_has_escape_whitespaces(&has_bits);
 2097|      1|          escape_whitespaces_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2098|      1|          CHK_(ptr);
  ------------------
  |  | 2054|      1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2099|      1|        } else goto handle_unusual;
 2100|      1|        continue;
 2101|       |      // optional string normalization_rule_tsv = 6;
 2102|      1|      case 6:
  ------------------
  |  Branch (2102:7): [True: 0, False: 3]
  ------------------
 2103|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2104|      0|          auto str = _internal_mutable_normalization_rule_tsv();
 2105|      0|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2106|      0|          CHK_(ptr);
  ------------------
  |  | 2054|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2107|      0|        } else goto handle_unusual;
 2108|      0|        continue;
 2109|      0|      default: {
  ------------------
  |  Branch (2109:7): [True: 0, False: 3]
  ------------------
 2110|      0|      handle_unusual:
 2111|      0|        if ((tag & 7) == 4 || tag == 0) {
  ------------------
  |  Branch (2111:13): [True: 0, False: 0]
  |  Branch (2111:31): [True: 0, False: 0]
  ------------------
 2112|      0|          ctx->SetLastTag(tag);
 2113|      0|          goto success;
 2114|      0|        }
 2115|      0|      if ((1600u <= tag)) {
  ------------------
  |  Branch (2115:11): [True: 0, False: 0]
  ------------------
 2116|      0|        ptr = _extensions_.ParseField(tag, ptr,
 2117|      0|            internal_default_instance(), &_internal_metadata_, ctx);
 2118|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 2054|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2119|      0|        continue;
 2120|      0|      }
 2121|      0|        ptr = UnknownFieldParse(tag,
 2122|      0|            _internal_metadata_.mutable_unknown_fields<std::string>(),
 2123|      0|            ptr, ctx);
 2124|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 2054|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2125|      0|        continue;
 2126|      0|      }
 2127|      3|    }  // switch
 2128|      3|  }  // while
 2129|      1|success:
 2130|      1|  _has_bits_.Or(has_bits);
 2131|      1|  return ptr;
 2132|      0|failure:
 2133|      0|  ptr = nullptr;
 2134|      0|  goto success;
 2135|      1|#undef CHK_
 2136|      1|}
_ZNK13sentencepiece14NormalizerSpec13IsInitializedEv:
 2295|      1|bool NormalizerSpec::IsInitialized() const {
 2296|      1|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (2296:7): [True: 0, False: 1]
  ------------------
 2297|      0|    return false;
 2298|      0|  }
 2299|       |
 2300|      1|  return true;
 2301|      1|}
_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|    299|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 2786|    299|  _extensions_(arena) {
 2787|    299|  SharedCtor();
 2788|    299|  RegisterArenaDtor(arena);
 2789|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.ModelProto.SentencePiece)
 2790|    299|}
_ZN13sentencepiece24ModelProto_SentencePiece14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE:
 2859|    298|const char* ModelProto_SentencePiece::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 2860|    298|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 2861|    298|  _Internal::HasBits has_bits{};
 2862|  1.15k|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (2862:10): [True: 855, False: 298]
  ------------------
 2863|    855|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 2864|    855|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 2865|    855|    CHK_(ptr);
  ------------------
  |  | 2860|    855|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    855|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 855]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2866|    855|    switch (tag >> 3) {
 2867|       |      // optional string piece = 1;
 2868|    298|      case 1:
  ------------------
  |  Branch (2868:7): [True: 298, False: 557]
  ------------------
 2869|    298|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
  ------------------
  |  |  236|    298|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 298, False: 0]
  |  |  ------------------
  ------------------
 2870|    298|          auto str = _internal_mutable_piece();
 2871|    298|          ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
 2872|    298|          CHK_(ptr);
  ------------------
  |  | 2860|    298|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    298|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 298]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2873|    298|        } else goto handle_unusual;
 2874|    298|        continue;
 2875|       |      // optional float score = 2;
 2876|    298|      case 2:
  ------------------
  |  Branch (2876:7): [True: 298, False: 557]
  ------------------
 2877|    298|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 21)) {
  ------------------
  |  |  236|    298|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 298, False: 0]
  |  |  ------------------
  ------------------
 2878|    298|          _Internal::set_has_score(&has_bits);
 2879|    298|          score_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
 2880|    298|          ptr += sizeof(float);
 2881|    298|        } else goto handle_unusual;
 2882|    298|        continue;
 2883|       |      // optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
 2884|    298|      case 3:
  ------------------
  |  Branch (2884:7): [True: 259, False: 596]
  ------------------
 2885|    259|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 24)) {
  ------------------
  |  |  236|    259|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 259, False: 0]
  |  |  ------------------
  ------------------
 2886|    259|          ::PROTOBUF_NAMESPACE_ID::uint64 val = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
 2887|    259|          CHK_(ptr);
  ------------------
  |  | 2860|    259|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    259|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 259]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2888|    259|          if (PROTOBUF_PREDICT_TRUE(::sentencepiece::ModelProto_SentencePiece_Type_IsValid(val))) {
  ------------------
  |  |  236|    259|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 259, False: 0]
  |  |  ------------------
  ------------------
 2889|    259|            _internal_set_type(static_cast<::sentencepiece::ModelProto_SentencePiece_Type>(val));
 2890|    259|          } else {
 2891|      0|            ::PROTOBUF_NAMESPACE_ID::internal::WriteVarint(3, val, mutable_unknown_fields());
 2892|      0|          }
 2893|    259|        } else goto handle_unusual;
 2894|    259|        continue;
 2895|    259|      default: {
  ------------------
  |  Branch (2895:7): [True: 0, False: 855]
  ------------------
 2896|      0|      handle_unusual:
 2897|      0|        if ((tag & 7) == 4 || tag == 0) {
  ------------------
  |  Branch (2897:13): [True: 0, False: 0]
  |  Branch (2897:31): [True: 0, False: 0]
  ------------------
 2898|      0|          ctx->SetLastTag(tag);
 2899|      0|          goto success;
 2900|      0|        }
 2901|      0|      if ((1600u <= tag)) {
  ------------------
  |  Branch (2901:11): [True: 0, False: 0]
  ------------------
 2902|      0|        ptr = _extensions_.ParseField(tag, ptr,
 2903|      0|            internal_default_instance(), &_internal_metadata_, ctx);
 2904|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 2860|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2905|      0|        continue;
 2906|      0|      }
 2907|      0|        ptr = UnknownFieldParse(tag,
 2908|      0|            _internal_metadata_.mutable_unknown_fields<std::string>(),
 2909|      0|            ptr, ctx);
 2910|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 2860|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 2911|      0|        continue;
 2912|      0|      }
 2913|    855|    }  // switch
 2914|    855|  }  // while
 2915|    298|success:
 2916|    298|  _has_bits_.Or(has_bits);
 2917|    298|  return ptr;
 2918|      0|failure:
 2919|      0|  ptr = nullptr;
 2920|      0|  goto success;
 2921|    298|#undef CHK_
 2922|    298|}
_ZNK13sentencepiece24ModelProto_SentencePiece13IsInitializedEv:
 3037|    298|bool ModelProto_SentencePiece::IsInitialized() const {
 3038|    298|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (3038:7): [True: 0, False: 298]
  ------------------
 3039|      0|    return false;
 3040|      0|  }
 3041|       |
 3042|    298|  return true;
 3043|    298|}
_ZN13sentencepiece10ModelProtoC2EPN6google8protobuf5ArenaE:
 3100|      2|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
 3101|      2|  _extensions_(arena),
 3102|      2|  pieces_(arena) {
 3103|      2|  SharedCtor();
 3104|      2|  RegisterArenaDtor(arena);
 3105|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.ModelProto)
 3106|      2|}
_ZN13sentencepiece10ModelProto5ClearEv:
 3173|      1|void ModelProto::Clear() {
 3174|       |// @@protoc_insertion_point(message_clear_start:sentencepiece.ModelProto)
 3175|      1|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
 3176|       |  // Prevent compiler warnings about cached_has_bits being unused
 3177|      1|  (void) cached_has_bits;
 3178|       |
 3179|      1|  _extensions_.Clear();
 3180|      1|  pieces_.Clear();
 3181|      1|  cached_has_bits = _has_bits_[0];
 3182|      1|  if (cached_has_bits & 0x0000000fu) {
  ------------------
  |  Branch (3182:7): [True: 0, False: 1]
  ------------------
 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|      1|  _has_bits_.Clear();
 3201|      1|  _internal_metadata_.Clear<std::string>();
 3202|      1|}
_ZN13sentencepiece10ModelProto14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE:
 3204|      1|const char* ModelProto::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
 3205|      1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
 3206|      1|  _Internal::HasBits has_bits{};
 3207|      4|  while (!ctx->Done(&ptr)) {
  ------------------
  |  Branch (3207:10): [True: 3, False: 1]
  ------------------
 3208|      3|    ::PROTOBUF_NAMESPACE_ID::uint32 tag;
 3209|      3|    ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
 3210|      3|    CHK_(ptr);
  ------------------
  |  | 3205|      3|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      3|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 3]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3211|      3|    switch (tag >> 3) {
 3212|       |      // repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
 3213|      1|      case 1:
  ------------------
  |  Branch (3213:7): [True: 1, False: 2]
  ------------------
 3214|      1|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) {
  ------------------
  |  |  236|      1|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 3215|      1|          ptr -= 1;
 3216|    298|          do {
 3217|    298|            ptr += 1;
 3218|    298|            ptr = ctx->ParseMessage(_internal_add_pieces(), ptr);
 3219|    298|            CHK_(ptr);
  ------------------
  |  | 3205|    298|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|    298|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 298]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3220|    298|            if (!ctx->DataAvailable(ptr)) break;
  ------------------
  |  Branch (3220:17): [True: 0, False: 298]
  ------------------
 3221|    298|          } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr));
  ------------------
  |  Branch (3221:20): [True: 297, False: 1]
  ------------------
 3222|      1|        } else goto handle_unusual;
 3223|      1|        continue;
 3224|       |      // optional .sentencepiece.TrainerSpec trainer_spec = 2;
 3225|      1|      case 2:
  ------------------
  |  Branch (3225:7): [True: 1, False: 2]
  ------------------
 3226|      1|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) {
  ------------------
  |  |  236|      1|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 3227|      1|          ptr = ctx->ParseMessage(_internal_mutable_trainer_spec(), ptr);
 3228|      1|          CHK_(ptr);
  ------------------
  |  | 3205|      1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3229|      1|        } else goto handle_unusual;
 3230|      1|        continue;
 3231|       |      // optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
 3232|      1|      case 3:
  ------------------
  |  Branch (3232:7): [True: 1, False: 2]
  ------------------
 3233|      1|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) {
  ------------------
  |  |  236|      1|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 3234|      1|          ptr = ctx->ParseMessage(_internal_mutable_normalizer_spec(), ptr);
 3235|      1|          CHK_(ptr);
  ------------------
  |  | 3205|      1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3236|      1|        } else goto handle_unusual;
 3237|      1|        continue;
 3238|       |      // optional .sentencepiece.SelfTestData self_test_data = 4;
 3239|      1|      case 4:
  ------------------
  |  Branch (3239:7): [True: 0, False: 3]
  ------------------
 3240|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3241|      0|          ptr = ctx->ParseMessage(_internal_mutable_self_test_data(), ptr);
 3242|      0|          CHK_(ptr);
  ------------------
  |  | 3205|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3243|      0|        } else goto handle_unusual;
 3244|      0|        continue;
 3245|       |      // optional .sentencepiece.NormalizerSpec denormalizer_spec = 5;
 3246|      0|      case 5:
  ------------------
  |  Branch (3246:7): [True: 0, False: 3]
  ------------------
 3247|      0|        if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) {
  ------------------
  |  |  236|      0|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3248|      0|          ptr = ctx->ParseMessage(_internal_mutable_denormalizer_spec(), ptr);
 3249|      0|          CHK_(ptr);
  ------------------
  |  | 3205|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3250|      0|        } else goto handle_unusual;
 3251|      0|        continue;
 3252|      0|      default: {
  ------------------
  |  Branch (3252:7): [True: 0, False: 3]
  ------------------
 3253|      0|      handle_unusual:
 3254|      0|        if ((tag & 7) == 4 || tag == 0) {
  ------------------
  |  Branch (3254:13): [True: 0, False: 0]
  |  Branch (3254:31): [True: 0, False: 0]
  ------------------
 3255|      0|          ctx->SetLastTag(tag);
 3256|      0|          goto success;
 3257|      0|        }
 3258|      0|      if ((1600u <= tag)) {
  ------------------
  |  Branch (3258:11): [True: 0, False: 0]
  ------------------
 3259|      0|        ptr = _extensions_.ParseField(tag, ptr,
 3260|      0|            internal_default_instance(), &_internal_metadata_, ctx);
 3261|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 3205|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3262|      0|        continue;
 3263|      0|      }
 3264|      0|        ptr = UnknownFieldParse(tag,
 3265|      0|            _internal_metadata_.mutable_unknown_fields<std::string>(),
 3266|      0|            ptr, ctx);
 3267|      0|        CHK_(ptr != nullptr);
  ------------------
  |  | 3205|      0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
  |  |  ------------------
  |  |  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 3268|      0|        continue;
 3269|      0|      }
 3270|      3|    }  // switch
 3271|      3|  }  // while
 3272|      1|success:
 3273|      1|  _has_bits_.Or(has_bits);
 3274|      1|  return ptr;
 3275|      0|failure:
 3276|      0|  ptr = nullptr;
 3277|      0|  goto success;
 3278|      1|#undef CHK_
 3279|      1|}
_ZNK13sentencepiece10ModelProto13IsInitializedEv:
 3435|      1|bool ModelProto::IsInitialized() const {
 3436|      1|  if (!_extensions_.IsInitialized()) {
  ------------------
  |  Branch (3436:7): [True: 0, False: 1]
  ------------------
 3437|      0|    return false;
 3438|      0|  }
 3439|       |
 3440|      1|  if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(pieces_)) return false;
  ------------------
  |  Branch (3440:7): [True: 0, False: 1]
  ------------------
 3441|      1|  if (_internal_has_trainer_spec()) {
  ------------------
  |  Branch (3441:7): [True: 1, False: 0]
  ------------------
 3442|      1|    if (!trainer_spec_->IsInitialized()) return false;
  ------------------
  |  Branch (3442:9): [True: 0, False: 1]
  ------------------
 3443|      1|  }
 3444|      1|  if (_internal_has_normalizer_spec()) {
  ------------------
  |  Branch (3444:7): [True: 1, False: 0]
  ------------------
 3445|      1|    if (!normalizer_spec_->IsInitialized()) return false;
  ------------------
  |  Branch (3445:9): [True: 0, False: 1]
  ------------------
 3446|      1|  }
 3447|      1|  if (_internal_has_self_test_data()) {
  ------------------
  |  Branch (3447:7): [True: 0, False: 1]
  ------------------
 3448|      0|    if (!self_test_data_->IsInitialized()) return false;
  ------------------
  |  Branch (3448:9): [True: 0, False: 0]
  ------------------
 3449|      0|  }
 3450|      1|  if (_internal_has_denormalizer_spec()) {
  ------------------
  |  Branch (3450:7): [True: 0, False: 1]
  ------------------
 3451|      0|    if (!denormalizer_spec_->IsInitialized()) return false;
  ------------------
  |  Branch (3451:9): [True: 0, False: 0]
  ------------------
 3452|      0|  }
 3453|      1|  return true;
 3454|      1|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece11TrainerSpecEJEEEPT_PS1_DpOT0_:
 3478|      1|template<> PROTOBUF_NOINLINE ::sentencepiece::TrainerSpec* Arena::CreateMaybeMessage< ::sentencepiece::TrainerSpec >(Arena* arena) {
 3479|      1|  return Arena::CreateMessageInternal< ::sentencepiece::TrainerSpec >(arena);
 3480|      1|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece14NormalizerSpecEJEEEPT_PS1_DpOT0_:
 3481|      1|template<> PROTOBUF_NOINLINE ::sentencepiece::NormalizerSpec* Arena::CreateMaybeMessage< ::sentencepiece::NormalizerSpec >(Arena* arena) {
 3482|      1|  return Arena::CreateMessageInternal< ::sentencepiece::NormalizerSpec >(arena);
 3483|      1|}
_ZN6google8protobuf5Arena18CreateMaybeMessageIN13sentencepiece24ModelProto_SentencePieceEJEEEPT_PS1_DpOT0_:
 3490|    298|template<> PROTOBUF_NOINLINE ::sentencepiece::ModelProto_SentencePiece* Arena::CreateMaybeMessage< ::sentencepiece::ModelProto_SentencePiece >(Arena* arena) {
 3491|    298|  return Arena::CreateMessageInternal< ::sentencepiece::ModelProto_SentencePiece >(arena);
 3492|    298|}
sentencepiece_model.pb.cc:_ZL61InitDefaultsscc_info_ModelProto_sentencepiece_5fmodel_2eprotov:
   45|      1|static void InitDefaultsscc_info_ModelProto_sentencepiece_5fmodel_2eproto() {
   46|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   47|       |
   48|      1|  {
   49|      1|    void* ptr = &::sentencepiece::_ModelProto_default_instance_;
   50|      1|    new (ptr) ::sentencepiece::ModelProto();
   51|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   52|      1|  }
   53|      1|}
sentencepiece_model.pb.cc:_ZL75InitDefaultsscc_info_ModelProto_SentencePiece_sentencepiece_5fmodel_2eprotov:
   62|      1|static void InitDefaultsscc_info_ModelProto_SentencePiece_sentencepiece_5fmodel_2eproto() {
   63|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   64|       |
   65|      1|  {
   66|      1|    void* ptr = &::sentencepiece::_ModelProto_SentencePiece_default_instance_;
   67|      1|    new (ptr) ::sentencepiece::ModelProto_SentencePiece();
   68|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   69|      1|  }
   70|      1|}
sentencepiece_model.pb.cc:_ZL65InitDefaultsscc_info_NormalizerSpec_sentencepiece_5fmodel_2eprotov:
   75|      1|static void InitDefaultsscc_info_NormalizerSpec_sentencepiece_5fmodel_2eproto() {
   76|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   77|       |
   78|      1|  {
   79|      1|    void* ptr = &::sentencepiece::_NormalizerSpec_default_instance_;
   80|      1|    new (ptr) ::sentencepiece::NormalizerSpec();
   81|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   82|      1|  }
   83|      1|}
sentencepiece_model.pb.cc:_ZL63InitDefaultsscc_info_SelfTestData_sentencepiece_5fmodel_2eprotov:
   88|      1|static void InitDefaultsscc_info_SelfTestData_sentencepiece_5fmodel_2eproto() {
   89|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   90|       |
   91|      1|  {
   92|      1|    void* ptr = &::sentencepiece::_SelfTestData_default_instance_;
   93|      1|    new (ptr) ::sentencepiece::SelfTestData();
   94|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   95|      1|  }
   96|      1|}
sentencepiece_model.pb.cc:_ZL70InitDefaultsscc_info_SelfTestData_Sample_sentencepiece_5fmodel_2eprotov:
  102|      1|static void InitDefaultsscc_info_SelfTestData_Sample_sentencepiece_5fmodel_2eproto() {
  103|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
  104|       |
  105|      1|  {
  106|      1|    void* ptr = &::sentencepiece::_SelfTestData_Sample_default_instance_;
  107|      1|    new (ptr) ::sentencepiece::SelfTestData_Sample();
  108|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  109|      1|  }
  110|      1|}
sentencepiece_model.pb.cc:_ZL62InitDefaultsscc_info_TrainerSpec_sentencepiece_5fmodel_2eprotov:
  115|      1|static void InitDefaultsscc_info_TrainerSpec_sentencepiece_5fmodel_2eproto() {
  116|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
  117|       |
  118|      1|  {
  119|      1|    void* ptr = &::sentencepiece::_TrainerSpec_default_instance_;
  120|      1|    new (ptr) ::sentencepiece::TrainerSpec();
  121|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
  122|      1|  }
  123|      1|}
_ZN13sentencepiece11TrainerSpec10SharedCtorEv:
  490|      2|void TrainerSpec::SharedCtor() {
  491|      2|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_TrainerSpec_sentencepiece_5fmodel_2eproto.base);
  492|      2|  model_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  493|      2|  input_format_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  494|      2|  required_chars_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  495|      2|  unk_surface_.UnsafeSetDefault(nullptr);
  496|      2|  unk_piece_.UnsafeSetDefault(nullptr);
  497|      2|  bos_piece_.UnsafeSetDefault(nullptr);
  498|      2|  eos_piece_.UnsafeSetDefault(nullptr);
  499|      2|  pad_piece_.UnsafeSetDefault(nullptr);
  500|      2|  pretokenization_delimiter_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  501|      2|  seed_sentencepieces_file_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  502|      2|  ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
  503|      2|      reinterpret_cast<char*>(&self_test_sample_size_) - reinterpret_cast<char*>(this)),
  504|      2|      0, static_cast<size_t>(reinterpret_cast<char*>(&differential_privacy_clipping_threshold_) -
  505|      2|      reinterpret_cast<char*>(&self_test_sample_size_)) + sizeof(differential_privacy_clipping_threshold_));
  506|      2|  model_type_ = 1;
  507|      2|  vocab_size_ = 8000;
  508|      2|  character_coverage_ = 0.9995f;
  509|      2|  seed_sentencepiece_size_ = 1000000;
  510|      2|  shrinking_factor_ = 0.75f;
  511|      2|  num_threads_ = 16;
  512|      2|  num_sub_iterations_ = 2;
  513|      2|  max_sentence_length_ = 4192;
  514|      2|  max_sentencepiece_length_ = 16;
  515|      2|  shuffle_input_sentence_ = true;
  516|      2|  split_by_unicode_script_ = true;
  517|      2|  split_by_number_ = true;
  518|      2|  split_by_whitespace_ = true;
  519|      2|  vocabulary_output_piece_score_ = true;
  520|      2|  hard_vocab_limit_ = true;
  521|      2|  bos_id_ = 1;
  522|      2|  eos_id_ = 2;
  523|      2|  pad_id_ = -1;
  524|      2|}
_ZN13sentencepiece11TrainerSpec17RegisterArenaDtorEPN6google8protobuf5ArenaE:
  550|      2|void TrainerSpec::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  551|      2|}
_ZN13sentencepiece11TrainerSpec9_Internal18set_has_vocab_sizeEPN6google8protobuf8internal7HasBitsILm2EEE:
  290|      1|  static void set_has_vocab_size(HasBits* has_bits) {
  291|      1|    (*has_bits)[0] |= 33554432u;
  292|      1|  }
_ZN13sentencepiece11TrainerSpec9_Internal21set_has_byte_fallbackEPN6google8protobuf8internal7HasBitsILm2EEE:
  362|      1|  static void set_has_byte_fallback(HasBits* has_bits) {
  363|      1|    (*has_bits)[0] |= 262144u;
  364|      1|  }
_ZN13sentencepiece14NormalizerSpec10SharedCtorEv:
 1989|      2|void NormalizerSpec::SharedCtor() {
 1990|      2|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NormalizerSpec_sentencepiece_5fmodel_2eproto.base);
 1991|      2|  name_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1992|      2|  precompiled_charsmap_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1993|      2|  normalization_rule_tsv_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 1994|      2|  add_dummy_prefix_ = true;
 1995|      2|  remove_extra_whitespaces_ = true;
 1996|      2|  escape_whitespaces_ = true;
 1997|      2|}
_ZN13sentencepiece14NormalizerSpec17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2016|      2|void NormalizerSpec::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2017|      2|}
_ZN13sentencepiece14NormalizerSpec9_Internal24set_has_add_dummy_prefixEPN6google8protobuf8internal7HasBitsILm1EEE:
 1942|      1|  static void set_has_add_dummy_prefix(HasBits* has_bits) {
 1943|      1|    (*has_bits)[0] |= 8u;
 1944|      1|  }
_ZN13sentencepiece14NormalizerSpec9_Internal32set_has_remove_extra_whitespacesEPN6google8protobuf8internal7HasBitsILm1EEE:
 1945|      1|  static void set_has_remove_extra_whitespaces(HasBits* has_bits) {
 1946|      1|    (*has_bits)[0] |= 16u;
 1947|      1|  }
_ZN13sentencepiece14NormalizerSpec9_Internal26set_has_escape_whitespacesEPN6google8protobuf8internal7HasBitsILm1EEE:
 1948|      1|  static void set_has_escape_whitespaces(HasBits* has_bits) {
 1949|      1|    (*has_bits)[0] |= 32u;
 1950|      1|  }
_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|    299|void ModelProto_SentencePiece::SharedCtor() {
 2808|    299|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ModelProto_SentencePiece_sentencepiece_5fmodel_2eproto.base);
 2809|    299|  piece_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
 2810|    299|  score_ = 0;
 2811|    299|  type_ = 1;
 2812|    299|}
_ZN13sentencepiece24ModelProto_SentencePiece17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 2829|    299|void ModelProto_SentencePiece::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 2830|    299|}
_ZN13sentencepiece24ModelProto_SentencePiece9_Internal13set_has_scoreEPN6google8protobuf8internal7HasBitsILm1EEE:
 2776|    298|  static void set_has_score(HasBits* has_bits) {
 2777|    298|    (*has_bits)[0] |= 2u;
 2778|    298|  }
_ZN13sentencepiece10ModelProto10SharedCtorEv:
 3136|      2|void ModelProto::SharedCtor() {
 3137|      2|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_ModelProto_sentencepiece_5fmodel_2eproto.base);
 3138|      2|  ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
 3139|      2|      reinterpret_cast<char*>(&trainer_spec_) - reinterpret_cast<char*>(this)),
 3140|      2|      0, static_cast<size_t>(reinterpret_cast<char*>(&denormalizer_spec_) -
 3141|      2|      reinterpret_cast<char*>(&trainer_spec_)) + sizeof(denormalizer_spec_));
 3142|      2|}
_ZN13sentencepiece10ModelProto17RegisterArenaDtorEPN6google8protobuf5ArenaE:
 3162|      2|void ModelProto::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
 3163|      2|}

_ZNK13sentencepiece10ModelProto15normalizer_specEv:
 4771|      1|inline const ::sentencepiece::NormalizerSpec& ModelProto::normalizer_spec() const {
 4772|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.normalizer_spec)
 4773|      1|  return _internal_normalizer_spec();
 4774|      1|}
_ZNK13sentencepiece10ModelProto25_internal_normalizer_specEv:
 4766|      1|inline const ::sentencepiece::NormalizerSpec& ModelProto::_internal_normalizer_spec() const {
 4767|      1|  const ::sentencepiece::NormalizerSpec* p = normalizer_spec_;
 4768|      1|  return p != nullptr ? *p : reinterpret_cast<const ::sentencepiece::NormalizerSpec&>(
  ------------------
  |  Branch (4768:10): [True: 1, False: 0]
  ------------------
 4769|      0|      ::sentencepiece::_NormalizerSpec_default_instance_);
 4770|      1|}
_ZNK13sentencepiece10ModelProto12trainer_specEv:
 4688|    259|inline const ::sentencepiece::TrainerSpec& ModelProto::trainer_spec() const {
 4689|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.trainer_spec)
 4690|    259|  return _internal_trainer_spec();
 4691|    259|}
_ZNK13sentencepiece10ModelProto22_internal_trainer_specEv:
 4683|    259|inline const ::sentencepiece::TrainerSpec& ModelProto::_internal_trainer_spec() const {
 4684|    259|  const ::sentencepiece::TrainerSpec* p = trainer_spec_;
 4685|    259|  return p != nullptr ? *p : reinterpret_cast<const ::sentencepiece::TrainerSpec&>(
  ------------------
  |  Branch (4685:10): [True: 259, False: 0]
  ------------------
 4686|      0|      ::sentencepiece::_TrainerSpec_default_instance_);
 4687|    259|}
_ZNK13sentencepiece10ModelProto21has_denormalizer_specEv:
 4925|      1|inline bool ModelProto::has_denormalizer_spec() const {
 4926|      1|  return _internal_has_denormalizer_spec();
 4927|      1|}
_ZNK13sentencepiece10ModelProto31_internal_has_denormalizer_specEv:
 4920|      2|inline bool ModelProto::_internal_has_denormalizer_spec() const {
 4921|      2|  bool value = (_has_bits_[0] & 0x00000008u) != 0;
 4922|      2|  PROTOBUF_ASSUME(!value || denormalizer_spec_ != nullptr);
  ------------------
  |  |  493|      2|  GOOGLE_DCHECK(pred);               \
  |  |  ------------------
  |  |  |  |  181|      2|#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: 2]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  494|      2|  __builtin_assume(pred)
  |  |  ------------------
  |  |  |  Branch (494:20): [True: 2, False: 0]
  |  |  |  Branch (494:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 4923|      2|  return value;
 4924|      2|}
_ZNK13sentencepiece14NormalizerSpec20precompiled_charsmapEv:
 4082|      1|inline const std::string& NormalizerSpec::precompiled_charsmap() const {
 4083|       |  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.precompiled_charsmap)
 4084|      1|  return _internal_precompiled_charsmap();
 4085|      1|}
_ZNK13sentencepiece14NormalizerSpec30_internal_precompiled_charsmapEv:
 4094|      1|inline const std::string& NormalizerSpec::_internal_precompiled_charsmap() const {
 4095|      1|  return precompiled_charsmap_.Get();
 4096|      1|}
_ZNK13sentencepiece10ModelProto14self_test_dataEv:
 4854|      1|inline const ::sentencepiece::SelfTestData& ModelProto::self_test_data() const {
 4855|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.self_test_data)
 4856|      1|  return _internal_self_test_data();
 4857|      1|}
_ZNK13sentencepiece10ModelProto24_internal_self_test_dataEv:
 4849|      1|inline const ::sentencepiece::SelfTestData& ModelProto::_internal_self_test_data() const {
 4850|      1|  const ::sentencepiece::SelfTestData* p = self_test_data_;
 4851|      1|  return p != nullptr ? *p : reinterpret_cast<const ::sentencepiece::SelfTestData&>(
  ------------------
  |  Branch (4851:10): [True: 0, False: 1]
  ------------------
 4852|      1|      ::sentencepiece::_SelfTestData_default_instance_);
 4853|      1|}
_ZNK13sentencepiece12SelfTestData7samplesEv:
 4488|      1|SelfTestData::samples() const {
 4489|       |  // @@protoc_insertion_point(field_list:sentencepiece.SelfTestData.samples)
 4490|      1|  return samples_;
 4491|      1|}
_ZNK13sentencepiece11TrainerSpec10model_typeEv:
 2300|      1|inline ::sentencepiece::TrainerSpec_ModelType TrainerSpec::model_type() const {
 2301|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.model_type)
 2302|      1|  return _internal_model_type();
 2303|      1|}
_ZNK13sentencepiece11TrainerSpec20_internal_model_typeEv:
 2297|      1|inline ::sentencepiece::TrainerSpec_ModelType TrainerSpec::_internal_model_type() const {
 2298|      1|  return static_cast< ::sentencepiece::TrainerSpec_ModelType >(model_type_);
 2299|      1|}
_ZNK13sentencepiece10ModelProto11pieces_sizeEv:
 4635|    598|inline int ModelProto::pieces_size() const {
 4636|    598|  return _internal_pieces_size();
 4637|    598|}
_ZNK13sentencepiece10ModelProto21_internal_pieces_sizeEv:
 4632|    598|inline int ModelProto::_internal_pieces_size() const {
 4633|    598|  return pieces_.size();
 4634|    598|}
_ZNK13sentencepiece24ModelProto_SentencePiece4typeEv:
 4613|  2.82k|inline ::sentencepiece::ModelProto_SentencePiece_Type ModelProto_SentencePiece::type() const {
 4614|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.type)
 4615|  2.82k|  return _internal_type();
 4616|  2.82k|}
_ZNK13sentencepiece24ModelProto_SentencePiece14_internal_typeEv:
 4610|  2.82k|inline ::sentencepiece::ModelProto_SentencePiece_Type ModelProto_SentencePiece::_internal_type() const {
 4611|  2.82k|  return static_cast< ::sentencepiece::ModelProto_SentencePiece_Type >(type_);
 4612|  2.82k|}
_ZNK13sentencepiece24ModelProto_SentencePiece5pieceEv:
 4509|  1.15k|inline const std::string& ModelProto_SentencePiece::piece() const {
 4510|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.piece)
 4511|  1.15k|  return _internal_piece();
 4512|  1.15k|}
_ZNK13sentencepiece24ModelProto_SentencePiece15_internal_pieceEv:
 4521|  1.15k|inline const std::string& ModelProto_SentencePiece::_internal_piece() const {
 4522|  1.15k|  return piece_.Get();
 4523|  1.15k|}
_ZN13sentencepiece24ModelProto_SentencePiece18_internal_set_typeENS_29ModelProto_SentencePiece_TypeE:
 4617|    259|inline void ModelProto_SentencePiece::_internal_set_type(::sentencepiece::ModelProto_SentencePiece_Type value) {
 4618|       |  assert(::sentencepiece::ModelProto_SentencePiece_Type_IsValid(value));
 4619|    259|  _has_bits_[0] |= 0x00000004u;
 4620|    259|  type_ = value;
 4621|    259|}
_ZN13sentencepiece10ModelProto33_internal_mutable_normalizer_specEv:
 4804|      1|inline ::sentencepiece::NormalizerSpec* ModelProto::_internal_mutable_normalizer_spec() {
 4805|      1|  _has_bits_[0] |= 0x00000002u;
 4806|      1|  if (normalizer_spec_ == nullptr) {
  ------------------
  |  Branch (4806:7): [True: 1, False: 0]
  ------------------
 4807|      1|    auto* p = CreateMaybeMessage<::sentencepiece::NormalizerSpec>(GetArena());
 4808|      1|    normalizer_spec_ = p;
 4809|      1|  }
 4810|      1|  return normalizer_spec_;
 4811|      1|}
_ZN13sentencepiece10ModelProtoC2Ev:
 1836|      2|  inline ModelProto() : ModelProto(nullptr) {}
_ZN13sentencepiece11TrainerSpecC2Ev:
  133|      2|  inline TrainerSpec() : TrainerSpec(nullptr) {}
_ZN13sentencepiece14NormalizerSpecC2Ev:
 1093|      2|  inline NormalizerSpec() : NormalizerSpec(nullptr) {}
_ZN13sentencepiece19SelfTestData_SampleC2Ev:
 1325|      1|  inline SelfTestData_Sample() : SelfTestData_Sample(nullptr) {}
_ZN13sentencepiece12SelfTestDataC2Ev:
 1487|      1|  inline SelfTestData() : SelfTestData(nullptr) {}
_ZN13sentencepiece24ModelProto_SentencePieceC2Ev:
 1629|    299|  inline ModelProto_SentencePiece() : ModelProto_SentencePiece(nullptr) {}
_ZN13sentencepiece11TrainerSpec24_internal_set_model_typeENS_21TrainerSpec_ModelTypeE:
 2304|      1|inline void TrainerSpec::_internal_set_model_type(::sentencepiece::TrainerSpec_ModelType value) {
 2305|       |  assert(::sentencepiece::TrainerSpec_ModelType_IsValid(value));
 2306|      1|  _has_bits_[0] |= 0x01000000u;
 2307|      1|  model_type_ = value;
 2308|      1|}
_ZNK13sentencepiece11TrainerSpec36_internal_treat_whitespace_as_suffixEv:
 2932|      1|inline bool TrainerSpec::_internal_treat_whitespace_as_suffix() const {
 2933|      1|  return treat_whitespace_as_suffix_;
 2934|      1|}
_ZNK13sentencepiece11TrainerSpec26treat_whitespace_as_suffixEv:
 2935|      1|inline bool TrainerSpec::treat_whitespace_as_suffix() const {
 2936|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.treat_whitespace_as_suffix)
 2937|      1|  return _internal_treat_whitespace_as_suffix();
 2938|      1|}
_ZNK13sentencepiece11TrainerSpec23_internal_byte_fallbackEv:
 3310|    257|inline bool TrainerSpec::_internal_byte_fallback() const {
 3311|    257|  return byte_fallback_;
 3312|    257|}
_ZNK13sentencepiece11TrainerSpec13byte_fallbackEv:
 3313|    257|inline bool TrainerSpec::byte_fallback() const {
 3314|       |  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.byte_fallback)
 3315|    257|  return _internal_byte_fallback();
 3316|    257|}
_ZN13sentencepiece24ModelProto_SentencePiece23_internal_mutable_pieceEv:
 4547|    298|inline std::string* ModelProto_SentencePiece::_internal_mutable_piece() {
 4548|    298|  _has_bits_[0] |= 0x00000001u;
 4549|    298|  return piece_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
 4550|    298|}
_ZNK13sentencepiece24ModelProto_SentencePiece15_internal_scoreEv:
 4582|     39|inline float ModelProto_SentencePiece::_internal_score() const {
 4583|     39|  return score_;
 4584|     39|}
_ZNK13sentencepiece24ModelProto_SentencePiece5scoreEv:
 4585|     39|inline float ModelProto_SentencePiece::score() const {
 4586|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.score)
 4587|     39|  return _internal_score();
 4588|     39|}
_ZNK13sentencepiece10ModelProto16_internal_piecesEi:
 4650|    596|inline const ::sentencepiece::ModelProto_SentencePiece& ModelProto::_internal_pieces(int index) const {
 4651|    596|  return pieces_.Get(index);
 4652|    596|}
_ZNK13sentencepiece10ModelProto6piecesEi:
 4653|    596|inline const ::sentencepiece::ModelProto_SentencePiece& ModelProto::pieces(int index) const {
 4654|       |  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.pieces)
 4655|    596|  return _internal_pieces(index);
 4656|    596|}
_ZN13sentencepiece10ModelProto20_internal_add_piecesEv:
 4657|    298|inline ::sentencepiece::ModelProto_SentencePiece* ModelProto::_internal_add_pieces() {
 4658|    298|  return pieces_.Add();
 4659|    298|}
_ZNK13sentencepiece10ModelProto6piecesEv:
 4665|      1|ModelProto::pieces() const {
 4666|       |  // @@protoc_insertion_point(field_list:sentencepiece.ModelProto.pieces)
 4667|      1|  return pieces_;
 4668|      1|}
_ZNK13sentencepiece10ModelProto26_internal_has_trainer_specEv:
 4671|      1|inline bool ModelProto::_internal_has_trainer_spec() const {
 4672|      1|  bool value = (_has_bits_[0] & 0x00000001u) != 0;
 4673|      1|  PROTOBUF_ASSUME(!value || trainer_spec_ != nullptr);
  ------------------
  |  |  493|      1|  GOOGLE_DCHECK(pred);               \
  |  |  ------------------
  |  |  |  |  181|      1|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  494|      2|  __builtin_assume(pred)
  |  |  ------------------
  |  |  |  Branch (494:20): [True: 0, False: 1]
  |  |  |  Branch (494:20): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 4674|      1|  return value;
 4675|      1|}
_ZN13sentencepiece10ModelProto30_internal_mutable_trainer_specEv:
 4721|      1|inline ::sentencepiece::TrainerSpec* ModelProto::_internal_mutable_trainer_spec() {
 4722|      1|  _has_bits_[0] |= 0x00000001u;
 4723|      1|  if (trainer_spec_ == nullptr) {
  ------------------
  |  Branch (4723:7): [True: 1, False: 0]
  ------------------
 4724|      1|    auto* p = CreateMaybeMessage<::sentencepiece::TrainerSpec>(GetArena());
 4725|      1|    trainer_spec_ = p;
 4726|      1|  }
 4727|      1|  return trainer_spec_;
 4728|      1|}
_ZNK13sentencepiece10ModelProto29_internal_has_normalizer_specEv:
 4754|      1|inline bool ModelProto::_internal_has_normalizer_spec() const {
 4755|      1|  bool value = (_has_bits_[0] & 0x00000002u) != 0;
 4756|      1|  PROTOBUF_ASSUME(!value || normalizer_spec_ != nullptr);
  ------------------
  |  |  493|      1|  GOOGLE_DCHECK(pred);               \
  |  |  ------------------
  |  |  |  |  181|      1|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  494|      2|  __builtin_assume(pred)
  |  |  ------------------
  |  |  |  Branch (494:20): [True: 0, False: 1]
  |  |  |  Branch (494:20): [True: 1, False: 0]
  |  |  ------------------
  ------------------
 4757|      1|  return value;
 4758|      1|}
_ZNK13sentencepiece10ModelProto28_internal_has_self_test_dataEv:
 4837|      1|inline bool ModelProto::_internal_has_self_test_data() const {
 4838|      1|  bool value = (_has_bits_[0] & 0x00000004u) != 0;
 4839|      1|  PROTOBUF_ASSUME(!value || self_test_data_ != nullptr);
  ------------------
  |  |  493|      1|  GOOGLE_DCHECK(pred);               \
  |  |  ------------------
  |  |  |  |  181|      1|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  494|      1|  __builtin_assume(pred)
  |  |  ------------------
  |  |  |  Branch (494:20): [True: 1, False: 0]
  |  |  |  Branch (494:20): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 4840|      1|  return value;
 4841|      1|}

_ZN13sentencepiece4util6StatusC2Ev:
   23|      4|Status::Status() {}
_ZN13sentencepiece4util6StatusD2Ev:
   24|      5|Status::~Status() {}
_ZN13sentencepiece4util6StatusC2ERKS1_:
   38|      3|    : rep_((s.rep_ == nullptr) ? nullptr : new Rep(*s.rep_)) {}
  ------------------
  |  Branch (38:12): [True: 3, False: 0]
  ------------------

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

_ZN13sentencepiece14ModelInterface16InitializePiecesEv:
   61|      1|void ModelInterface::InitializePieces() {
   62|      1|  pieces_.clear();
   63|      1|  reserved_id_map_.clear();
   64|      1|  unk_id_ = -1;
   65|       |
   66|      1|  std::set<absl::string_view> user_defined_symbols;
   67|      1|  std::vector<bool> byte_found(256, false);
   68|       |
   69|      1|  int pieces_size = 0;
   70|      1|  int reserved_id_map_size = 0;
   71|    299|  for (int i = 0; i < model_proto_->pieces_size(); ++i) {
  ------------------
  |  Branch (71:19): [True: 298, False: 1]
  ------------------
   72|    298|    const auto &sp = model_proto_->pieces(i);
   73|    298|    const bool is_normal_piece =
   74|    298|        (sp.type() == ModelProto::SentencePiece::NORMAL ||
  ------------------
  |  Branch (74:10): [True: 39, False: 259]
  ------------------
   75|    259|         sp.type() == ModelProto::SentencePiece::USER_DEFINED ||
  ------------------
  |  Branch (75:10): [True: 0, False: 259]
  ------------------
   76|    259|         sp.type() == ModelProto::SentencePiece::UNUSED);
  ------------------
  |  Branch (76:10): [True: 0, False: 259]
  ------------------
   77|    298|    if (is_normal_piece) {
  ------------------
  |  Branch (77:9): [True: 39, False: 259]
  ------------------
   78|     39|      ++pieces_size;
   79|    259|    } else {
   80|    259|      ++reserved_id_map_size;
   81|    259|    }
   82|    298|  }
   83|      1|  pieces_.reserve(pieces_size);
   84|      1|  reserved_id_map_.reserve(reserved_id_map_size);
   85|       |
   86|    299|  for (int i = 0; i < model_proto_->pieces_size(); ++i) {
  ------------------
  |  Branch (86:19): [True: 298, False: 1]
  ------------------
   87|    298|    const auto &sp = model_proto_->pieces(i);
   88|    298|    if (sp.piece().empty()) {
  ------------------
  |  Branch (88:9): [True: 0, False: 298]
  ------------------
   89|      0|      status_ = util::InternalError("piece must not be empty.");
   90|      0|      return;
   91|      0|    }
   92|    298|    if (sp.piece().find('\0') != absl::string_view::npos) {
  ------------------
  |  Branch (92:9): [True: 0, False: 298]
  ------------------
   93|      0|      status_ = util::InternalError("piece must not include null character.");
   94|      0|      return;
   95|      0|    }
   96|    298|    const bool is_normal_piece =
   97|    298|        (sp.type() == ModelProto::SentencePiece::NORMAL ||
  ------------------
  |  Branch (97:10): [True: 39, False: 259]
  ------------------
   98|    259|         sp.type() == ModelProto::SentencePiece::USER_DEFINED ||
  ------------------
  |  Branch (98:10): [True: 0, False: 259]
  ------------------
   99|    259|         sp.type() == ModelProto::SentencePiece::UNUSED);
  ------------------
  |  Branch (99:10): [True: 0, False: 259]
  ------------------
  100|    298|    if (!port::InsertIfNotPresent(
  ------------------
  |  Branch (100:9): [True: 0, False: 298]
  ------------------
  101|    298|            is_normal_piece ? &pieces_ : &reserved_id_map_, sp.piece(), i)) {
  ------------------
  |  Branch (101:13): [True: 39, False: 259]
  ------------------
  102|      0|      status_ = util::InternalError(sp.piece() + " is already defined.");
  103|      0|      return;
  104|      0|    }
  105|       |
  106|    298|    if (sp.type() == ModelProto::SentencePiece::USER_DEFINED) {
  ------------------
  |  Branch (106:9): [True: 0, False: 298]
  ------------------
  107|      0|      user_defined_symbols.insert(sp.piece());
  108|      0|    }
  109|       |
  110|    298|    if (sp.type() == ModelProto::SentencePiece::UNKNOWN) {
  ------------------
  |  Branch (110:9): [True: 1, False: 297]
  ------------------
  111|      1|      if (unk_id_ >= 0) {
  ------------------
  |  Branch (111:11): [True: 0, False: 1]
  ------------------
  112|      0|        status_ = util::InternalError("unk is already defined.");
  113|      0|        return;
  114|      0|      }
  115|      1|      unk_id_ = i;
  116|      1|    }
  117|       |
  118|    298|    if (sp.type() == ModelProto::SentencePiece::BYTE) {
  ------------------
  |  Branch (118:9): [True: 256, False: 42]
  ------------------
  119|    256|      if (!model_proto_->trainer_spec().byte_fallback()) {
  ------------------
  |  Branch (119:11): [True: 0, False: 256]
  ------------------
  120|      0|        status_ =
  121|      0|            util::InternalError("byte piece " + sp.piece() +
  122|      0|                                " is found although `byte_fallback` is false.");
  123|      0|        return;
  124|      0|      }
  125|    256|      const int byte = PieceToByte(sp.piece());
  126|    256|      if (0 <= byte && byte < 256) {
  ------------------
  |  Branch (126:11): [True: 256, False: 0]
  |  Branch (126:24): [True: 256, False: 0]
  ------------------
  127|    256|        byte_found[byte] = true;
  128|    256|      } else {
  129|      0|        status_ =
  130|      0|            util::InternalError("byte piece " + sp.piece() + " is invalid.");
  131|      0|        return;
  132|      0|      }
  133|    256|    }
  134|    298|  }
  135|       |
  136|      1|  if (unk_id_ == -1) {
  ------------------
  |  Branch (136:7): [True: 0, False: 1]
  ------------------
  137|      0|    status_ = util::InternalError("unk is not defined.");
  138|      0|    return;
  139|      0|  }
  140|       |
  141|      1|  if (model_proto_->trainer_spec().byte_fallback()) {
  ------------------
  |  Branch (141:7): [True: 1, False: 0]
  ------------------
  142|       |    // Checks that there are 256 byte pieces.
  143|      1|    if (std::find(byte_found.begin(), byte_found.end(), false) !=
  ------------------
  |  Branch (143:9): [True: 0, False: 1]
  ------------------
  144|      1|        byte_found.end()) {
  145|      0|      status_ = util::InternalError(
  146|      0|          "there are not 256 byte pieces although `byte_fallback` is true.");
  147|      0|      return;
  148|      0|    }
  149|      1|  }
  150|       |
  151|      1|  matcher_ = std::make_unique<normalizer::PrefixMatcher>(user_defined_symbols);
  152|      1|}
_ZN13sentencepiece11ByteToPieceEh:
  211|    256|std::string ByteToPiece(unsigned char c) {
  212|    256|  return absl::StrFormat("<0x%02X>", c);
  213|    256|}
_ZN13sentencepiece11PieceToByteENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEE:
  215|    256|int PieceToByte(absl::string_view piece) {
  216|    256|  using PieceToByteMap = absl::flat_hash_map<std::string, unsigned char>;
  217|    256|  static const auto *const kMap = []() -> PieceToByteMap * {
  218|    256|    auto *m = new PieceToByteMap();
  219|    256|    for (int i = 0; i < 256; ++i) {
  220|    256|      (*m)[ByteToPiece(i)] = i;
  221|    256|    }
  222|    256|    return m;
  223|    256|  }();
  224|       |
  225|    256|  if (const auto it = kMap->find(piece); it != kMap->end()) {
  ------------------
  |  Branch (225:42): [True: 256, False: 0]
  ------------------
  226|    256|    return it->second;
  227|    256|  }
  228|       |
  229|      0|  return -1;
  230|    256|}
model_interface.cc:_ZZN13sentencepiece11PieceToByteENSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEENK3$_0clEv:
  217|      1|  static const auto *const kMap = []() -> PieceToByteMap * {
  218|      1|    auto *m = new PieceToByteMap();
  219|    257|    for (int i = 0; i < 256; ++i) {
  ------------------
  |  Branch (219:21): [True: 256, False: 1]
  ------------------
  220|    256|      (*m)[ByteToPiece(i)] = i;
  221|    256|    }
  222|      1|    return m;
  223|      1|  }();

_ZN13sentencepiece14ModelInterfaceC2Ev:
   65|      1|  ModelInterface() {}
_ZNK13sentencepiece14ModelInterface6statusEv:
   71|      2|  virtual util::Status status() const { return status_; }
_ZNK13sentencepiece14ModelInterface14prefix_matcherEv:
   75|      1|  virtual const normalizer::PrefixMatcher *prefix_matcher() const {
   76|      1|    return matcher_.get();
   77|      1|  }

_ZN13sentencepiece10normalizer10NormalizerC2ERKNS_14NormalizerSpecERKNS_11TrainerSpecE:
   35|      1|    : spec_(&spec),
   36|      1|      treat_whitespace_as_suffix_(trainer_spec.treat_whitespace_as_suffix()),
   37|      1|      status_(util::OkStatus()) {
   38|      1|  Init();
   39|      1|}
_ZN13sentencepiece10normalizer10Normalizer4InitEv:
   48|      1|void Normalizer::Init() {
   49|      1|  absl::string_view index = spec_->precompiled_charsmap();
   50|       |
   51|      1|  if (!index.empty()) {
  ------------------
  |  Branch (51:7): [True: 0, False: 1]
  ------------------
   52|      0|    absl::string_view trie_blob;
   53|      0|    status_ = DecodePrecompiledCharsMap(index, &trie_blob, &normalized_,
   54|      0|                                        &precompiled_charsmap_buffer_);
   55|       |
   56|      0|    if (!status_.ok()) return;
  ------------------
  |  Branch (56:9): [True: 0, False: 0]
  ------------------
   57|       |
   58|       |    // Reads the body of double array.
   59|      0|    trie_ = std::make_unique<Darts::DoubleArray>();
   60|       |
   61|       |    // The second arg of set_array is not the size of blob,
   62|       |    // but the number of double array units.
   63|      0|    trie_->set_array(const_cast<char *>(trie_blob.data()),
   64|      0|                     trie_blob.size() / trie_->unit_size());
   65|       |
   66|      0|    if (!trie_->validate()) {
  ------------------
  |  Branch (66:9): [True: 0, False: 0]
  ------------------
   67|      0|      status_ = util::InternalError(
   68|      0|          "Trie data contains out-of-bounds node references.");
   69|      0|      return;
   70|      0|    }
   71|      0|  }
   72|      1|}
_ZN13sentencepiece10normalizer13PrefixMatcherC2ERKNSt3__13setINS2_17basic_string_viewIcNS2_11char_traitsIcEEEENS2_4lessIS7_EENS2_9allocatorIS7_EEEE:
  319|      1|PrefixMatcher::PrefixMatcher(const std::set<absl::string_view> &dic) {
  320|      1|  if (dic.empty()) return;
  ------------------
  |  Branch (320:7): [True: 1, False: 0]
  ------------------
  321|      0|  std::vector<const char *> key;
  322|      0|  std::vector<size_t> lengths;
  323|      0|  key.reserve(dic.size());
  324|      0|  lengths.reserve(dic.size());
  325|      0|  for (const auto &it : dic) {
  ------------------
  |  Branch (325:23): [True: 0, False: 0]
  ------------------
  326|      0|    key.push_back(it.data());
  327|      0|    lengths.push_back(it.size());
  328|      0|  }
  329|      0|  trie_ = std::make_unique<Darts::DoubleArray>();
  330|      0|  if (trie_->build(key.size(), const_cast<char **>(key.data()),
  ------------------
  |  Branch (330:7): [True: 0, False: 0]
  ------------------
  331|      0|                   const_cast<size_t *>(lengths.data()), nullptr) != 0) {
  332|      0|    LOG(ERROR) << "Failed to build the TRIE for PrefixMatcher";
  ------------------
  |  |  218|      0|#define LOG(severity) ABSL_LOG_INTERNAL_LOG_IMPL(_##severity)
  |  |  ------------------
  |  |  |  |   27|      0|  ABSL_LOG_INTERNAL_CONDITION##severity(STATELESS, true) \
  |  |  |  |  ------------------
  |  |  |  |  |  |  176|      0|  ABSL_LOG_INTERNAL_##type##_CONDITION(condition)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   65|      0|  switch (0)                                             \
  |  |  |  |  |  |  |  |   66|      0|  case 0:                                                \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (66:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   67|      0|  default:                                               \
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (67:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |   68|      0|    !(condition) ? (void)0 : ::absl::log_internal::Voidify() &&
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (68:5): [Folded, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |   28|      0|      ABSL_LOG_INTERNAL_LOG##severity.InternalStream()
  |  |  |  |  ------------------
  |  |  |  |  |  |   63|      0|  ::absl::log_internal::LogMessage( \
  |  |  |  |  |  |   64|      0|      __FILE__, __LINE__, ::absl::log_internal::LogMessage::ErrorTag{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  333|      0|    trie_.reset();
  334|      0|  }
  335|      0|}

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

_ZN13sentencepiece22SentencePieceProcessorC2Ev:
  228|      1|SentencePieceProcessor::SentencePieceProcessor() {}
_ZN13sentencepiece22SentencePieceProcessor23LoadFromSerializedProtoENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEE:
  248|      1|    absl::string_view serialized) {
  249|      1|  auto model_proto = std::make_unique<ModelProto>();
  250|      1|  RET_CHECK(model_proto->ParseFromArray(serialized.data(), serialized.size()));
  ------------------
  |  |  321|      1|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 1, False: 0]
  |  |  ------------------
  |  |  322|      1|  } else /* NOLINT */                                        \
  |  |  323|      1|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  251|      1|  return Load(std::move(model_proto));
  252|      1|}
_ZN13sentencepiece22SentencePieceProcessor4LoadENSt3__110unique_ptrINS_10ModelProtoENS1_14default_deleteIS3_EEEE:
  255|      1|    std::unique_ptr<ModelProto> model_proto) {
  256|      1|  model_proto_ = std::move(model_proto);
  257|      1|  model_ = ModelFactory::Create(*model_proto_);
  258|      1|  normalizer_ = std::make_unique<normalizer::Normalizer>(
  259|      1|      model_proto_->normalizer_spec(), model_proto_->trainer_spec());
  260|      1|  if (model_proto_->has_denormalizer_spec() &&
  ------------------
  |  Branch (260:7): [True: 0, False: 1]
  ------------------
  261|      0|      !model_proto_->denormalizer_spec().precompiled_charsmap().empty()) {
  ------------------
  |  Branch (261:7): [True: 0, False: 0]
  ------------------
  262|      0|    denormalizer_ = std::make_unique<normalizer::Normalizer>(
  263|      0|        model_proto_->denormalizer_spec());
  264|      0|  }
  265|       |
  266|       |  // Escapes user-defined-symbols in normalizer.
  267|      1|  normalizer_->SetPrefixMatcher(model_->prefix_matcher());
  268|       |
  269|      1|  RETURN_IF_ERROR(status());
  ------------------
  |  |   44|      1|  do {                                 \
  |  |   45|      1|    const auto _status = expr;         \
  |  |   46|      1|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   47|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  270|       |
  271|       |  // Running self-testing.
  272|      1|  std::vector<std::string> errors, sps;
  273|      1|  for (const auto &s : model_proto_->self_test_data().samples()) {
  ------------------
  |  Branch (273:22): [True: 0, False: 1]
  ------------------
  274|      0|    RETURN_IF_ERROR(Encode(s.input(), &sps));
  ------------------
  |  |   44|      0|  do {                                 \
  |  |   45|      0|    const auto _status = expr;         \
  |  |   46|      0|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   47|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  275|      0|    const std::string result = absl::StrJoin(sps, " ");
  276|      0|    if (!model_->VerifyOutputsEquivalent(s.expected(), result)) {
  ------------------
  |  Branch (276:9): [True: 0, False: 0]
  ------------------
  277|      0|      errors.emplace_back(
  278|      0|          absl::StrCat(s.input(), "\t", s.expected(), "\t", result));
  279|      0|    }
  280|      0|  }
  281|       |
  282|      1|  if (!errors.empty()) {
  ------------------
  |  Branch (282:7): [True: 0, False: 1]
  ------------------
  283|      0|    LOG(INFO) << errors.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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  284|      0|              << model_proto_->self_test_data().samples_size()
  285|      0|              << " samples did not pass the test.";
  286|      0|    for (const auto &e : errors) {
  ------------------
  |  Branch (286:24): [True: 0, False: 0]
  ------------------
  287|      0|      LOG(INFO) << e;
  ------------------
  |  |  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{})
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  288|      0|    }
  289|      0|    return util::InternalError("Self-test failures. See LOG(INFO).");
  290|      0|  }
  291|       |
  292|      1|  return util::OkStatus();
  293|      1|}
_ZNK13sentencepiece22SentencePieceProcessor6statusEv:
  305|      1|util::Status SentencePieceProcessor::status() const {
  306|      1|  RET_CHECK(model_) << "Model is not initialized.";
  ------------------
  |  |  321|      1|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 1, False: 0]
  |  |  ------------------
  |  |  322|      1|  } else /* NOLINT */                                        \
  |  |  323|      1|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  307|      1|  RET_CHECK(normalizer_) << "Normalizer is not initialized.";
  ------------------
  |  |  321|      1|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (321:7): [True: 1, False: 0]
  |  |  ------------------
  |  |  322|      1|  } else /* NOLINT */                                        \
  |  |  323|      1|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  324|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  325|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  308|      1|  RETURN_IF_ERROR(model_->status());
  ------------------
  |  |   44|      1|  do {                                 \
  |  |   45|      1|    const auto _status = expr;         \
  |  |   46|      1|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   47|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  309|      1|  RETURN_IF_ERROR(normalizer_->status());
  ------------------
  |  |   44|      1|  do {                                 \
  |  |   45|      1|    const auto _status = expr;         \
  |  |   46|      1|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (46:9): [True: 0, False: 1]
  |  |  ------------------
  |  |   47|      1|  } while (0)
  |  |  ------------------
  |  |  |  Branch (47:12): [Folded, False: 1]
  |  |  ------------------
  ------------------
  310|      1|  return util::OkStatus();
  311|      1|}

_ZN13sentencepiece7unigram5Model9BuildTrieEPNSt3__16vectorINS2_4pairINS2_17basic_string_viewIcNS2_11char_traitsIcEEEEiEENS2_9allocatorIS9_EEEE:
  622|      1|void Model::BuildTrie(std::vector<std::pair<absl::string_view, int>> *pieces) {
  623|      1|  if (!status().ok()) return;
  ------------------
  |  Branch (623:7): [True: 0, False: 1]
  ------------------
  624|       |
  625|      1|  if (pieces->empty()) {
  ------------------
  |  Branch (625:7): [True: 0, False: 1]
  ------------------
  626|      0|    status_ = util::InternalError("no pieces are loaded.");
  627|      0|    return;
  628|      0|  }
  629|       |
  630|       |  // sort by sentencepiece since DoubleArray::build()
  631|       |  // only accepts sorted strings.
  632|      1|  sort(pieces->begin(), pieces->end());
  633|       |
  634|       |  // Makes key/value/length set for DoubleArrayTrie.
  635|      1|  std::vector<const char *> key(pieces->size());
  636|      1|  std::vector<size_t> length(pieces->size());
  637|      1|  std::vector<int> value(pieces->size());
  638|     40|  for (size_t i = 0; i < pieces->size(); ++i) {
  ------------------
  |  Branch (638:22): [True: 39, False: 1]
  ------------------
  639|     39|    key[i] = (*pieces)[i].first.data();  // sorted piece.
  640|     39|    length[i] = (*pieces)[i].first.size();
  641|     39|    value[i] = (*pieces)[i].second;  // vocab_id
  642|     39|  }
  643|       |
  644|      1|  trie_ = std::make_unique<Darts::DoubleArray>();
  645|      1|  if (trie_->build(key.size(), const_cast<char **>(&key[0]),
  ------------------
  |  Branch (645:7): [True: 0, False: 1]
  ------------------
  646|      1|                   const_cast<size_t *>(&length[0]), &value[0]) != 0) {
  647|      0|    status_ = util::InternalError("cannot build double-array.");
  648|      0|    return;
  649|      0|  }
  650|       |
  651|       |  // Computes the maximum number of shared prefixes in the trie.
  652|      1|  const int kMaxTrieResultsSize = 1024;
  653|      1|  std::vector<Darts::DoubleArray::result_pair_type> results(
  654|      1|      kMaxTrieResultsSize);
  655|      1|  trie_results_size_ = 0;
  656|     39|  for (const auto &p : *pieces) {
  ------------------
  |  Branch (656:22): [True: 39, False: 1]
  ------------------
  657|     39|    const int num_nodes = trie_->commonPrefixSearch(
  658|     39|        p.first.data(), results.data(), results.size(), p.first.size());
  659|     39|    trie_results_size_ = std::max(trie_results_size_, num_nodes);
  660|     39|  }
  661|       |
  662|      1|  pieces_.clear();
  663|       |
  664|      1|  if (trie_results_size_ == 0)
  ------------------
  |  Branch (664:7): [True: 0, False: 1]
  ------------------
  665|      0|    status_ = util::InternalError("no entry is found in the trie.");
  666|      1|}
_ZN13sentencepiece7unigram5ModelC2ERKNS_10ModelProtoE:
  668|      1|Model::Model(const ModelProto &model_proto) {
  669|      1|  model_proto_ = &model_proto;
  670|       |
  671|      1|  InitializePieces();
  672|       |
  673|      1|  min_score_ = FLT_MAX;
  674|    298|  for (const auto &sp : model_proto_->pieces()) {
  ------------------
  |  Branch (674:23): [True: 298, False: 1]
  ------------------
  675|    298|    if (sp.type() == ModelProto::SentencePiece::NORMAL) {
  ------------------
  |  Branch (675:9): [True: 39, False: 259]
  ------------------
  676|     39|      min_score_ = std::min(min_score_, sp.score());
  677|     39|    }
  678|    298|  }
  679|       |
  680|      1|  std::vector<std::pair<absl::string_view, int>> pieces;
  681|     39|  for (const auto &it : pieces_) pieces.emplace_back(it.first, it.second);
  ------------------
  |  Branch (681:23): [True: 39, False: 1]
  ------------------
  682|       |
  683|      1|  BuildTrie(&pieces);
  684|      1|}

_ZN13sentencepiece4util8OkStatusEv:
  273|      3|inline Status OkStatus() { return Status(); }
_ZN13sentencepiece4port18InsertIfNotPresentIN4absl12lts_2026010713flat_hash_mapINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEiNS3_18container_internal10StringHashENSA_8StringEqENS5_9allocatorINS5_4pairIKS9_iEEEEEEEEbPT_RKNSJ_10value_type10first_typeERKNSL_11second_typeE:
  183|    298|    const typename Collection::value_type::second_type &value) {
  184|    298|  return InsertIfNotPresent(collection,
  185|    298|                            typename Collection::value_type(key, value));
  186|    298|}
_ZN13sentencepiece4port18InsertIfNotPresentIN4absl12lts_2026010713flat_hash_mapINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEiNS3_18container_internal10StringHashENSA_8StringEqENS5_9allocatorINS5_4pairIKS9_iEEEEEEEEbPT_RKNSJ_10value_typeE:
  175|    298|                        const typename Collection::value_type &vt) {
  176|    298|  return collection->insert(vt).second;
  177|    298|}

_ZN4absl12lts_2026010713little_endian10FromHost64Em:
  109|      5|inline uint64_t FromHost64(uint64_t x) { return x; }
_ZN4absl12lts_2026010713little_endian6Load64EPKv:
  176|      2|inline uint64_t Load64(const void* absl_nonnull p) {
  177|      2|  return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
  ------------------
  |  |   78|      2|  (absl::base_internal::UnalignedLoad64(_p))
  ------------------
  178|      2|}
_ZN4absl12lts_2026010713little_endian7Store64EPvm:
  180|      5|inline void Store64(void* absl_nonnull p, uint64_t v) {
  181|      5|  ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
  ------------------
  |  |   85|      5|  (absl::base_internal::UnalignedStore64(_p, _val))
  ------------------
  182|      5|}

_ZN4absl12lts_2026010713base_internal16UnalignedStore64EPvm:
   65|      5|inline void UnalignedStore64(void* absl_nonnull p, uint64_t v) {
   66|      5|  memcpy(p, &v, sizeof v);
   67|      5|}

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

_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl18MaskEmptyOrDeletedEv:
  319|      8|  NonIterableBitMaskType MaskEmptyOrDeleted() const {
  320|      8|    auto special = _mm_set1_epi8(static_cast<char>(ctrl_t::kSentinel));
  321|      8|    return NonIterableBitMaskType(static_cast<uint16_t>(
  322|      8|        _mm_movemask_epi8(_mm_cmpgt_epi8_fixed(special, ctrl))));
  323|      8|  }
_ZN4absl12lts_2026010718container_internal6IsFullENS1_6ctrl_tE:
  221|    562|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|    562|  return static_cast<std::underlying_type_t<ctrl_t>>(c) >= 0;
  226|    562|}
_ZN4absl12lts_2026010718container_internal20_mm_cmpgt_epi8_fixedEDv2_xS2_:
  264|      8|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|      8|  return _mm_cmpgt_epi8(a, b);
  273|      8|}

_ZNK4absl12lts_2026010718container_internal20HashtablezInfoHandle9IsSampledEv:
  220|     11|  inline bool IsSampled() const { return false; }
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle20RecordStorageChangedEmm:
  221|      1|  inline void RecordStorageChanged(size_t /*size*/, size_t /*capacity*/) {}
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle17RecordReservationEm:
  223|      2|  inline void RecordReservation(size_t /*target_capacity*/) {}
_ZN4absl12lts_2026010718container_internal20HashtablezInfoHandle16RecordInsertMissEmm:
  226|    545|                               size_t /*distance_from_desired*/) {}

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

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

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

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

_ZN4absl12lts_2026010711countl_zeroImEENSt3__19enable_ifIXsr3std11is_unsignedIT_EE5valueEiE4typeES4_:
  108|      2|    countl_zero(T x) noexcept {
  109|      2|  return numeric_internal::CountLeadingZeroes(x);
  110|      2|}

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

_ZN4absl12lts_2026010719str_format_internal13ConvertIntArgIhEEbT_NS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  349|    256|bool ConvertIntArg(T v, FormatConversionSpecImpl conv, FormatSinkImpl *sink) {
  350|    256|  using U = typename MakeUnsigned<T>::type;
  351|    256|  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|    256|  switch (static_cast<uint8_t>(conv.conversion_char())) {
  358|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::c):
  ------------------
  |  Branch (358:5): [True: 0, False: 256]
  ------------------
  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: 256]
  ------------------
  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: 256]
  ------------------
  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: 0]
  ------------------
  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: 256]
  ------------------
  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: 256]
  ------------------
  380|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::i):
  ------------------
  |  Branch (380:5): [True: 0, False: 256]
  ------------------
  381|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::v):
  ------------------
  |  Branch (381:5): [True: 0, False: 256]
  ------------------
  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: 256]
  ------------------
  386|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::e):
  ------------------
  |  Branch (386:5): [True: 0, False: 256]
  ------------------
  387|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::f):
  ------------------
  |  Branch (387:5): [True: 0, False: 256]
  ------------------
  388|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::g):
  ------------------
  |  Branch (388:5): [True: 0, False: 256]
  ------------------
  389|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::A):
  ------------------
  |  Branch (389:5): [True: 0, False: 256]
  ------------------
  390|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::E):
  ------------------
  |  Branch (390:5): [True: 0, False: 256]
  ------------------
  391|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::F):
  ------------------
  |  Branch (391:5): [True: 0, False: 256]
  ------------------
  392|      0|    case static_cast<uint8_t>(FormatConversionCharInternal::G):
  ------------------
  |  Branch (392:5): [True: 0, False: 256]
  ------------------
  393|      0|      return ConvertFloatImpl(static_cast<double>(v), conv, sink);
  394|       |
  395|      0|    default:
  ------------------
  |  Branch (395:5): [True: 0, False: 256]
  ------------------
  396|      0|      ABSL_ASSUME(false);
  ------------------
  |  |  270|      0|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  397|    256|  }
  398|       |
  399|    256|  if (conv.is_basic()) {
  ------------------
  |  Branch (399:7): [True: 0, False: 256]
  ------------------
  400|      0|    sink->Append(as_digits.with_neg_and_zero());
  401|      0|    return true;
  402|      0|  }
  403|    256|  return ConvertIntImplInnerSlow(as_digits, conv, sink);
  404|    256|}
_ZN4absl12lts_2026010719str_format_internal17FormatConvertImplEhNS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  554|    256|                                        FormatSinkImpl *sink) {
  555|    256|  return {ConvertIntArg(v, conv, sink)};
  556|    256|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_113ReducePaddingEmPm:
   53|    256|void ReducePadding(size_t n, size_t *capacity) {
   54|    256|  *capacity = Excess(n, *capacity);
   55|    256|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_123ConvertIntImplInnerSlowERKNS2_9IntDigitsENS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  238|    256|                             FormatSinkImpl *sink) {
  239|       |  // Print as a sequence of Substrings:
  240|       |  //   [left_spaces][sign][base_indicator][zeroes][formatted][right_spaces]
  241|    256|  size_t fill = 0;
  242|    256|  if (conv.width() >= 0)
  ------------------
  |  Branch (242:7): [True: 256, False: 0]
  ------------------
  243|    256|    fill = static_cast<size_t>(conv.width());
  244|       |
  245|    256|  string_view formatted = as_digits.without_neg_or_zero();
  246|    256|  ReducePadding(formatted, &fill);
  247|       |
  248|    256|  string_view sign = SignColumn(as_digits.is_negative(), conv);
  249|    256|  ReducePadding(sign, &fill);
  250|       |
  251|    256|  string_view base_indicator = BaseIndicator(as_digits, conv);
  252|    256|  ReducePadding(base_indicator, &fill);
  253|       |
  254|    256|  bool precision_specified = conv.precision() >= 0;
  255|    256|  size_t precision =
  256|    256|      precision_specified ? static_cast<size_t>(conv.precision()) : size_t{1};
  ------------------
  |  Branch (256:7): [True: 0, False: 256]
  ------------------
  257|       |
  258|    256|  if (conv.has_alt_flag() &&
  ------------------
  |  Branch (258:7): [True: 0, False: 256]
  ------------------
  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|    256|  size_t num_zeroes = Excess(formatted.size(), precision);
  270|    256|  ReducePadding(num_zeroes, &fill);
  271|       |
  272|    256|  size_t num_left_spaces = !conv.has_left_flag() ? fill : 0;
  ------------------
  |  Branch (272:28): [True: 256, False: 0]
  ------------------
  273|    256|  size_t num_right_spaces = conv.has_left_flag() ? fill : 0;
  ------------------
  |  Branch (273:29): [True: 0, False: 256]
  ------------------
  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|    256|  if (!precision_specified && conv.has_zero_flag()) {
  ------------------
  |  Branch (278:7): [True: 256, False: 0]
  |  Branch (278:31): [True: 256, False: 0]
  ------------------
  279|    256|    num_zeroes += num_left_spaces;
  280|    256|    num_left_spaces = 0;
  281|    256|  }
  282|       |
  283|    256|  sink->Append(num_left_spaces, ' ');
  284|    256|  sink->Append(sign);
  285|    256|  sink->Append(base_indicator);
  286|    256|  sink->Append(num_zeroes, '0');
  287|    256|  sink->Append(formatted);
  288|    256|  sink->Append(num_right_spaces, ' ');
  289|    256|  return true;
  290|    256|}
arg.cc:_ZNK4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits19without_neg_or_zeroEv:
  178|    256|  string_view without_neg_or_zero() const {
  179|    256|    static_assert('-' < '0', "The check below verifies both.");
  180|    256|    size_t advance = start_[0] <= '0' ? 1 : 0;
  ------------------
  |  Branch (180:22): [True: 1, False: 255]
  ------------------
  181|    256|    return {start_ + advance, size_ - advance};
  182|    256|  }
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_113ReducePaddingENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEPm:
   48|    768|void ReducePadding(string_view s, size_t *capacity) {
   49|    768|  *capacity = Excess(s.size(), *capacity);
   50|    768|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_110SignColumnEbNS1_24FormatConversionSpecImplE:
  213|    256|string_view SignColumn(bool neg, const FormatConversionSpecImpl conv) {
  214|    256|  if (conv.conversion_char() == FormatConversionCharInternal::d ||
  ------------------
  |  Branch (214:7): [True: 0, False: 256]
  ------------------
  215|    256|      conv.conversion_char() == FormatConversionCharInternal::i) {
  ------------------
  |  Branch (215:7): [True: 0, False: 256]
  ------------------
  216|      0|    if (neg) return "-";
  ------------------
  |  Branch (216:9): [True: 0, False: 0]
  ------------------
  217|      0|    if (conv.has_show_pos_flag()) return "+";
  ------------------
  |  Branch (217:9): [True: 0, False: 0]
  ------------------
  218|      0|    if (conv.has_sign_col_flag()) return " ";
  ------------------
  |  Branch (218:9): [True: 0, False: 0]
  ------------------
  219|      0|  }
  220|    256|  return {};
  221|    256|}
arg.cc:_ZNK4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits11is_negativeEv:
  184|    256|  bool is_negative() const { return start_[0] == '-'; }
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_113BaseIndicatorERKNS2_9IntDigitsENS1_24FormatConversionSpecImplE:
  196|    256|                          const FormatConversionSpecImpl conv) {
  197|       |  // always show 0x for %p.
  198|    256|  bool alt = conv.has_alt_flag() ||
  ------------------
  |  Branch (198:14): [True: 0, False: 256]
  ------------------
  199|    256|             conv.conversion_char() == FormatConversionCharInternal::p;
  ------------------
  |  Branch (199:14): [True: 0, False: 256]
  ------------------
  200|    256|  bool hex = (conv.conversion_char() == FormatConversionCharInternal::x ||
  ------------------
  |  Branch (200:15): [True: 0, False: 256]
  ------------------
  201|    256|              conv.conversion_char() == FormatConversionCharInternal::X ||
  ------------------
  |  Branch (201:15): [True: 256, False: 0]
  ------------------
  202|      0|              conv.conversion_char() == FormatConversionCharInternal::p);
  ------------------
  |  Branch (202:15): [True: 0, False: 0]
  ------------------
  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|    256|  if (alt && hex && !as_digits.without_neg_or_zero().empty()) {
  ------------------
  |  Branch (206:7): [True: 0, False: 256]
  |  Branch (206:7): [True: 0, False: 256]
  |  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|    256|  return {};
  211|    256|}
arg.cc:_ZN4absl12lts_2026010719str_format_internal12_GLOBAL__N_19IntDigits15PrintAsHexUpperIhEEvT_:
  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|  }

_ZN4absl12lts_2026010719str_format_internal19FormatArgImplFriend7ConvertINS1_13FormatArgImplEEEbT_NS1_24FormatConversionSpecImplEPNS1_14FormatSinkImplE:
  414|    256|                      FormatSinkImpl* out) {
  415|    256|    return arg.dispatcher_(arg.data_, conv, out);
  416|    256|  }

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

_ZNK4absl12lts_2026010719str_format_internal15BoundConversion3argEv:
   43|    256|  const FormatArgImpl* arg() const { return arg_; }
_ZN4absl12lts_2026010719str_format_internal15BoundConversion7set_argEPKNS1_13FormatArgImplE:
   44|    256|  void set_arg(const FormatArgImpl* a) { arg_ = a; }
_ZNK4absl12lts_2026010719str_format_internal21UntypedFormatSpecImpl21has_parsed_conversionEv:
   61|    256|  bool has_parsed_conversion() const { return size_ == ~size_t{}; }
_ZNK4absl12lts_2026010719str_format_internal21UntypedFormatSpecImpl3strEv:
   63|    256|  string_view str() const {
   64|       |    assert(!has_parsed_conversion());
   65|    256|    return string_view(static_cast<const char*>(data_), size_);
   66|    256|  }

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

_ZN4absl12lts_2026010719str_format_internal17FormatRawSinkImpl5WriteENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   48|    256|  void Write(string_view s) { write_(sink_, s); }
_ZN4absl12lts_2026010719str_format_internal14FormatSinkImplC2ENS1_17FormatRawSinkImplE:
   68|    256|  explicit FormatSinkImpl(FormatRawSinkImpl raw) : raw_(raw) {}
_ZN4absl12lts_2026010719str_format_internal14FormatSinkImplD2Ev:
   70|    256|  ~FormatSinkImpl() { Flush(); }
_ZN4absl12lts_2026010719str_format_internal14FormatSinkImpl5FlushEv:
   72|    256|  void Flush() {
   73|    256|    raw_.Write(string_view(buf_, static_cast<size_t>(pos_ - buf_)));
   74|    256|    pos_ = buf_;
   75|    256|  }
_ZN4absl12lts_2026010719str_format_internal14FormatSinkImpl6AppendEmc:
   77|    768|  void Append(size_t n, char c) {
   78|    768|    if (n == 0) return;
  ------------------
  |  Branch (78:9): [True: 752, False: 16]
  ------------------
   79|     16|    size_ += n;
   80|     16|    auto raw_append = [&](size_t count) {
   81|     16|      memset(pos_, c, count);
   82|     16|      pos_ += count;
   83|     16|    };
   84|     16|    while (n > Avail()) {
  ------------------
  |  Branch (84:12): [True: 0, False: 16]
  ------------------
   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|     16|    raw_append(n);
   92|     16|  }
_ZN4absl12lts_2026010719str_format_internal14FormatSinkImpl6AppendENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   94|  1.28k|  void Append(string_view v) {
   95|  1.28k|    size_t n = v.size();
   96|  1.28k|    if (n == 0) return;
  ------------------
  |  Branch (96:9): [True: 513, False: 767]
  ------------------
   97|    767|    size_ += n;
   98|    767|    if (n >= Avail()) {
  ------------------
  |  Branch (98:9): [True: 0, False: 767]
  ------------------
   99|      0|      Flush();
  100|      0|      raw_.Write(v);
  101|      0|      return;
  102|      0|    }
  103|    767|    memcpy(pos_, v.data(), n);
  104|    767|    pos_ += n;
  105|    767|  }
_ZNK4absl12lts_2026010719str_format_internal14FormatSinkImpl5AvailEv:
  123|    783|  size_t Avail() const {
  124|    783|    return static_cast<size_t>(buf_ + sizeof(buf_) - pos_);
  125|    783|  }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl8is_basicEv:
  277|    256|  bool is_basic() const { return flags_ == Flags::kBasic; }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl13has_left_flagEv:
  278|    512|  bool has_left_flag() const { return FlagsContains(flags_, Flags::kLeft); }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl12has_alt_flagEv:
  285|    512|  bool has_alt_flag() const { return FlagsContains(flags_, Flags::kAlt); }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl13has_zero_flagEv:
  286|    256|  bool has_zero_flag() const { return FlagsContains(flags_, Flags::kZero); }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl5widthEv:
  301|    512|  int width() const { return width_; }
_ZNK4absl12lts_2026010719str_format_internal24FormatConversionSpecImpl9precisionEv:
  304|    256|  int precision() const { return precision_; }
_ZN4absl12lts_2026010719str_format_internal30FormatConversionSpecImplFriend8SetFlagsENS1_5FlagsEPNS1_24FormatConversionSpecImplE:
  321|    256|  static void SetFlags(Flags f, FormatConversionSpecImpl* conv) {
  322|    256|    conv->flags_ = f;
  323|    256|  }
_ZN4absl12lts_2026010719str_format_internal30FormatConversionSpecImplFriend12SetLengthModENS0_9LengthModEPNS1_24FormatConversionSpecImplE:
  324|    256|  static void SetLengthMod(LengthMod l, FormatConversionSpecImpl* conv) {
  325|    256|    conv->length_mod_ = l;
  326|    256|  }
_ZN4absl12lts_2026010719str_format_internal30FormatConversionSpecImplFriend17SetConversionCharENS0_20FormatConversionCharEPNS1_24FormatConversionSpecImplE:
  328|    256|                                FormatConversionSpecImpl* conv) {
  329|    256|    conv->conv_ = c;
  330|    256|  }
_ZN4absl12lts_2026010719str_format_internal30FormatConversionSpecImplFriend8SetWidthEiPNS1_24FormatConversionSpecImplE:
  331|    256|  static void SetWidth(int w, FormatConversionSpecImpl* conv) {
  332|    256|    conv->width_ = w;
  333|    256|  }
_ZN4absl12lts_2026010719str_format_internal30FormatConversionSpecImplFriend12SetPrecisionEiPNS1_24FormatConversionSpecImplE:
  334|    256|  static void SetPrecision(int p, FormatConversionSpecImpl* conv) {
  335|    256|    conv->precision_ = p;
  336|    256|  }
_ZN4absl12lts_2026010719str_format_internalorENS1_5FlagsES2_:
  146|    512|constexpr Flags operator|(Flags a, Flags b) {
  147|    512|  return static_cast<Flags>(static_cast<uint8_t>(a) | static_cast<uint8_t>(b));
  148|    512|}
_ZN4absl12lts_2026010719str_format_internal13FlagsContainsENS1_5FlagsES2_:
  150|  1.28k|constexpr bool FlagsContains(Flags haystack, Flags needle) {
  151|  1.28k|  return (static_cast<uint8_t>(haystack) & static_cast<uint8_t>(needle)) ==
  152|  1.28k|         static_cast<uint8_t>(needle);
  153|  1.28k|}
_ZN4absl12lts_2026010719str_format_internal6ExcessEmm:
  447|  1.28k|inline size_t Excess(size_t used, size_t capacity) {
  448|  1.28k|  return used < capacity ? capacity - used : 0;
  ------------------
  |  Branch (448:10): [True: 65, False: 1.21k]
  ------------------
  449|  1.28k|}
_ZZN4absl12lts_2026010719str_format_internal14FormatSinkImpl6AppendEmcENKUlmE_clEm:
   80|     16|    auto raw_append = [&](size_t count) {
   81|     16|      memset(pos_, c, count);
   82|     16|      pos_ += count;
   83|     16|    };
_ZN4absl12lts_2026010719str_format_internal17FormatRawSinkImplC2INSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEETnPDTclsr19str_format_internalE11InvokeFlushclsr3stdE7declvalIPT_EEcvNS4_17basic_string_viewIcS7_EE_EEELPv0EEESC_:
   46|    256|      : sink_(raw), write_(&FormatRawSinkImpl::Flush<T>) {}
_ZN4absl12lts_2026010719str_format_internal17FormatRawSinkImpl5FlushINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvPvNS4_17basic_string_viewIcS7_EE:
   57|    256|  static void Flush(void* r, string_view s) {
   58|    256|    str_format_internal::InvokeFlush(static_cast<T*>(r), s);
   59|    256|  }

_ZN4absl12lts_2026010719str_format_internal15AbslFormatFlushEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_17basic_string_viewIcS5_EE:
   71|    256|inline void AbslFormatFlush(std::string* out, string_view s) {
   72|    256|  out->append(s.data(), s.size());
   73|    256|}
_ZN4absl12lts_2026010719str_format_internal11InvokeFlushINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEDTcl15AbslFormatFlushfp_fp0_EEPT_NS3_17basic_string_viewIcS6_EE:
   89|    256|auto InvokeFlush(T* out, string_view s) -> decltype(AbslFormatFlush(out, s)) {
   90|    256|  AbslFormatFlush(out, s);
   91|    256|}

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

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

_ZNK4absl12lts_202601074SpanIKNS0_19str_format_internal13FormatArgImplEE4sizeEv:
  323|    256|  constexpr size_type size() const noexcept { return len_; }
_ZNK4absl12lts_202601074SpanIKNS0_19str_format_internal13FormatArgImplEEixEm:
  338|    256|  constexpr reference operator[](size_type i) const noexcept {
  339|    256|    ABSL_HARDENING_ASSERT(i < size());
  ------------------
  |  |  140|    256|#define ABSL_HARDENING_ASSERT(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|    256|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 256]
  |  |  |  |  |  Branch (106:37): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  340|    256|    return ptr_[i];
  341|    256|  }

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

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

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

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

_ZN4absl12lts_2026010713flat_hash_mapINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEhNS0_18container_internal10StringHashENS9_8StringEqENS6_INS2_4pairIKS8_hEEEEEC2Ev:
  184|      1|  flat_hash_map() {}
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE5valueEPNS3_4pairIKS9_hEE:
  684|    256|  static V& value(std::pair<const K, V>* kv) { return kv->second; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE7elementEPNS1_13map_slot_typeIS9_hEE:
  682|  1.23k|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE5applyINS1_12EqualElementIS9_NS1_8StringEqEEEJRNS3_4pairIKS9_hEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|     26|  apply(F&& f, Args&&... args) {
  669|     26|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|     26|                                                   std::forward<Args>(args)...);
  671|     26|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE8transferINS7_INS3_4pairIKS9_hEEEEEEDaPT_PNS1_13map_slot_typeIS9_hEESK_:
  661|    445|                       slot_type* old_slot) {
  662|    445|    return slot_policy::transfer(alloc, new_slot, old_slot);
  663|    445|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS3_4pairIKS9_hEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSJ_DpOSK_:
  668|    434|  apply(F&& f, Args&&... args) {
  669|    434|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|    434|                                                   std::forward<Args>(args)...);
  671|    434|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE9constructINS7_INS3_4pairIKS9_hEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOS9_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_hEEDpOT0_:
  649|    256|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|    256|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|    256|  }
_ZN4absl12lts_2026010713flat_hash_mapINSt3__117basic_string_viewIcNS2_11char_traitsIcEEEEiNS0_18container_internal10StringHashENS7_8StringEqENS2_9allocatorINS2_4pairIKS6_iEEEEEC2Ev:
  184|      2|  flat_hash_map() {}
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE5applyINS1_12EqualElementIS7_NS1_8StringEqEEEJRNS3_4pairIKS7_iEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSH_DpOSI_:
  668|     10|  apply(F&& f, Args&&... args) {
  669|     10|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|     10|                                                   std::forward<Args>(args)...);
  671|     10|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE7elementEPNS1_13map_slot_typeIS7_iEE:
  682|     49|  static std::pair<const K, V>& element(slot_type* slot) { return slot->value; }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE5applyINS1_12raw_hash_setIS8_JEE19EmplaceDecomposableEJRKNS3_4pairIKS7_iEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSI_DpOSJ_:
  668|    298|  apply(F&& f, Args&&... args) {
  669|    298|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|    298|                                                   std::forward<Args>(args)...);
  671|    298|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE9constructINS3_9allocatorINS3_4pairIKS7_iEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSC_EEENSI_IJRKiEEEEEEvPT_PNS1_13map_slot_typeIS7_iEEDpOT0_:
  649|    298|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  650|    298|    slot_policy::construct(alloc, slot, std::forward<Args>(args)...);
  651|    298|  }
_ZN4absl12lts_2026010718container_internal17FlatHashMapPolicyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE5applyINS1_12EqualElementINS3_17basic_string_viewIcS6_EENS1_8StringEqEEEJRNS3_4pairIKS9_hEEEEEDTclsr4absl18container_internalE13DecomposePairclsr3stdE7declvalIT_EEspclsr3stdE7declvalIT0_EEEEOSL_DpOSM_:
  668|    260|  apply(F&& f, Args&&... args) {
  669|    260|    return absl::container_internal::DecomposePair(std::forward<F>(f),
  670|    260|                                                   std::forward<Args>(args)...);
  671|    260|  }

_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE7elementISB_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeISA_hEE:
   85|  1.23k|      -> decltype(P::element(slot)) {
   86|  1.23k|    return P::element(slot);
   87|  1.23k|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE8transferINS8_INS4_4pairIKSA_hEEEEEEvPT_PNS1_13map_slot_typeISA_hEESM_:
   75|    445|  static void transfer(Alloc* alloc, slot_type* new_slot, slot_type* old_slot) {
   76|    445|    transfer_impl(alloc, new_slot, old_slot, Rank2{});
   77|    445|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE13transfer_implINS8_INS4_4pairIKSA_hEEEESB_EEDTclsrT0_8transferfp_fp0_fp1_EEPT_PNS1_13map_slot_typeISA_hEESO_NSC_5Rank2E:
  119|    445|                                                           old_slot)) {
  120|    445|    return P::transfer(alloc, new_slot, old_slot);
  121|    445|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE9constructINS8_INS4_4pairIKSA_hEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSL_IJEEEEEEvPT_PNS1_13map_slot_typeISA_hEEDpOT0_:
   51|    256|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|    256|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|    256|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE7elementIS9_EEDTclsrT_7elementfp_EEPNS1_13map_slot_typeIS8_iEE:
   85|     49|      -> decltype(P::element(slot)) {
   86|     49|    return P::element(slot);
   87|     49|  }
_ZN4absl12lts_2026010718container_internal20common_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE9constructINS4_9allocatorINS4_4pairIKS8_iEEEEJRKNS4_21piecewise_construct_tENS4_5tupleIJRSE_EEENSK_IJRKiEEEEEEvPT_PNS1_13map_slot_typeIS8_iEEDpOT0_:
   51|    298|  static void construct(Alloc* alloc, slot_type* slot, Args&&... args) {
   52|    298|    Policy::construct(alloc, slot, std::forward<Args>(args)...);
   53|    298|  }

_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   91|  6.43k|  constexpr const T& get() const& { return value; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|  6.43k|  constexpr const ElemT<I>& get() const& {
  250|  6.43k|    return StorageT<I>::get();
  251|  6.43k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EE3getEv:
   92|  3.43k|  constexpr T& get() & { return value; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi0EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|  3.43k|  constexpr ElemT<I>& get() & {
  245|  3.43k|    return StorageT<I>::get();
  246|  3.43k|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EE3getEv:
  105|  1.00k|  constexpr T& get() & { return *this; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi3EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|  1.00k|  constexpr ElemT<I>& get() & {
  245|  1.00k|    return StorageT<I>::get();
  246|  1.00k|  }
_ZN4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEC2IS3_JS4_S5_S8_ETnNS6_9enable_ifIXsr4absl11conjunctionINS6_8negationINS6_7is_sameIFvS9_EFvu7__decayIT_EEEEEENS1_25internal_compressed_tuple27TupleItemsMoveConstructibleIS9_JSF_DpT0_EEEEE5valueEbE4typeELb1EEEOSF_DpOSM_:
  239|      3|      : CompressedTuple::CompressedTupleImpl(absl::in_place,
  240|      3|                                             std::forward<First>(first),
  241|      3|                                             std::forward<Vs>(base)...) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple19CompressedTupleImplINS1_15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEENS8_16integer_sequenceImJLm0ELm1ELm2ELm3EEEELb1EEC2IJS5_S6_S7_SA_EEENS8_10in_place_tEDpOT_:
  126|     12|      : Storage<Ts, I, StorageTag<Ts...>>(absl::in_place,
  127|     12|                                          std::forward<Vs>(args))... {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_12CommonFieldsELm0ENS2_10StorageTagIJS4_NS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEEELb0EEC2IS4_EENS8_10in_place_tEOT_:
   90|      3|      : value(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EEC2IS4_EENS8_10in_place_tEOT_:
  102|      3|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EEC2IS4_EENS8_10in_place_tEOT_:
  102|      3|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZN4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINSt3__19allocatorIcEELm3ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqES6_EEELb1EEC2IS6_EENS4_10in_place_tEOT_:
  102|      3|  explicit constexpr Storage(absl::in_place_t, V&& v) : T(std::forward<V>(v)) {}
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi2EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|    296|  constexpr const ElemT<I>& get() const& {
  250|    296|    return StorageT<I>::get();
  251|    296|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_8StringEqELm2ENS2_10StorageTagIJNS1_12CommonFieldsENS1_10StringHashES4_NSt3__19allocatorIcEEEEELb1EE3getEv:
  104|    296|  constexpr const T& get() const& { return *this; }
_ZNKR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERKNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  249|  1.24k|  constexpr const ElemT<I>& get() const& {
  250|  1.24k|    return StorageT<I>::get();
  251|  1.24k|  }
_ZNKR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  104|  1.24k|  constexpr const T& get() const& { return *this; }
_ZNR4absl12lts_2026010718container_internal15CompressedTupleIJNS1_12CommonFieldsENS1_10StringHashENS1_8StringEqENSt3__19allocatorIcEEEE3getILi1EEERNS1_25internal_compressed_tuple4ElemIS9_XT_EE4typeEv:
  244|      2|  constexpr ElemT<I>& get() & {
  245|      2|    return StorageT<I>::get();
  246|      2|  }
_ZNR4absl12lts_2026010718container_internal25internal_compressed_tuple7StorageINS1_10StringHashELm1ENS2_10StorageTagIJNS1_12CommonFieldsES4_NS1_8StringEqENSt3__19allocatorIcEEEEELb1EE3getEv:
  105|      2|  constexpr T& get() & { return *this; }

_ZN4absl12lts_2026010718container_internal27SanitizerPoisonMemoryRegionEPKvm:
  240|    435|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|    435|  (void)m;
  248|    435|  (void)s;
  249|    435|}
_ZN4absl12lts_2026010718container_internal29SanitizerUnpoisonMemoryRegionEPKvm:
  251|  1.00k|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|  1.00k|  (void)m;
  259|  1.00k|  (void)s;
  260|  1.00k|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS1_8StringEqEEEJRNS4_4pairIKSA_hEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|     26|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|     26|  return memory_internal::DecomposePairImpl(
  228|     26|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|     26|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS1_8StringEqEEERKSB_NS5_5tupleIJRKhEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS5_4pairISO_SP_EE:
  158|     26|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|     26|  const auto& key = std::get<0>(p.first);
  160|     26|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|     26|                            std::move(p.second));
  162|     26|}
_ZNK4absl12lts_2026010718container_internal12EqualElementINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS1_8StringEqEEclIS9_JRKNS3_21piecewise_construct_tENS3_5tupleIJRKS9_EEENSG_IJRKhEEEEEEbRKT_DpOT0_:
  529|     26|  bool operator()(const K2& lhs, Args&&...) const {
  530|     26|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|     26|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|     26|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhEENS3_4pairINS3_5tupleIJRKT_EEENSC_IJRKT0_EEEEERKNSB_ISD_SH_EE:
  207|    720|    const std::pair<F, S>& p) {
  208|    720|  return PairArgs(p.first, p.second);
  209|    720|}
_ZN4absl12lts_2026010718container_internal8PairArgsIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEERKhEENS3_4pairINS3_5tupleIJOT_EEENSF_IJOT0_EEEEESH_SK_:
  201|    720|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|    720|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|    720|          std::forward_as_tuple(std::forward<S>(s))};
  204|    720|}
_ZN4absl12lts_2026010718container_internal23TypeErasedApplyToSlotFnINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEEmPKvPvm:
  542|      1|size_t TypeErasedApplyToSlotFn(const void* fn, void* slot, size_t seed) {
  543|      1|  const auto* f = static_cast<const Fn*>(fn);
  544|      1|  return HashElement<Fn, kIsDefault>{*f, seed}(*static_cast<const T*>(slot));
  545|      1|}
_ZN4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEC2ERKS3_m:
  495|  1.24k|  HashElement(const Hash& h, size_t s) : hash(h), seed(s) {}
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJEEEmRKT_DpOT0_:
  498|    256|  size_t operator()(const K& key, Args&&...) const {
  499|    256|    if constexpr (kIsDefault) {
  500|       |      // TODO(b/384509507): resolve `no header providing
  501|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  502|       |      // Maybe we should make "internal/hash.h" be a separate library.
  503|    256|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|    256|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|    256|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE8transferINS7_INS3_4pairIKS9_hEEEEEEDaPT_PNS1_13map_slot_typeIS9_hEESK_:
  442|    445|                       slot_type* old_slot) {
  443|       |    // This should really just be
  444|       |    // typename absl::is_trivially_relocatable<value_type>::type()
  445|       |    // but std::pair is not trivially copyable in C++23 in some standard
  446|       |    // library versions.
  447|       |    // See https://github.com/llvm/llvm-project/pull/95444 for instance.
  448|    445|    auto is_relocatable = typename std::conjunction<
  449|    445|        absl::is_trivially_relocatable<typename value_type::first_type>,
  450|    445|        absl::is_trivially_relocatable<typename value_type::second_type>>::
  451|    445|        type();
  452|       |
  453|    445|    emplace(new_slot);
  454|    445|    if (is_relocatable) {
  ------------------
  |  Branch (454:9): [Folded, False: 445]
  ------------------
  455|       |      // TODO(b/247130232,b/251814870): remove casts after fixing warnings.
  456|      0|      std::memcpy(static_cast<void*>(std::launder(&new_slot->value)),
  457|      0|                  static_cast<const void*>(&old_slot->value),
  458|      0|                  sizeof(value_type));
  459|      0|      return is_relocatable;
  460|      0|    }
  461|       |
  462|    445|    if (kMutableKeys::value) {
  ------------------
  |  Branch (462:9): [True: 445, Folded]
  ------------------
  463|    445|      absl::allocator_traits<Allocator>::construct(
  464|    445|          *alloc, &new_slot->mutable_value, std::move(old_slot->mutable_value));
  465|    445|    } else {
  466|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &new_slot->value,
  467|      0|                                                   std::move(old_slot->value));
  468|      0|    }
  469|    445|    destroy(alloc, old_slot);
  470|    445|    return is_relocatable;
  471|    445|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE7emplaceEPNS1_13map_slot_typeIS9_hEE:
  368|    701|  static void emplace(slot_type* slot) {
  369|       |    // The construction of union doesn't do anything at runtime but it allows us
  370|       |    // to access its members without violating aliasing rules.
  371|    701|    new (slot) slot_type;
  372|    701|  }
_ZN4absl12lts_2026010718container_internal13map_slot_typeINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhEC2Ev:
  349|    701|  map_slot_type() {}
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE7destroyINS7_INS3_4pairIKS9_hEEEEEEDaPT_PNS1_13map_slot_typeIS9_hEE:
  431|    445|  static auto destroy(Allocator* alloc, slot_type* slot) {
  432|    445|    if (kMutableKeys::value) {
  ------------------
  |  Branch (432:9): [True: 445, Folded]
  ------------------
  433|    445|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->mutable_value);
  434|    445|    } else {
  435|      0|      absl::allocator_traits<Allocator>::destroy(*alloc, &slot->value);
  436|      0|    }
  437|    445|    return IsDestructionTrivial<Allocator, value_type>();
  438|    445|  }
_ZN4absl12lts_2026010718container_internal20IsDestructionTrivialINSt3__19allocatorINS3_4pairIKNS3_12basic_stringIcNS3_11char_traitsIcEENS4_IcEEEEhEEEESC_EEDav:
   81|    445|constexpr auto IsDestructionTrivial() {
   82|    445|  constexpr bool result =
   83|    445|      std::is_trivially_destructible<ValueType>::value &&
  ------------------
  |  Branch (83:7): [Folded, False: 445]
  ------------------
   84|      0|      std::is_same<typename absl::allocator_traits<
  ------------------
  |  Branch (84:7): [True: 0, Folded]
  ------------------
   85|      0|                       Allocator>::template rebind_alloc<char>,
   86|      0|                   std::allocator<char>>::value;
   87|    445|  return std::integral_constant<bool, result>();
   88|    445|}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_11HashElementINS1_10StringHashELb1EEEJRNSt3__14pairIKNS6_12basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEhEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSH_DpOSI_:
  226|    434|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|    434|  return memory_internal::DecomposePairImpl(
  228|    434|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|    434|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_11HashElementINS1_10StringHashELb1EEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEENS7_5tupleIJRKhEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS7_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS7_4pairISO_SP_EE:
  158|    434|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|    434|  const auto& key = std::get<0>(p.first);
  160|    434|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|    434|                            std::move(p.second));
  162|    434|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSC_EEENSG_IJRKhEEEEEEmRKT_DpOT0_:
  498|    434|  size_t operator()(const K& key, Args&&...) const {
  499|    434|    if constexpr (kIsDefault) {
  500|       |      // TODO(b/384509507): resolve `no header providing
  501|       |      // "absl::hash_internal::SupportsHashWithSeed" is directly included`.
  502|       |      // Maybe we should make "internal/hash.h" be a separate library.
  503|    434|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|    434|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|    434|  }
_ZN4absl12lts_2026010718container_internal7HashKeyINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEC2ERKS3_RKSA_:
  515|      2|  HashKey(const Hash& h, const Key& k) : hash(h), key(k) {}
_ZNK4absl12lts_2026010718container_internal7HashKeyINS1_10StringHashENSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEELb1EEclEm:
  517|      1|  size_t operator()(size_t seed) const {
  518|      1|    return HashElement<Hash, kIsDefault>{hash, seed}(key);
  519|      1|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEhE9constructINS7_INS3_4pairIKS9_hEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJOS9_EEENSJ_IJEEEEEEvPT_PNS1_13map_slot_typeIS9_hEEDpOT0_:
  397|    256|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|    256|    emplace(slot);
  399|    256|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 256, Folded]
  ------------------
  400|    256|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|    256|                                                   std::forward<Args>(args)...);
  402|    256|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|    256|  }
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS1_8StringEqEEEJRNS4_4pairIKS8_iEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSF_DpOSG_:
  226|     10|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|     10|  return memory_internal::DecomposePairImpl(
  228|     10|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|     10|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_8StringEqEEERKS9_NS5_5tupleIJRKiEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSE_IJSJ_EEEEEclsr3stdE7declvalIT1_EEEEOSI_NS5_4pairISM_SN_EE:
  158|     10|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|     10|  const auto& key = std::get<0>(p.first);
  160|     10|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|     10|                            std::move(p.second));
  162|     10|}
_ZNK4absl12lts_2026010718container_internal12EqualElementINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_8StringEqEEclIS7_JRKNS3_21piecewise_construct_tENS3_5tupleIJRKS7_EEENSE_IJRKiEEEEEEbRKT_DpOT0_:
  529|     10|  bool operator()(const K2& lhs, Args&&...) const {
  530|     10|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|     10|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|     10|  }
_ZN4absl12lts_2026010718container_internal8PairArgsIKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiEENS3_4pairINS3_5tupleIJRKT_EEENSA_IJRKT0_EEEEERKNS9_ISB_SF_EE:
  207|    308|    const std::pair<F, S>& p) {
  208|    308|  return PairArgs(p.first, p.second);
  209|    308|}
_ZN4absl12lts_2026010718container_internal8PairArgsIRKNSt3__117basic_string_viewIcNS3_11char_traitsIcEEEERKiEENS3_4pairINS3_5tupleIJOT_EEENSD_IJOT0_EEEEESF_SI_:
  201|    308|std::pair<std::tuple<F&&>, std::tuple<S&&>> PairArgs(F&& f, S&& s) {
  202|    308|  return {std::piecewise_construct, std::forward_as_tuple(std::forward<F>(f)),
  203|    308|          std::forward_as_tuple(std::forward<S>(s))};
  204|    308|}
_ZNK4absl12lts_2026010718container_internal11HashElementINS1_10StringHashELb1EEclINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEEmRKT_DpOT0_:
  498|    554|  size_t operator()(const K& key, Args&&...) const {
  499|    554|    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|    554|      return absl::hash_internal::HashWithSeed().hash(hash, key, seed);
  504|    554|    }
  505|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  506|      0|    return hash(key) ^ seed;
  507|    554|  }
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE7emplaceEPNS1_13map_slot_typeIS7_iEE:
  368|    298|  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|    298|    new (slot) slot_type;
  372|    298|  }
_ZN4absl12lts_2026010718container_internal13map_slot_typeINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiEC2Ev:
  349|    298|  map_slot_type() {}
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEiEEJEE19EmplaceDecomposableEJRKNS5_4pairIKS9_iEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSI_DpOSJ_:
  226|    298|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|    298|  return memory_internal::DecomposePairImpl(
  228|    298|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|    298|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEiEEJEE19EmplaceDecomposableERKSA_NS6_5tupleIJRKiEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS6_19piecewise_constructEEclsr3stdE7declvalINSG_IJSL_EEEEEclsr3stdE7declvalIT1_EEEEOSK_NS6_4pairISO_SP_EE:
  158|    298|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|    298|  const auto& key = std::get<0>(p.first);
  160|    298|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|    298|                            std::move(p.second));
  162|    298|}
_ZN4absl12lts_2026010718container_internal15map_slot_policyINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEiE9constructINS3_9allocatorINS3_4pairIKS7_iEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRSC_EEENSI_IJRKiEEEEEEvPT_PNS1_13map_slot_typeIS7_iEEDpOT0_:
  397|    298|  static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
  398|    298|    emplace(slot);
  399|    298|    if (kMutableKeys::value) {
  ------------------
  |  Branch (399:9): [True: 298, Folded]
  ------------------
  400|    298|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
  401|    298|                                                   std::forward<Args>(args)...);
  402|    298|    } else {
  403|      0|      absl::allocator_traits<Allocator>::construct(*alloc, &slot->value,
  404|      0|                                                   std::forward<Args>(args)...);
  405|      0|    }
  406|    298|  }
_ZN4absl12lts_2026010718container_internal13DecomposePairINS1_12EqualElementINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEENS1_8StringEqEEEJRNS4_4pairIKNS4_12basic_stringIcS7_NS4_9allocatorIcEEEEhEEEEEDTclsr15memory_internalE17DecomposePairImplclsr3stdE7forwardIT_Efp_Ecl8PairArgsspclsr3stdE7forwardIT0_Efp0_EEEEOSJ_DpOSK_:
  226|    260|        std::forward<F>(f), PairArgs(std::forward<Args>(args)...))) {
  227|    260|  return memory_internal::DecomposePairImpl(
  228|    260|      std::forward<F>(f), PairArgs(std::forward<Args>(args)...));
  229|    260|}
_ZN4absl12lts_2026010718container_internal15memory_internal17DecomposePairImplINS1_12EqualElementINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEENS1_8StringEqEEERKNS5_12basic_stringIcS8_NS5_9allocatorIcEEEENS5_5tupleIJRKhEEEEEDTclclsr3stdE7declvalIT_EEclsr3stdE7declvalIRKT0_EEL_ZNS5_19piecewise_constructEEclsr3stdE7declvalINSI_IJSN_EEEEEclsr3stdE7declvalIT1_EEEEOSM_NS5_4pairISQ_SR_EE:
  158|    260|DecomposePairImpl(F&& f, std::pair<std::tuple<K>, V> p) {
  159|    260|  const auto& key = std::get<0>(p.first);
  160|    260|  return std::forward<F>(f)(key, std::piecewise_construct, std::move(p.first),
  161|    260|                            std::move(p.second));
  162|    260|}
_ZNK4absl12lts_2026010718container_internal12EqualElementINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEENS1_8StringEqEEclINS3_12basic_stringIcS6_NS3_9allocatorIcEEEEJRKNS3_21piecewise_construct_tENS3_5tupleIJRKSE_EEENSI_IJRKhEEEEEEbRKT_DpOT0_:
  529|    260|  bool operator()(const K2& lhs, Args&&...) const {
  530|    260|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(eq(lhs, rhs));
  ------------------
  |  |  488|    260|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  531|    260|  }

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

_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE5applyINS1_12EqualElementISA_NS1_8StringEqEEEJRNS4_4pairIKSA_hEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|     26|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|     26|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|     26|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE5applyINS1_11HashElementINS1_10StringHashELb1EEEJRNS4_4pairIKSA_hEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSM_DpOSN_:
  130|    434|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|    434|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|    434|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE5applyINS1_12EqualElementIS8_NS1_8StringEqEEEJRNS4_4pairIKS8_iEEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSK_DpOSL_:
  130|     10|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|     10|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|     10|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEvE5applyINS1_12raw_hash_setIS9_JEE19EmplaceDecomposableEJRKNS4_4pairIKS8_iEEES9_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSL_DpOSM_:
  130|    298|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|    298|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|    298|  }
_ZN4absl12lts_2026010718container_internal18hash_policy_traitsINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEvE5applyINS1_12EqualElementINS4_17basic_string_viewIcS7_EENS1_8StringEqEEEJRNS4_4pairIKSA_hEEESB_EEDTclsrT1_5applyclsr3stdE7forwardIT_Efp_Espclsr3stdE7forwardIT0_Efp0_EEEOSO_DpOSP_:
  130|    260|      -> decltype(P::apply(std::forward<F>(f), std::forward<Ts>(ts)...)) {
  131|    260|    return P::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
  132|    260|  }

_ZN4absl12lts_2026010718container_internal13GroupSse2ImplC2EPKNS1_6ctrl_tE:
  280|    890|  explicit GroupSse2Impl(const ctrl_t* pos) {
  281|    890|    ctrl = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pos));
  282|    890|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl5MatchEh:
  285|    839|  BitMaskType Match(h2_t hash) const {
  286|    839|    auto match = _mm_set1_epi8(static_cast<char>(hash));
  287|    839|    return BitMaskType(
  288|    839|        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  289|    839|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl9MaskEmptyEv:
  292|    583|  NonIterableBitMaskType MaskEmpty() const {
  293|       |#ifdef ABSL_INTERNAL_HAVE_SSSE3
  294|       |    // This only works because ctrl_t::kEmpty is -128.
  295|       |    return NonIterableBitMaskType(
  296|       |        static_cast<uint16_t>(_mm_movemask_epi8(_mm_sign_epi8(ctrl, ctrl))));
  297|       |#else
  298|    583|    auto match = _mm_set1_epi8(static_cast<char>(ctrl_t::kEmpty));
  299|    583|    return NonIterableBitMaskType(
  300|    583|        static_cast<uint16_t>(_mm_movemask_epi8(_mm_cmpeq_epi8(match, ctrl))));
  301|    583|#endif
  302|    583|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl8MaskFullEv:
  307|     31|  BitMaskType MaskFull() const {
  308|     31|    return BitMaskType(static_cast<uint16_t>(_mm_movemask_epi8(ctrl) ^ 0xffff));
  309|     31|  }
_ZNK4absl12lts_2026010718container_internal13GroupSse2Impl11MaskNonFullEv:
  314|     12|  auto MaskNonFull() const {
  315|     12|    return BitMaskType(static_cast<uint16_t>(_mm_movemask_epi8(ctrl)));
  316|     12|  }
_ZN4absl12lts_2026010718container_internal16IsEmptyOrDeletedENS1_6ctrl_tE:
  228|     79|inline bool IsEmptyOrDeleted(ctrl_t c) { return c < ctrl_t::kSentinel; }
_ZN4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EEC2Et:
  133|  1.75k|  explicit BitMask(T mask) : Base(mask) {
  134|  1.75k|    if (Shift == 3 && !NullifyBitsOnIteration) {
  ------------------
  |  Branch (134:9): [Folded, False: 1.75k]
  |  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|  1.75k|  }
_ZN4absl12lts_2026010718container_internal18NonIterableBitMaskItLi16ELi0EEC2Et:
   85|  2.34k|  explicit NonIterableBitMask(T mask) : mask_(mask) {}
_ZNK4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EE5beginEv:
  153|    870|  BitMask begin() const { return *this; }
_ZNK4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EE3endEv:
  154|    870|  BitMask end() const { return BitMask(0); }
_ZN4absl12lts_2026010718container_internalneERKNS1_7BitMaskItLi16ELi0ELb0EEES5_:
  160|  1.34k|  friend bool operator!=(const BitMask& a, const BitMask& b) {
  161|  1.34k|    return a.mask_ != b.mask_;
  162|  1.34k|  }
_ZNK4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EEdeEv:
  151|    729|  uint32_t operator*() const { return Base::LowestBitSet(); }
_ZNK4absl12lts_2026010718container_internal18NonIterableBitMaskItLi16ELi0EE12LowestBitSetEv:
   90|  1.29k|  uint32_t LowestBitSet() const {
   91|  1.29k|    return container_internal::TrailingZeros(mask_) >> Shift;
   92|  1.29k|  }
_ZN4absl12lts_2026010718container_internal13TrailingZerosItEEjT_:
   63|  1.29k|uint32_t TrailingZeros(T x) {
   64|  1.29k|  ABSL_ASSUME(x != 0);
  ------------------
  |  |  270|  1.29k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
   65|  1.29k|  return static_cast<uint32_t>(countr_zero(x));
   66|  1.29k|}
_ZNK4absl12lts_2026010718container_internal18NonIterableBitMaskItLi16ELi0EEcvbEv:
   87|    603|  explicit operator bool() const { return this->mask_ != 0; }
_ZN4absl12lts_2026010718container_internal7BitMaskItLi16ELi0ELb0EEppEv:
  143|    473|  BitMask& operator++() {
  144|    473|    if (Shift == 3 && NullifyBitsOnIteration) {
  ------------------
  |  Branch (144:9): [Folded, False: 473]
  |  Branch (144:23): [Folded, False: 0]
  ------------------
  145|      0|      this->mask_ &= kMsbs8Bytes;
  146|      0|    }
  147|    473|    this->mask_ &= (this->mask_ - 1);
  148|    473|    return *this;
  149|    473|  }

_ZN4absl12lts_2026010718container_internal21ShouldSampleNextTableEv:
  243|      3|inline bool ShouldSampleNextTable() {
  244|       |#if defined(ABSL_INTERNAL_HASHTABLEZ_SAMPLE)
  245|       |  if (ABSL_PREDICT_TRUE(--global_next_sample.next_sample > 0)) {
  246|       |    return false;
  247|       |  }
  248|       |  return true;
  249|       |#else
  250|      3|  return false;
  251|      3|#endif  // ABSL_INTERNAL_HASHTABLEZ_SAMPLE
  252|      3|}

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

_ZNK4absl12lts_2026010718container_internal12PerTableSeed4seedEv:
  445|  1.24k|  size_t seed() const {
  446|       |    // We use a sign-extended load to ensure high bits are non-zero.
  447|  1.24k|    int16_t seed_signed = absl::bit_cast<int16_t>(seed_);
  448|  1.24k|    auto seed_sign_extended =
  449|  1.24k|        static_cast<std::make_signed_t<size_t>>(seed_signed);
  450|  1.24k|    return absl::bit_cast<size_t>(seed_sign_extended);
  451|  1.24k|  }
_ZN4absl12lts_2026010718container_internal12PerTableSeedC2Et:
  455|  1.24k|  explicit PerTableSeed(uint16_t seed) : seed_(seed) {
  456|       |    ABSL_SWISSTABLE_ASSERT((seed & kSignBit) != 0 || seed == 0);
  ------------------
  |  |  248|  1.24k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  457|  1.24k|  }
_ZN4absl12lts_2026010718container_internal13HashtableSizeC2ENS1_19no_seed_empty_tag_tE:
  472|      3|  explicit HashtableSize(no_seed_empty_tag_t) : data_(0) {}
_ZNK4absl12lts_2026010718container_internal13HashtableSize4sizeEv:
  476|     13|  size_t size() const { return static_cast<size_t>(data_ >> kSizeShift); }
_ZNK4absl12lts_2026010718container_internal13HashtableSize4seedEv:
  487|  1.24k|  PerTableSeed seed() const {
  488|  1.24k|    return PerTableSeed(static_cast<size_t>(data_) & kSeedMask);
  489|  1.24k|  }
_ZNK4absl12lts_2026010718container_internal13HashtableSize9has_infozEv:
  502|    556|  bool has_infoz() const {
  503|    556|    return ABSL_PREDICT_FALSE((data_ & kHasInfozMask) != 0);
  ------------------
  |  |  189|    556|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:49): [Folded, False: 556]
  |  |  |  Branch (189:58): [True: 0, False: 556]
  |  |  ------------------
  ------------------
  504|    556|  }
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled19set_reserved_growthEm:
  631|      3|  void set_reserved_growth(size_t) {}
_ZN4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled20set_reservation_sizeEm:
  633|      5|  void set_reservation_size(size_t) {}
_ZNK4absl12lts_2026010718container_internal34CommonFieldsGenerationInfoDisabled14generation_ptrEv:
  636|  1.06k|  GenerationType* generation_ptr() const { return nullptr; }
_ZN4absl12lts_2026010718container_internal37HashSetIteratorGenerationInfoDisabledC2EPKh:
  660|  1.06k|  explicit HashSetIteratorGenerationInfoDisabled(const GenerationType*) {}
_ZNK4absl12lts_2026010718container_internal37HashSetIteratorGenerationInfoDisabled10generationEv:
  662|  1.18k|  GenerationType generation() const { return 0; }
_ZNK4absl12lts_2026010718container_internal37HashSetIteratorGenerationInfoDisabled14generation_ptrEv:
  664|  1.77k|  const GenerationType* generation_ptr() const { return nullptr; }
_ZNK4absl12lts_2026010718container_internal9HeapOrSoo7controlEv:
  880|  4.12k|  MaybeInitializedPtr<ctrl_t> control() const {
  881|  4.12k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.control);
  ------------------
  |  |  488|  4.12k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  882|  4.12k|  }
_ZNK4absl12lts_2026010718container_internal9HeapOrSoo10slot_arrayEv:
  886|  2.52k|  MaybeInitializedPtr<void> slot_array() const {
  887|  2.52k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(heap.slot_array);
  ------------------
  |  |  488|  2.52k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  888|  2.52k|  }
_ZN4absl12lts_2026010718container_internal12CommonFieldsC2ENS1_13non_soo_tag_tE:
  919|      3|      : capacity_(0), size_(no_seed_empty_tag_t{}) {}
_ZNK4absl12lts_2026010718container_internal12CommonFields7controlEv:
  948|  4.12k|  ctrl_t* control() const {
  949|  4.12k|    ABSL_SWISSTABLE_ASSERT(capacity() > 0);
  ------------------
  |  |  248|  4.12k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  950|       |    // Assume that the control bytes don't alias `this`.
  951|  4.12k|    ctrl_t* ctrl = heap_or_soo_.control().get();
  952|  4.12k|    [[maybe_unused]] size_t num_control_bytes = NumControlBytes(capacity());
  953|  4.12k|    ABSL_ASSUME(reinterpret_cast<uintptr_t>(ctrl + num_control_bytes) <=
  ------------------
  |  |  270|  8.17k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  |  |  ------------------
  |  |  |  Branch (270:44): [True: 68, False: 4.05k]
  |  |  |  Branch (270:44): [True: 4.05k, False: 0]
  |  |  ------------------
  ------------------
  954|  4.12k|                    reinterpret_cast<uintptr_t>(this) ||
  955|  4.12k|                reinterpret_cast<uintptr_t>(this + 1) <=
  956|  4.12k|                    reinterpret_cast<uintptr_t>(ctrl));
  957|  4.12k|    ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(ctrl);
  ------------------
  |  |  488|  4.12k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
  958|  4.12k|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields10slot_arrayEv:
  963|  2.52k|  void* slot_array() const { return heap_or_soo_.slot_array().get(); }
_ZNK4absl12lts_2026010718container_internal12CommonFields11slots_unionEv:
  964|      1|  MaybeInitializedPtr<void> slots_union() const {
  965|      1|    return heap_or_soo_.slot_array();
  966|      1|  }
_ZNK4absl12lts_2026010718container_internal12CommonFields4sizeEv:
  970|     13|  size_t size() const { return size_.size(); }
_ZNK4absl12lts_2026010718container_internal12CommonFields4seedEv:
  996|  1.24k|  PerTableSeed seed() const { return size_.seed(); }
_ZNK4absl12lts_2026010718container_internal12CommonFields8capacityEv:
 1012|  6.62k|  size_t capacity() const { return capacity_; }
_ZNK4absl12lts_2026010718container_internal12CommonFields8is_smallEv:
 1019|    812|  bool is_small() const { return IsSmallCapacity(capacity_); }
_ZNK4absl12lts_2026010718container_internal12CommonFields9has_infozEv:
 1035|    556|  bool has_infoz() const { return size_.has_infoz(); }
_ZN4absl12lts_2026010718container_internal12CommonFields5infozEv:
 1050|    556|  HashtablezInfoHandle infoz() {
 1051|    556|    return has_infoz() ? *infoz_ptr() : HashtablezInfoHandle();
  ------------------
  |  Branch (1051:12): [True: 0, False: 556]
  ------------------
 1052|    556|  }
_ZN4absl12lts_2026010718container_internal10SooControlEv:
  395|      1|inline ctrl_t* SooControl() {
  396|       |  // Const must be cast away here; no uses of this function will actually write
  397|       |  // to it because it is only used for SOO iterators.
  398|      1|  return const_cast<ctrl_t*>(kSooControl);
  399|      1|}
_ZN4absl12lts_2026010718container_internal11SooCapacityEv:
  419|      2|constexpr size_t SooCapacity() { return 1; }
_ZN4absl12lts_2026010718container_internal2H1Em:
  529|  1.24k|inline size_t H1(size_t hash) { return hash; }
_ZN4absl12lts_2026010718container_internal2H2Em:
  534|  1.79k|inline h2_t H2(size_t hash) { return hash >> (sizeof(size_t) * 8 - 7); }
_ZN4absl12lts_2026010718container_internal15IsSmallCapacityEm:
  775|  4.95k|constexpr bool IsSmallCapacity(size_t capacity) { return capacity <= 1; }
_ZN4absl12lts_2026010718container_internal14NumClonedBytesEv:
  782|  5.25k|constexpr size_t NumClonedBytes() { return Group::kWidth - 1; }
_ZN4absl12lts_2026010718container_internal15NumControlBytesEm:
  785|  4.13k|constexpr size_t NumControlBytes(size_t capacity) {
  786|  4.13k|  return IsSmallCapacity(capacity) ? 0 : capacity + 1 + NumClonedBytes();
  ------------------
  |  Branch (786:10): [True: 3, False: 4.13k]
  ------------------
  787|  4.13k|}
_ZN4absl12lts_2026010718container_internal13ControlOffsetEb:
  791|     19|constexpr size_t ControlOffset(bool has_infoz) {
  792|     19|  return (has_infoz ? sizeof(HashtablezInfoHandle) : 0) + sizeof(GrowthInfo);
  ------------------
  |  Branch (792:11): [True: 0, False: 19]
  ------------------
  793|     19|}
_ZN4absl12lts_2026010718container_internal16PreviousCapacityEm:
 1151|      5|constexpr size_t PreviousCapacity(size_t n) {
 1152|       |  ABSL_SWISSTABLE_ASSERT(IsValidCapacity(n));
  ------------------
  |  |  248|      5|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1153|      5|  return n / 2;
 1154|      5|}
_ZN4absl12lts_2026010718container_internal12AssertIsFullEPKNS1_6ctrl_tEhPKhPKc:
 1243|    590|                         const char* operation) {
 1244|    590|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1244:7): [True: 590, Folded]
  ------------------
 1245|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1246|       |  // enabled. To minimize their impact in those builds:
 1247|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1248|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1249|       |  //   the chances that the hot paths will be inlined.
 1250|      0|  if (ABSL_PREDICT_FALSE(ctrl == nullptr)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1251|      0|    ABSL_RAW_LOG(FATAL, "%s called on end() iterator.", operation);
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1252|      0|  }
 1253|      0|  if (ABSL_PREDICT_FALSE(ctrl == DefaultIterControl())) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1254|      0|    ABSL_RAW_LOG(FATAL, "%s called on default-constructed iterator.",
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1255|      0|                 operation);
 1256|      0|  }
 1257|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1257:7): [Folded, False: 0]
  ------------------
 1258|      0|    if (ABSL_PREDICT_FALSE(generation != *generation_ptr)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1259|      0|      ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1260|      0|                   "%s called on invalid iterator. The table could have "
 1261|      0|                   "rehashed or moved since this iterator was initialized.",
 1262|      0|                   operation);
 1263|      0|    }
 1264|      0|    if (ABSL_PREDICT_FALSE(!IsFull(*ctrl))) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1265|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1266|      0|          FATAL,
 1267|      0|          "%s called on invalid iterator. The element was likely erased.",
 1268|      0|          operation);
 1269|      0|    }
 1270|      0|  } else {
 1271|      0|    if (ABSL_PREDICT_FALSE(!IsFull(*ctrl))) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1272|       |      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1273|      0|          FATAL,
 1274|      0|          "%s called on invalid iterator. The element might have been erased "
 1275|      0|          "or the table might have rehashed. Consider running with "
 1276|      0|          "--config=asan to diagnose rehashing issues.",
 1277|      0|          operation);
 1278|      0|    }
 1279|      0|  }
 1280|      0|}
_ZN4absl12lts_2026010718container_internal26AssertIsValidForComparisonEPKNS1_6ctrl_tEhPKh:
 1285|    592|                                       const GenerationType* generation_ptr) {
 1286|    592|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1286:7): [True: 592, Folded]
  ------------------
 1287|      0|  const bool ctrl_is_valid_for_comparison =
 1288|      0|      ctrl == nullptr || ctrl == DefaultIterControl() || IsFull(*ctrl);
  ------------------
  |  Branch (1288:7): [True: 0, False: 0]
  |  Branch (1288:26): [True: 0, False: 0]
  |  Branch (1288:58): [True: 0, False: 0]
  ------------------
 1289|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1289:7): [Folded, False: 0]
  ------------------
 1290|      0|    if (ABSL_PREDICT_FALSE(generation != *generation_ptr)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1291|      0|      ABSL_RAW_LOG(FATAL,
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1292|      0|                   "Invalid iterator comparison. The table could have rehashed "
 1293|      0|                   "or moved since this iterator was initialized.");
 1294|      0|    }
 1295|      0|    if (ABSL_PREDICT_FALSE(!ctrl_is_valid_for_comparison)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1296|      0|      ABSL_RAW_LOG(
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 1297|      0|          FATAL, "Invalid iterator comparison. The element was likely erased.");
 1298|      0|    }
 1299|      0|  } else {
 1300|      0|    ABSL_HARDENING_ASSERT_SLOW(
  ------------------
  |  |  159|      0|#define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|      0|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1301|      0|        ctrl_is_valid_for_comparison &&
 1302|      0|        "Invalid iterator comparison. The element might have been erased or "
 1303|      0|        "the table might have rehashed. Consider running with --config=asan to "
 1304|      0|        "diagnose rehashing issues.");
 1305|      0|  }
 1306|      0|}
_ZN4absl12lts_2026010718container_internal19AssertSameContainerEPKNS1_6ctrl_tES4_RKPKvS8_PKhSA_:
 1338|    296|                                const GenerationType* generation_ptr_b) {
 1339|    296|  if (!SwisstableDebugEnabled()) return;
  ------------------
  |  Branch (1339:7): [True: 296, Folded]
  ------------------
 1340|       |  // `SwisstableDebugEnabled()` is also true for release builds with hardening
 1341|       |  // enabled. To minimize their impact in those builds:
 1342|       |  // - use `ABSL_PREDICT_FALSE()` to provide a compiler hint for code layout
 1343|       |  // - use `ABSL_RAW_LOG()` with a format string to reduce code size and improve
 1344|       |  //   the chances that the hot paths will be inlined.
 1345|       |
 1346|       |  // fail_if(is_invalid, message) crashes when is_invalid is true and provides
 1347|       |  // an error message based on `message`.
 1348|      0|  const auto fail_if = [](bool is_invalid, const char* message) {
 1349|      0|    if (ABSL_PREDICT_FALSE(is_invalid)) {
 1350|      0|      ABSL_RAW_LOG(FATAL, "Invalid iterator comparison. %s", message);
 1351|      0|    }
 1352|      0|  };
 1353|       |
 1354|      0|  const bool a_is_default = ctrl_a == DefaultIterControl();
 1355|      0|  const bool b_is_default = ctrl_b == DefaultIterControl();
 1356|      0|  if (a_is_default && b_is_default) return;
  ------------------
  |  Branch (1356:7): [True: 0, False: 0]
  |  Branch (1356:23): [True: 0, False: 0]
  ------------------
 1357|      0|  fail_if(a_is_default != b_is_default,
 1358|      0|          "Comparing default-constructed hashtable iterator with a "
 1359|      0|          "non-default-constructed hashtable iterator.");
 1360|       |
 1361|      0|  if (SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (1361:7): [Folded, False: 0]
  ------------------
 1362|      0|    if (ABSL_PREDICT_TRUE(generation_ptr_a == generation_ptr_b)) return;
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 0]
  |  |  |  Branch (190:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 1363|      0|    const bool a_is_empty = IsEmptyGeneration(generation_ptr_a);
 1364|      0|    const bool b_is_empty = IsEmptyGeneration(generation_ptr_b);
 1365|      0|    fail_if(a_is_empty != b_is_empty,
 1366|      0|            "Comparing an iterator from an empty hashtable with an iterator "
 1367|      0|            "from a non-empty hashtable.");
 1368|      0|    fail_if(a_is_empty && b_is_empty,
  ------------------
  |  Branch (1368:13): [True: 0, False: 0]
  |  Branch (1368:27): [True: 0, False: 0]
  ------------------
 1369|      0|            "Comparing iterators from different empty hashtables.");
 1370|       |
 1371|      0|    const bool a_is_end = ctrl_a == nullptr;
 1372|      0|    const bool b_is_end = ctrl_b == nullptr;
 1373|      0|    fail_if(a_is_end || b_is_end,
  ------------------
  |  Branch (1373:13): [True: 0, False: 0]
  |  Branch (1373:25): [True: 0, False: 0]
  ------------------
 1374|      0|            "Comparing iterator with an end() iterator from a different "
 1375|      0|            "hashtable.");
 1376|      0|    fail_if(true, "Comparing non-end() iterators from different hashtables.");
 1377|      0|  } else {
 1378|      0|    ABSL_HARDENING_ASSERT_SLOW(
  ------------------
  |  |  159|      0|#define ABSL_HARDENING_ASSERT_SLOW(expr) ABSL_ASSERT(expr)
  |  |  ------------------
  |  |  |  |  106|      0|#define ABSL_ASSERT(expr) (false ? ((expr) ? void() : void()) : void())
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (106:28): [Folded, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, False: 0]
  |  |  |  |  |  Branch (106:38): [True: 0, Folded]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1379|      0|        AreItersFromSameContainer(ctrl_a, ctrl_b, slot_a, slot_b) &&
 1380|      0|        "Invalid iterator comparison. The iterators may be from different "
 1381|      0|        "containers or the container might have rehashed or moved. Consider "
 1382|      0|        "running with --config=asan to diagnose issues.");
 1383|      0|  }
 1384|      0|}
_ZN4absl12lts_2026010718container_internal8probe_h1Emm:
 1398|    823|inline probe_seq<Group::kWidth> probe_h1(size_t capacity, size_t h1) {
 1399|    823|  return probe_seq<Group::kWidth>(h1, capacity);
 1400|    823|}
_ZN4absl12lts_2026010718container_internal5probeEmm:
 1401|    808|inline probe_seq<Group::kWidth> probe(size_t capacity, size_t hash) {
 1402|    808|  return probe_h1(capacity, H1(hash));
 1403|    808|}
_ZN4absl12lts_2026010718container_internal5probeERKNS1_12CommonFieldsEm:
 1404|    808|inline probe_seq<Group::kWidth> probe(const CommonFields& common, size_t hash) {
 1405|    808|  return probe(common.capacity(), hash);
 1406|    808|}
_ZNK4absl12lts_2026010718container_internal19MaybeInitializedPtrINS1_6ctrl_tEE3getEv:
  849|  4.12k|  T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
  ------------------
  |  |  488|  4.12k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
_ZNK4absl12lts_2026010718container_internal19MaybeInitializedPtrIvE3getEv:
  849|  2.52k|  T* get() const { ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(p); }
  ------------------
  |  |  488|  2.52k|#define ABSL_SWISSTABLE_IGNORE_UNINITIALIZED_RETURN(x) return x
  ------------------
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE10SooEnabledEv:
 1856|      1|  constexpr static bool SooEnabled() {
 1857|      1|    return PolicyTraits::soo_enabled() &&
  ------------------
  |  Branch (1857:12): [True: 0, Folded]
  ------------------
 1858|      0|           sizeof(slot_type) <= sizeof(HeapOrSoo) &&
  ------------------
  |  Branch (1858:12): [Folded, False: 0]
  ------------------
 1859|      0|           alignof(slot_type) <= alignof(HeapOrSoo);
  ------------------
  |  Branch (1859:12): [True: 0, Folded]
  ------------------
 1860|      1|  }
_ZN4absl12lts_2026010718container_internal12CommonFields13CreateDefaultILb0EEES2_v:
  939|      3|  static CommonFields CreateDefault() {
  940|      3|    return kSooEnabled ? CommonFields{soo_tag_t{}}
  ------------------
  |  Branch (940:12): [Folded, False: 3]
  ------------------
  941|      3|                       : CommonFields{non_soo_tag_t{}};
  942|      3|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE15DefaultCapacityEv:
 1862|      2|  constexpr static size_t DefaultCapacity() {
 1863|      2|    return SooEnabled() ? SooCapacity() : 0;
  ------------------
  |  Branch (1863:12): [Folded, False: 2]
  ------------------
 1864|      2|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8capacityEv:
 2331|      3|  size_t capacity() const {
 2332|      3|    const size_t cap = common().capacity();
 2333|       |    // Compiler complains when using functions in ASSUME so use local variable.
 2334|      3|    [[maybe_unused]] static constexpr size_t kDefaultCapacity =
 2335|      3|        DefaultCapacity();
 2336|      3|    ABSL_ASSUME(cap >= kDefaultCapacity);
  ------------------
  |  |  270|      3|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2337|      3|    return cap;
 2338|      3|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6commonEv:
 3431|  2.10k|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8is_smallEv:
 1874|    300|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5emptyEv:
 2326|      1|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE4sizeEv:
 2327|      1|  size_t size() const {
 2328|      1|    AssertNotDebugCapacity();
 2329|      1|    return common().size();
 2330|      1|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22AssertNotDebugCapacityEv:
 3285|    303|  void AssertNotDebugCapacity() const {
 3286|    303|#ifdef NDEBUG
 3287|    303|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 303, Folded]
  ------------------
 3288|    303|      return;
 3289|    303|    }
 3290|      0|#endif
 3291|      0|    if (ABSL_PREDICT_TRUE(capacity() <
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 0]
  |  |  |  Branch (190:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3292|      0|                          InvalidCapacity::kAboveMaxValidCapacity)) {
 3293|      0|      return;
 3294|      0|    }
 3295|      0|    assert(capacity() != InvalidCapacity::kReentrance &&
 3296|      0|           "Reentrant container access during element construction/destruction "
 3297|      0|           "is not allowed.");
 3298|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3299|       |      if (capacity() == InvalidCapacity::kDestroyed) {
 3300|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3301|       |      }
 3302|       |    }
 3303|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3303:9): [Folded, False: 0]
  ------------------
 3304|      0|        ABSL_PREDICT_FALSE(capacity() >= InvalidCapacity::kMovedFrom)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3305|      0|      if (capacity() == InvalidCapacity::kSelfMovedFrom) {
  ------------------
  |  Branch (3305:11): [True: 0, False: 0]
  ------------------
 3306|       |        // If this log triggers, then a hash table was move-assigned to itself
 3307|       |        // and then used again later without being reinitialized.
 3308|      0|        ABSL_RAW_LOG(FATAL, "Use of self-move-assigned hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3309|      0|      }
 3310|      0|      ABSL_RAW_LOG(FATAL, "Use of moved-from hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3311|      0|    }
 3312|      0|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6commonEv:
 3430|  1.20k|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE14char_alloc_refEv:
 3479|    299|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE10slot_arrayEv:
 3437|    606|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|    606|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|    606|    return static_cast<slot_type*>(common().slot_array());
 3440|    606|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE13destroy_slotsEv:
 2992|      1|  void destroy_slots() {
 2993|      1|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2994|      1|    if (PolicyTraits::template destroy_is_trivial<Alloc>()) return;
  ------------------
  |  Branch (2994:9): [True: 1, Folded]
  ------------------
 2995|      0|    auto destroy_slot = [&](const ctrl_t*, void* slot) {
 2996|      0|      this->destroy(static_cast<slot_type*>(slot));
 2997|      0|    };
 2998|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 2999|       |      CommonFields common_copy(non_soo_tag_t{}, this->common());
 3000|       |      common().set_capacity(InvalidCapacity::kDestroyed);
 3001|       |      IterateOverFullSlots(common_copy, sizeof(slot_type), destroy_slot);
 3002|       |      common().set_capacity(common_copy.capacity());
 3003|      0|    } else {
 3004|      0|      IterateOverFullSlots(common(), sizeof(slot_type), destroy_slot);
 3005|      0|    }
 3006|      0|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7controlEv:
 3433|    895|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|    895|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|    895|    return common().control();
 3436|    895|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEEC2Ev:
 2109|      1|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE15unchecked_derefENSC_8iteratorE:
 3394|    256|  reference unchecked_deref(iterator it) { return it.unchecked_deref(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iterator15unchecked_derefEv:
 2039|    512|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE22find_or_prepare_insertISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3358|    256|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|    256|    AssertOnFind(key);
 3360|    256|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 2, False: 254]
  ------------------
 3361|    254|    return find_or_prepare_insert_large(key);
 3362|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE12AssertOnFindISA_EEvRKT_:
 3279|    256|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|    256|    AssertHashEqConsistent(key);
 3281|    256|    AssertNotDebugCapacity();
 3282|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE22AssertHashEqConsistentISA_EEvRKT_:
 3317|    256|  void AssertHashEqConsistent(const K& key) {
 3318|    256|#ifdef NDEBUG
 3319|    256|    return;
 3320|      0|#endif
 3321|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3322|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3322:9): [True: 0, Folded]
  ------------------
 3323|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3323:9): [True: 0, Folded]
  ------------------
 3324|      0|      return;
 3325|      0|    }
 3326|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3326:9): [Folded, False: 0]
  ------------------
 3327|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3327:9): [Folded, False: 0]
  ------------------
 3328|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3328:9): [Folded, False: 0]
  ------------------
 3329|      0|      return;
 3330|      0|    }
 3331|      0|    if (empty()) return;
  ------------------
  |  Branch (3331:9): [True: 0, False: 0]
  ------------------
 3332|       |
 3333|      0|    const size_t hash_of_arg = hash_of(key);
 3334|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3335|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3336|      0|      if (!is_key_equal) return;
 3337|       |
 3338|      0|      [[maybe_unused]] const bool is_hash_equal =
 3339|      0|          hash_of_arg == hash_of(to_slot(slot));
 3340|      0|      assert((!is_key_equal || is_hash_equal) &&
 3341|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3342|      0|             "hash/eq functors are inconsistent.");
 3343|      0|    };
 3344|       |
 3345|      0|    if (is_small()) {
  ------------------
  |  Branch (3345:9): [True: 0, False: 0]
  ------------------
 3346|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3347|      0|      return;
 3348|      0|    }
 3349|       |    // We only do validation for small tables so that it's constant time.
 3350|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3350:9): [True: 0, False: 0]
  ------------------
 3351|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3352|      0|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE22AssertNotDebugCapacityEv:
 3285|    770|  void AssertNotDebugCapacity() const {
 3286|    770|#ifdef NDEBUG
 3287|    770|    if (!SwisstableGenerationsEnabled()) {
  ------------------
  |  Branch (3287:9): [True: 770, Folded]
  ------------------
 3288|    770|      return;
 3289|    770|    }
 3290|      0|#endif
 3291|      0|    if (ABSL_PREDICT_TRUE(capacity() <
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 0]
  |  |  |  Branch (190:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3292|      0|                          InvalidCapacity::kAboveMaxValidCapacity)) {
 3293|      0|      return;
 3294|      0|    }
 3295|      0|    assert(capacity() != InvalidCapacity::kReentrance &&
 3296|      0|           "Reentrant container access during element construction/destruction "
 3297|      0|           "is not allowed.");
 3298|       |    if constexpr (SwisstableAssertAccessToDestroyedTable()) {
 3299|       |      if (capacity() == InvalidCapacity::kDestroyed) {
 3300|       |        ABSL_RAW_LOG(FATAL, "Use of destroyed hash table.");
 3301|       |      }
 3302|       |    }
 3303|      0|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (3303:9): [Folded, False: 0]
  ------------------
 3304|      0|        ABSL_PREDICT_FALSE(capacity() >= InvalidCapacity::kMovedFrom)) {
  ------------------
  |  |  189|      0|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 0]
  |  |  |  Branch (189:49): [Folded, False: 0]
  |  |  |  Branch (189:58): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 3305|      0|      if (capacity() == InvalidCapacity::kSelfMovedFrom) {
  ------------------
  |  Branch (3305:11): [True: 0, False: 0]
  ------------------
 3306|       |        // If this log triggers, then a hash table was move-assigned to itself
 3307|       |        // and then used again later without being reinitialized.
 3308|      0|        ABSL_RAW_LOG(FATAL, "Use of self-move-assigned hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3309|      0|      }
 3310|      0|      ABSL_RAW_LOG(FATAL, "Use of moved-from hash table.");
  ------------------
  |  |   45|      0|  do {                                                                         \
  |  |   46|      0|    constexpr const char* absl_raw_log_internal_basename =                     \
  |  |   47|      0|        ::absl::raw_log_internal::Basename(__FILE__, sizeof(__FILE__) - 1);    \
  |  |   48|      0|    ::absl::raw_log_internal::RawLog(ABSL_RAW_LOG_INTERNAL_##severity,         \
  |  |  ------------------
  |  |  |  |  110|      0|#define ABSL_RAW_LOG_INTERNAL_FATAL ::absl::LogSeverity::kFatal
  |  |  ------------------
  |  |   49|      0|                                     absl_raw_log_internal_basename, __LINE__, \
  |  |   50|      0|                                     __VA_ARGS__);                             \
  |  |   51|      0|    ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_##severity;                        \
  |  |  ------------------
  |  |  |  |  118|      0|#define ABSL_RAW_LOG_INTERNAL_MAYBE_UNREACHABLE_FATAL ABSL_UNREACHABLE()
  |  |  |  |  ------------------
  |  |  |  |  |  |  236|      0|  do {                                           \
  |  |  |  |  |  |  237|      0|    /* NOLINTNEXTLINE: misc-static-assert */     \
  |  |  |  |  |  |  238|      0|    assert(false && "ABSL_UNREACHABLE reached"); \
  |  |  |  |  |  |  239|      0|    ABSL_INTERNAL_UNREACHABLE_IMPL();            \
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  214|      0|#define ABSL_INTERNAL_UNREACHABLE_IMPL() __builtin_unreachable()
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  240|      0|  } while (false)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (240:12): [Folded, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |   52|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (52:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
 3311|      0|    }
 3312|      0|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8is_smallEv:
 1874|    512|  bool is_small() const { return common().is_small(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE6commonEv:
 3431|  4.33k|  const CommonFields& common() const { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE28find_or_prepare_insert_smallISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3207|      2|  std::pair<iterator, bool> find_or_prepare_insert_small(const K& key) {
 3208|      2|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|      2|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3209|       |    if constexpr (SooEnabled()) {
 3210|       |      return find_or_prepare_insert_soo(key);
 3211|       |    }
 3212|      2|    if (!empty()) {
  ------------------
  |  Branch (3212:9): [True: 1, False: 1]
  ------------------
 3213|      1|      if (equal_to(key, single_slot())) {
  ------------------
  |  Branch (3213:11): [True: 0, False: 1]
  ------------------
 3214|      0|        common().infoz().RecordInsertHit();
 3215|      0|        return {single_iterator(), false};
 3216|      0|      }
 3217|      1|    }
 3218|      2|    return {iterator_at_ptr(PrepareInsertSmallNonSoo(
 3219|      2|                common(), GetPolicyFunctions(),
 3220|      2|                HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})),
 3221|      2|            true};
 3222|      2|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE5emptyEv:
 2326|      2|  bool empty() const { return !size(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE4sizeEv:
 2327|      2|  size_t size() const {
 2328|      2|    AssertNotDebugCapacity();
 2329|      2|    return common().size();
 2330|      2|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8equal_toISA_EEbRKT_PNS1_13map_slot_typeISA_hEE:
 3056|     26|                                             slot_type* slot) const {
 3057|     26|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|     26|                               PolicyTraits::element(slot));
 3059|     26|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE6eq_refEv:
 3478|    286|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE11single_slotEv:
 3450|      1|  slot_type* single_slot() {
 3451|      1|    ABSL_SWISSTABLE_ASSERT(is_small());
  ------------------
  |  |  248|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3452|      1|    return SooEnabled() ? soo_slot() : slot_array();
  ------------------
  |  Branch (3452:12): [Folded, False: 1]
  ------------------
 3453|      1|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE10slot_arrayEv:
 3437|  1.34k|  slot_type* slot_array() const {
 3438|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  1.34k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3439|  1.34k|    return static_cast<slot_type*>(common().slot_array());
 3440|  1.34k|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE6commonEv:
 3430|  2.23k|  CommonFields& common() { return settings_.template get<0>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeISA_hEEPKh:
 1993|    512|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|    512|          ctrl_(ctrl),
 1995|    512|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|    512|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|    512|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|    512|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE15iterator_at_ptrENS4_4pairIPNS1_6ctrl_tEPvEE:
 3390|      2|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3391|      2|    return {ptrs.first, to_slot(ptrs.second), common().generation_ptr()};
 3392|      2|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE7to_slotEPv:
 3073|     33|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|     33|    return static_cast<slot_type*>(buf);
 3075|     33|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE18GetPolicyFunctionsEv:
 3558|    256|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|    256|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|    256|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|    256|                  "or use absl::node_hash_{map,set}.");
 3562|    256|    static_assert(alignof(slot_type) <=
 3563|    256|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|    256|    static_assert(sizeof(key_type) <=
 3565|    256|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|    256|    static_assert(sizeof(value_type) <=
 3567|    256|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|    256|    static constexpr size_t kBackingArrayAlignment =
 3569|    256|        BackingArrayAlignment(alignof(slot_type));
 3570|    256|    static constexpr PolicyFunctions value = {
 3571|    256|        static_cast<uint32_t>(sizeof(key_type)),
 3572|    256|        static_cast<uint32_t>(sizeof(value_type)),
 3573|    256|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|    256|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|    256|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|    256|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|    256|                                : &raw_hash_set::get_hash_ref_fn,
 3580|    256|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|    256|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [Folded, False: 256]
  ------------------
 3582|    256|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|    256|            : &raw_hash_set::transfer_n_slots_fn,
 3584|    256|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|    256|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|    256|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|    256|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|    256|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|    256|    return value;
 3590|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE19transfer_n_slots_fnEPvSD_SD_m:
 3494|     13|                                  size_t count) {
 3495|     13|    auto* src_slot = to_slot(src);
 3496|     13|    auto* dst_slot = to_slot(dst);
 3497|       |
 3498|     13|    auto* h = static_cast<raw_hash_set*>(set);
 3499|     34|    for (; count > 0; --count, ++src_slot, ++dst_slot) {
  ------------------
  |  Branch (3499:12): [True: 21, False: 13]
  ------------------
 3500|     21|      h->transfer(dst_slot, src_slot);
 3501|     21|    }
 3502|     13|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8transferEPNS1_13map_slot_typeISA_hEESF_:
 2941|    445|  inline void transfer(slot_type* to, slot_type* from) {
 2942|    445|    common().RunWithReentrancyGuard([&] {
 2943|    445|      allocator_type alloc(char_alloc_ref());
 2944|    445|      PolicyTraits::transfer(&alloc, to, from);
 2945|    445|    });
 2946|    445|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEhEEJEE8transferEPNS1_13map_slot_typeISC_hEESH_EUlvE_EEvT_:
 1099|    445|  void RunWithReentrancyGuard(F f) {
 1100|    445|#ifdef NDEBUG
 1101|    445|    f();
 1102|    445|    return;
 1103|      0|#endif
 1104|      0|    const size_t cap = capacity();
 1105|      0|    set_capacity(InvalidCapacity::kReentrance);
 1106|      0|    f();
 1107|      0|    set_capacity(cap);
 1108|      0|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8transferEPNS1_13map_slot_typeISA_hEESF_ENKUlvE_clEv:
 2942|    445|    common().RunWithReentrancyGuard([&] {
 2943|    445|      allocator_type alloc(char_alloc_ref());
 2944|    445|      PolicyTraits::transfer(&alloc, to, from);
 2945|    445|    });
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE14char_alloc_refEv:
 3479|    701|  CharAlloc& char_alloc_ref() { return settings_.template get<3>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE46transfer_unprobed_elements_to_next_capacity_fnERNS1_12CommonFieldsEPKNS1_6ctrl_tEPvSI_PFvSI_hmmE:
 3511|      5|                                    size_t source_offset, size_t h1)) {
 3512|      5|    const size_t new_capacity = common.capacity();
 3513|      5|    const size_t old_capacity = PreviousCapacity(new_capacity);
 3514|      5|    ABSL_ASSUME(old_capacity + 1 >= Group::kWidth);
  ------------------
  |  |  270|      5|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3515|      5|    ABSL_ASSUME((old_capacity + 1) % Group::kWidth == 0);
  ------------------
  |  |  270|      5|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 3516|       |
 3517|      5|    auto* set = reinterpret_cast<raw_hash_set*>(&common);
 3518|      5|    slot_type* old_slots_ptr = to_slot(old_slots);
 3519|      5|    ctrl_t* new_ctrl = common.control();
 3520|      5|    slot_type* new_slots = set->slot_array();
 3521|       |
 3522|     36|    for (size_t group_index = 0; group_index < old_capacity;
  ------------------
  |  Branch (3522:34): [True: 31, False: 5]
  ------------------
 3523|     31|         group_index += Group::kWidth) {
 3524|     31|      GroupFullEmptyOrDeleted old_g(old_ctrl + group_index);
 3525|     31|      std::memset(new_ctrl + group_index, static_cast<int8_t>(ctrl_t::kEmpty),
 3526|     31|                  Group::kWidth);
 3527|     31|      std::memset(new_ctrl + group_index + old_capacity + 1,
 3528|     31|                  static_cast<int8_t>(ctrl_t::kEmpty), Group::kWidth);
 3529|       |      // TODO(b/382423690): try to type erase everything outside of the loop.
 3530|       |      // We will share a lot of code in expense of one function call per group.
 3531|    434|      for (auto in_fixed_group_index : old_g.MaskFull()) {
  ------------------
  |  Branch (3531:38): [True: 434, False: 31]
  ------------------
 3532|    434|        size_t old_index = group_index + in_fixed_group_index;
 3533|    434|        slot_type* old_slot = old_slots_ptr + old_index;
 3534|       |        // TODO(b/382423690): try to avoid entire hash calculation since we need
 3535|       |        // only one new bit of h1.
 3536|    434|        size_t hash = set->hash_of(old_slot);
 3537|    434|        size_t h1 = H1(hash);
 3538|    434|        h2_t h2 = H2(hash);
 3539|    434|        size_t new_index = TryFindNewIndexWithoutProbing(
 3540|    434|            h1, old_index, old_capacity, new_ctrl, new_capacity);
 3541|       |        // Note that encode_probed_element is allowed to use old_ctrl buffer
 3542|       |        // till and included the old_index.
 3543|    434|        if (ABSL_PREDICT_FALSE(new_index == kProbedElementIndexSentinel)) {
  ------------------
  |  |  189|    434|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 10, False: 424]
  |  |  |  Branch (189:49): [Folded, False: 434]
  |  |  |  Branch (189:58): [True: 10, False: 424]
  |  |  ------------------
  ------------------
 3544|     10|          encode_probed_element(probed_storage, h2, old_index, h1);
 3545|     10|          continue;
 3546|     10|        }
 3547|    424|        ABSL_SWISSTABLE_ASSERT((new_index & old_capacity) <= old_index);
  ------------------
  |  |  248|    424|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3548|       |        ABSL_SWISSTABLE_ASSERT(IsEmpty(new_ctrl[new_index]));
  ------------------
  |  |  248|    424|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3549|    424|        new_ctrl[new_index] = static_cast<ctrl_t>(h2);
 3550|    424|        auto* new_slot = new_slots + new_index;
 3551|    424|        SanitizerUnpoisonMemoryRegion(new_slot, sizeof(slot_type));
 3552|    424|        set->transfer(new_slot, old_slot);
 3553|    424|        SanitizerPoisonMemoryRegion(old_slot, sizeof(slot_type));
 3554|    424|      }
 3555|     31|    }
 3556|      5|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE7hash_ofEPNS1_13map_slot_typeISA_hEE:
 3065|    434|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(slot_type* slot) const {
 3066|    434|    return PolicyTraits::apply(
 3067|    434|        HashElement<hasher, kIsDefaultHash>{hash_ref(), common().seed().seed()},
 3068|    434|        PolicyTraits::element(slot));
 3069|    434|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8hash_refEv:
 3476|    944|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal29TryFindNewIndexWithoutProbingIvEEmmmmPNS1_6ctrl_tEm:
 1425|    434|                                            size_t new_capacity) {
 1426|    434|  size_t index_diff = old_index - h1;
 1427|       |  // The first probe group starts with h1 & capacity.
 1428|       |  // All following groups start at (h1 + Group::kWidth * K) & capacity.
 1429|       |  // We can find an index within the floating group as index_diff modulo
 1430|       |  // Group::kWidth.
 1431|       |  // Both old and new capacity are larger than Group::kWidth so we can avoid
 1432|       |  // computing `& capacity`.
 1433|    434|  size_t in_floating_group_index = index_diff & (Group::kWidth - 1);
 1434|       |  // By subtracting we will get the difference between the first probe group
 1435|       |  // and the probe group corresponding to old_index.
 1436|    434|  index_diff -= in_floating_group_index;
 1437|    434|  if (ABSL_PREDICT_TRUE((index_diff & old_capacity) == 0)) {
  ------------------
  |  |  190|    434|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 412, False: 22]
  |  |  |  Branch (190:48): [Folded, False: 434]
  |  |  |  Branch (190:57): [True: 412, False: 22]
  |  |  ------------------
  ------------------
 1438|    412|    size_t new_index = (h1 + in_floating_group_index) & new_capacity;
 1439|    412|    ABSL_ASSUME(new_index != kProbedElementIndexSentinel);
  ------------------
  |  |  270|    412|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1440|    412|    return new_index;
 1441|    412|  }
 1442|     22|  ABSL_SWISSTABLE_ASSERT(((old_index - h1) & old_capacity) >= Group::kWidth);
  ------------------
  |  |  248|     22|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 1443|       |  // Try to insert element into the first probe group.
 1444|       |  // new_ctrl is not yet fully initialized so we can't use regular search via
 1445|       |  // find_first_non_full.
 1446|       |
 1447|       |  // We can search in the first probe group only if it is located in already
 1448|       |  // initialized part of the table.
 1449|     22|  if (ABSL_PREDICT_FALSE((h1 & old_capacity) >= old_index)) {
  ------------------
  |  |  189|     22|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 10, False: 12]
  |  |  |  Branch (189:49): [Folded, False: 22]
  |  |  |  Branch (189:58): [True: 10, False: 12]
  |  |  ------------------
  ------------------
 1450|     10|    return kProbedElementIndexSentinel;
 1451|     10|  }
 1452|     12|  size_t offset = h1 & new_capacity;
 1453|     12|  Group new_g(new_ctrl + offset);
 1454|     12|  if (auto mask = new_g.MaskNonFull(); ABSL_PREDICT_TRUE(mask)) {
  ------------------
  |  |  190|     12|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 12, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 12]
  |  |  |  Branch (190:57): [True: 12, False: 0]
  |  |  ------------------
  ------------------
 1455|     12|    size_t result = offset + mask.LowestBitSet();
 1456|     12|    ABSL_ASSUME(result != kProbedElementIndexSentinel);
  ------------------
  |  |  270|     12|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1457|     12|    return result;
 1458|     12|  }
 1459|      0|  return kProbedElementIndexSentinel;
 1460|     12|}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8hash_refEv:
 3475|      2|  hasher& hash_ref() { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_:
 3225|    254|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|    254|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|    254|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|    254|    prefetch_heap_block();
 3228|    254|    const size_t hash = hash_of(key);
 3229|    254|    auto seq = probe(common(), hash);
 3230|    254|    const h2_t h2 = H2(hash);
 3231|    254|    const ctrl_t* ctrl = control();
 3232|    254|    size_t index;
 3233|    254|    bool inserted;
 3234|       |    // We use a lambda function to be able to exit from the nested loop without
 3235|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3236|    254|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|    254|      while (true) {
 3238|    254|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|    254|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|    254|#endif
 3241|    254|        Group g{ctrl + seq.offset()};
 3242|    254|        for (uint32_t i : g.Match(h2)) {
 3243|    254|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|    254|            index = seq.offset(i);
 3245|    254|            inserted = false;
 3246|    254|            common().infoz().RecordInsertHit();
 3247|    254|            return;
 3248|    254|          }
 3249|    254|        }
 3250|    254|        auto mask_empty = g.MaskEmpty();
 3251|    254|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|    254|          size_t target_group_offset = seq.offset();
 3253|    254|          index = SwisstableGenerationsEnabled()
 3254|    254|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|    254|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|    254|                            FindInfo{target_group_offset, seq.index()},
 3257|    254|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|    254|                      : PrepareInsertLarge(
 3259|    254|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|    254|                            FindInfo{target_group_offset, seq.index()});
 3261|    254|          inserted = true;
 3262|    254|          return;
 3263|    254|        }
 3264|    254|        seq.next();
 3265|    254|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|    254|      }
 3267|    254|    }();
 3268|    254|    return {iterator_at(index), inserted};
 3269|    254|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE19prefetch_heap_blockEv:
 3423|    510|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|    510|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|    510|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|    510|    __builtin_prefetch(control(), 0, 1);
 3427|    510|#endif
 3428|    510|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE7hash_ofISA_EEmRKT_:
 3061|    254|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|    254|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|    254|                                               common().seed().seed()}(key);
 3064|    254|  }
_ZN4absl12lts_2026010718container_internal9probe_seqILm16EEC2Emm:
  327|    823|  probe_seq(size_t hash, size_t mask) {
  328|       |    ABSL_SWISSTABLE_ASSERT(((mask + 1) & mask) == 0 && "not a mask");
  ------------------
  |  |  248|    823|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
  329|    823|    mask_ = mask;
  330|    823|    offset_ = hash & mask_;
  331|    823|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE7controlEv:
 3433|  1.53k|  ctrl_t* control() const {
 3434|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|  1.53k|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3435|  1.53k|    return common().control();
 3436|  1.53k|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE28find_or_prepare_insert_largeISA_EENS4_4pairINSC_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|    254|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|    285|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 285, Folded]
  ------------------
 3238|    285|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|    285|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|    285|#endif
 3241|    285|        Group g{ctrl + seq.offset()};
 3242|    285|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 25, False: 285]
  ------------------
 3243|     25|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|     25|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 25]
  |  |  |  Branch (190:48): [Folded, False: 25]
  |  |  |  Branch (190:57): [True: 0, False: 25]
  |  |  ------------------
  ------------------
 3244|      0|            index = seq.offset(i);
 3245|      0|            inserted = false;
 3246|      0|            common().infoz().RecordInsertHit();
 3247|      0|            return;
 3248|      0|          }
 3249|     25|        }
 3250|    285|        auto mask_empty = g.MaskEmpty();
 3251|    285|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|    285|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 254, False: 31]
  |  |  |  Branch (190:48): [Folded, False: 285]
  |  |  |  Branch (190:57): [True: 254, False: 31]
  |  |  ------------------
  ------------------
 3252|    254|          size_t target_group_offset = seq.offset();
 3253|    254|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 254]
  ------------------
 3254|    254|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|      0|                            FindInfo{target_group_offset, seq.index()},
 3257|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|    254|                      : PrepareInsertLarge(
 3259|    254|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|    254|                            FindInfo{target_group_offset, seq.index()});
 3261|    254|          inserted = true;
 3262|    254|          return;
 3263|    254|        }
 3264|     31|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|     31|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|     31|      }
 3267|    254|    }();
_ZNK4absl12lts_2026010718container_internal9probe_seqILm16EE6offsetEv:
  334|  2.26k|  size_t offset() const { return offset_; }
_ZNK4absl12lts_2026010718container_internal9probe_seqILm16EE6offsetEm:
  335|    559|  size_t offset(size_t i) const { return (offset_ + i) & mask_; }
_ZNK4absl12lts_2026010718container_internal9probe_seqILm16EE5indexEv:
  343|    560|  size_t index() const { return index_; }
_ZN4absl12lts_2026010718container_internal9probe_seqILm16EE4nextEv:
  337|     31|  void next() {
  338|     31|    index_ += Width;
  339|     31|    offset_ += index_;
  340|     31|    offset_ &= mask_;
  341|     31|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE11iterator_atEm:
 3383|    510|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|    510|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|    510|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvNSC_8iteratorEDpOT_:
 3373|    256|  void emplace_at(iterator iter, Args&&... args) {
 3374|    256|    construct(iter.slot(), std::forward<Args>(args)...);
 3375|       |
 3376|       |    // When is_small, find calls find_small and if size is 0, then it will
 3377|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3378|       |    assert((is_small() ||
 3379|    256|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|    256|           "constructed value does not match the lookup key");
 3381|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_hEEDpOT_:
 2929|    256|  inline void construct(slot_type* slot, Args&&... args) {
 2930|    256|    common().RunWithReentrancyGuard([&] {
 2931|    256|      allocator_type alloc(char_alloc_ref());
 2932|    256|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|    256|    });
 2934|    256|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEhEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJOSC_EEENSJ_IJEEEEEEvPNS1_13map_slot_typeISC_hEEDpOT_EUlvE_EEvT_:
 1099|    256|  void RunWithReentrancyGuard(F f) {
 1100|    256|#ifdef NDEBUG
 1101|    256|    f();
 1102|    256|    return;
 1103|      0|#endif
 1104|      0|    const size_t cap = capacity();
 1105|      0|    set_capacity(InvalidCapacity::kReentrance);
 1106|      0|    f();
 1107|      0|    set_capacity(cap);
 1108|      0|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJOSA_EEENSH_IJEEEEEEvPNS1_13map_slot_typeISA_hEEDpOT_ENKUlvE_clEv:
 2930|    256|    common().RunWithReentrancyGuard([&] {
 2931|    256|      allocator_type alloc(char_alloc_ref());
 2932|    256|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|    256|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iterator4slotEv:
 2042|    256|    slot_type* slot() const { return slot_; }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEEC2Ev:
 2109|      2|      std::is_nothrow_default_constructible<allocator_type>::value) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE12AssertOnFindIS8_EEvRKT_:
 3279|    298|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|    298|    AssertHashEqConsistent(key);
 3281|    298|    AssertNotDebugCapacity();
 3282|    298|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22AssertHashEqConsistentIS8_EEvRKT_:
 3317|    298|  void AssertHashEqConsistent(const K& key) {
 3318|    298|#ifdef NDEBUG
 3319|    298|    return;
 3320|      0|#endif
 3321|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3322|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3322:9): [True: 0, Folded]
  ------------------
 3323|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3323:9): [True: 0, Folded]
  ------------------
 3324|      0|      return;
 3325|      0|    }
 3326|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3326:9): [Folded, False: 0]
  ------------------
 3327|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3327:9): [Folded, False: 0]
  ------------------
 3328|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3328:9): [Folded, False: 0]
  ------------------
 3329|      0|      return;
 3330|      0|    }
 3331|      0|    if (empty()) return;
  ------------------
  |  Branch (3331:9): [True: 0, False: 0]
  ------------------
 3332|       |
 3333|      0|    const size_t hash_of_arg = hash_of(key);
 3334|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3335|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3336|      0|      if (!is_key_equal) return;
 3337|       |
 3338|      0|      [[maybe_unused]] const bool is_hash_equal =
 3339|      0|          hash_of_arg == hash_of(to_slot(slot));
 3340|      0|      assert((!is_key_equal || is_hash_equal) &&
 3341|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3342|      0|             "hash/eq functors are inconsistent.");
 3343|      0|    };
 3344|       |
 3345|      0|    if (is_small()) {
  ------------------
  |  Branch (3345:9): [True: 0, False: 0]
  ------------------
 3346|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3347|      0|      return;
 3348|      0|    }
 3349|       |    // We only do validation for small tables so that it's constant time.
 3350|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3350:9): [True: 0, False: 0]
  ------------------
 3351|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3352|      0|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8equal_toIS8_EEbRKT_PNS1_13map_slot_typeIS8_iEE:
 3056|     10|                                             slot_type* slot) const {
 3057|     10|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|     10|                               PolicyTraits::element(slot));
 3059|     10|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6eq_refEv:
 3478|     10|  const key_equal& eq_ref() const { return settings_.template get<2>(); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE3endEv:
 2310|      1|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|      1|    AssertNotDebugCapacity();
 2312|      1|    return iterator(common().generation_ptr());
 2313|      1|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorC2EPKh:
 2014|      1|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorC2EPNS1_6ctrl_tEPNS1_13map_slot_typeIS8_iEEPKh:
 1993|    298|        : HashSetIteratorGenerationInfo(generation_ptr),
 1994|    298|          ctrl_(ctrl),
 1995|    298|          slot_(slot) {
 1996|       |      // This assumption helps the compiler know that any non-end iterator is
 1997|       |      // not equal to any end iterator.
 1998|    298|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|    298|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1999|    298|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE19prefetch_heap_blockEv:
 3423|    298|  void prefetch_heap_block() const {
 3424|       |    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|    298|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3425|    298|#if ABSL_HAVE_BUILTIN(__builtin_prefetch) || defined(__GNUC__)
 3426|    298|    __builtin_prefetch(control(), 0, 1);
 3427|    298|#endif
 3428|    298|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE11iterator_atEm:
 3383|    298|  iterator iterator_at(size_t i) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 3384|    298|    return {control() + i, slot_array() + i, common().generation_ptr()};
 3385|    298|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7hash_ofIS8_EEmRKT_:
 3061|    298|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|    298|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|    298|                                               common().seed().seed()}(key);
 3064|    298|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8hash_refEv:
 3476|    298|  const hasher& hash_ref() const { return settings_.template get<1>(); }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorESD_:
 1979|     40|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|     40|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|     40|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|     40|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|     40|                          a.generation_ptr(), b.generation_ptr());
 1984|     40|      return a.ctrl_ == b.ctrl_;
 1985|     40|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator14assert_is_fullEPKc:
 2016|     78|    void assert_is_full(const char* operation) const {
 2017|     78|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|     78|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratordeEv:
 1952|     39|    reference operator*() const {
 1953|     39|      assert_is_full("operator*()");
 1954|     39|      return unchecked_deref();
 1955|     39|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator15unchecked_derefEv:
 2039|     39|    reference unchecked_deref() const { return PolicyTraits::element(slot_); }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5clearEv:
 2341|      3|  ABSL_ATTRIBUTE_REINITIALIZES void clear() {
 2342|      3|    if (SwisstableGenerationsEnabled() &&
  ------------------
  |  Branch (2342:9): [Folded, False: 3]
  ------------------
 2343|      0|        capacity() >= InvalidCapacity::kMovedFrom) {
  ------------------
  |  Branch (2343:9): [True: 0, False: 0]
  ------------------
 2344|      0|      common().set_capacity(DefaultCapacity());
 2345|      0|    }
 2346|      3|    AssertNotDebugCapacity();
 2347|       |    // Iterating over this container is O(bucket_count()). When bucket_count()
 2348|       |    // is much greater than size(), iteration becomes prohibitively expensive.
 2349|       |    // For clear() it is more important to reuse the allocated array when the
 2350|       |    // container is small because allocation takes comparatively long time
 2351|       |    // compared to destruction of the elements of the container. So we pick the
 2352|       |    // largest bucket_count() threshold for which iteration is still fast and
 2353|       |    // past that we simply deallocate the array.
 2354|      3|    const size_t cap = capacity();
 2355|      3|    if (cap == 0) {
  ------------------
  |  Branch (2355:9): [True: 2, False: 1]
  ------------------
 2356|       |      // Already guaranteed to be empty; so nothing to do.
 2357|      2|    } else if (is_small()) {
  ------------------
  |  Branch (2357:16): [True: 0, False: 1]
  ------------------
 2358|      0|      if (!empty()) {
  ------------------
  |  Branch (2358:11): [True: 0, False: 0]
  ------------------
 2359|      0|        destroy(single_slot());
 2360|      0|        decrement_small_size();
 2361|      0|      }
 2362|      1|    } else {
 2363|      1|      destroy_slots();
 2364|      1|      clear_backing_array(/*reuse=*/cap < 128);
 2365|      1|    }
 2366|      3|    common().set_reserved_growth(0);
 2367|      3|    common().set_reservation_size(0);
 2368|      3|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE19clear_backing_arrayEb:
 2986|      1|  void clear_backing_array(bool reuse) {
 2987|       |    ABSL_SWISSTABLE_ASSERT(capacity() > DefaultCapacity());
  ------------------
  |  |  248|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2988|      1|    ClearBackingArray(common(), GetPolicyFunctions(), &char_alloc_ref(), reuse,
 2989|      1|                      SooEnabled());
 2990|      1|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE18GetPolicyFunctionsEv:
 3558|    301|  static const PolicyFunctions& GetPolicyFunctions() {
 3559|    301|    static_assert(sizeof(slot_type) <= (std::numeric_limits<uint32_t>::max)(),
 3560|    301|                  "Slot size is too large. Use std::unique_ptr for value type "
 3561|    301|                  "or use absl::node_hash_{map,set}.");
 3562|    301|    static_assert(alignof(slot_type) <=
 3563|    301|                  size_t{(std::numeric_limits<uint16_t>::max)()});
 3564|    301|    static_assert(sizeof(key_type) <=
 3565|    301|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3566|    301|    static_assert(sizeof(value_type) <=
 3567|    301|                  size_t{(std::numeric_limits<uint32_t>::max)()});
 3568|    301|    static constexpr size_t kBackingArrayAlignment =
 3569|    301|        BackingArrayAlignment(alignof(slot_type));
 3570|    301|    static constexpr PolicyFunctions value = {
 3571|    301|        static_cast<uint32_t>(sizeof(key_type)),
 3572|    301|        static_cast<uint32_t>(sizeof(value_type)),
 3573|    301|        static_cast<uint32_t>(sizeof(slot_type)),
 3574|    301|        static_cast<uint16_t>(alignof(slot_type)), SooEnabled(),
 3575|    301|        ShouldSampleHashtablezInfoForAlloc<CharAlloc>(),
 3576|       |        // TODO(b/328722020): try to type erase
 3577|       |        // for standard layout and alignof(Hash) <= alignof(CommonFields).
 3578|    301|        std::is_empty_v<hasher> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3578:9): [True: 0, Folded]
  ------------------
 3579|    301|                                : &raw_hash_set::get_hash_ref_fn,
 3580|    301|        PolicyTraits::template get_hash_slot_fn<hasher, kIsDefaultHash>(),
 3581|    301|        PolicyTraits::transfer_uses_memcpy()
  ------------------
  |  Branch (3581:9): [True: 0, Folded]
  ------------------
 3582|    301|            ? TransferNRelocatable<sizeof(slot_type)>
 3583|    301|            : &raw_hash_set::transfer_n_slots_fn,
 3584|    301|        std::is_empty_v<Alloc> ? &GetRefForEmptyClass
  ------------------
  |  Branch (3584:9): [True: 0, Folded]
  ------------------
 3585|    301|                               : &raw_hash_set::get_char_alloc_ref_fn,
 3586|    301|        &AllocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3587|    301|        &DeallocateBackingArray<kBackingArrayAlignment, CharAlloc>,
 3588|    301|        &raw_hash_set::transfer_unprobed_elements_to_next_capacity_fn};
 3589|    301|    return value;
 3590|    301|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7to_slotEPv:
 3073|      1|  static ABSL_ATTRIBUTE_ALWAYS_INLINE slot_type* to_slot(void* buf) {
 3074|      1|    return static_cast<slot_type*>(buf);
 3075|      1|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7reserveEm:
 2741|      2|  void reserve(size_t n) {
 2742|      2|    if (ABSL_PREDICT_TRUE(n > DefaultCapacity())) {
  ------------------
  |  |  190|      2|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 2, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 2]
  |  |  |  Branch (190:57): [True: 2, False: 0]
  |  |  ------------------
  ------------------
 2743|      2|      ReserveTableToFitNewSize(common(), GetPolicyFunctions(), n);
 2744|      2|    }
 2745|      2|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE6insertINS4_4pairIKS8_iEELi0EEENSC_INSA_8iteratorEbEERKT_:
 2411|    298|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2412|    298|    return emplace(value);
 2413|    298|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE7emplaceIJRKNS4_4pairIKS8_iEEETnNS4_9enable_ifIXsr14IsDecomposableIDpT_EE5valueEiE4typeELi0EEENSC_INSA_8iteratorEbEEDpOSI_:
 2526|    298|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2527|    298|    return PolicyTraits::apply(EmplaceDecomposable{*this},
 2528|    298|                               std::forward<Args>(args)...);
 2529|    298|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE19EmplaceDecomposableclIS8_JRKNS4_21piecewise_construct_tENS4_5tupleIJRKS8_EEENSG_IJRKiEEEEEENS4_4pairINSA_8iteratorEbEERKT_DpOT0_:
 2901|    298|    std::pair<iterator, bool> operator()(const K& key, Args&&... args) const {
 2902|    298|      auto res = s.find_or_prepare_insert(key);
 2903|    298|      if (res.second) {
  ------------------
  |  Branch (2903:11): [True: 298, False: 0]
  ------------------
 2904|    298|        s.emplace_at(res.first, std::forward<Args>(args)...);
 2905|    298|      }
 2906|    298|      return res;
 2907|    298|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE22find_or_prepare_insertIS8_EENS4_4pairINSA_8iteratorEbEERKT_:
 3358|    298|  std::pair<iterator, bool> find_or_prepare_insert(const K& key) {
 3359|    298|    AssertOnFind(key);
 3360|    298|    if (is_small()) return find_or_prepare_insert_small(key);
  ------------------
  |  Branch (3360:9): [True: 0, False: 298]
  ------------------
 3361|    298|    return find_or_prepare_insert_large(key);
 3362|    298|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE28find_or_prepare_insert_largeIS8_EENS4_4pairINSA_8iteratorEbEERKT_:
 3225|    298|  std::pair<iterator, bool> find_or_prepare_insert_large(const K& key) {
 3226|    298|    ABSL_SWISSTABLE_ASSERT(!is_soo());
  ------------------
  |  |  248|    298|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3227|    298|    prefetch_heap_block();
 3228|    298|    const size_t hash = hash_of(key);
 3229|    298|    auto seq = probe(common(), hash);
 3230|    298|    const h2_t h2 = H2(hash);
 3231|    298|    const ctrl_t* ctrl = control();
 3232|    298|    size_t index;
 3233|    298|    bool inserted;
 3234|       |    // We use a lambda function to be able to exit from the nested loop without
 3235|       |    // duplicating generated code for the return statement (e.g. iterator_at).
 3236|    298|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|    298|      while (true) {
 3238|    298|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|    298|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|    298|#endif
 3241|    298|        Group g{ctrl + seq.offset()};
 3242|    298|        for (uint32_t i : g.Match(h2)) {
 3243|    298|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
 3244|    298|            index = seq.offset(i);
 3245|    298|            inserted = false;
 3246|    298|            common().infoz().RecordInsertHit();
 3247|    298|            return;
 3248|    298|          }
 3249|    298|        }
 3250|    298|        auto mask_empty = g.MaskEmpty();
 3251|    298|        if (ABSL_PREDICT_TRUE(mask_empty)) {
 3252|    298|          size_t target_group_offset = seq.offset();
 3253|    298|          index = SwisstableGenerationsEnabled()
 3254|    298|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|    298|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|    298|                            FindInfo{target_group_offset, seq.index()},
 3257|    298|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|    298|                      : PrepareInsertLarge(
 3259|    298|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|    298|                            FindInfo{target_group_offset, seq.index()});
 3261|    298|          inserted = true;
 3262|    298|          return;
 3263|    298|        }
 3264|    298|        seq.next();
 3265|    298|        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
 3266|    298|      }
 3267|    298|    }();
 3268|    298|    return {iterator_at(index), inserted};
 3269|    298|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE28find_or_prepare_insert_largeIS8_EENS4_4pairINSA_8iteratorEbEERKT_ENKUlvE_clEv:
 3236|    298|    [&]() ABSL_ATTRIBUTE_ALWAYS_INLINE {
 3237|    298|      while (true) {
  ------------------
  |  Branch (3237:14): [True: 298, Folded]
  ------------------
 3238|    298|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 3239|    298|        absl::PrefetchToLocalCache(slot_array() + seq.offset());
 3240|    298|#endif
 3241|    298|        Group g{ctrl + seq.offset()};
 3242|    298|        for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (3242:25): [True: 10, False: 298]
  ------------------
 3243|     10|          if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i)))) {
  ------------------
  |  |  190|     10|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 10]
  |  |  |  Branch (190:48): [Folded, False: 10]
  |  |  |  Branch (190:57): [True: 0, False: 10]
  |  |  ------------------
  ------------------
 3244|      0|            index = seq.offset(i);
 3245|      0|            inserted = false;
 3246|      0|            common().infoz().RecordInsertHit();
 3247|      0|            return;
 3248|      0|          }
 3249|     10|        }
 3250|    298|        auto mask_empty = g.MaskEmpty();
 3251|    298|        if (ABSL_PREDICT_TRUE(mask_empty)) {
  ------------------
  |  |  190|    298|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 298, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 298]
  |  |  |  Branch (190:57): [True: 298, False: 0]
  |  |  ------------------
  ------------------
 3252|    298|          size_t target_group_offset = seq.offset();
 3253|    298|          index = SwisstableGenerationsEnabled()
  ------------------
  |  Branch (3253:19): [Folded, False: 298]
  ------------------
 3254|    298|                      ? PrepareInsertLargeGenerationsEnabled(
 3255|      0|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3256|      0|                            FindInfo{target_group_offset, seq.index()},
 3257|      0|                            HashKey<hasher, K, kIsDefaultHash>{hash_ref(), key})
 3258|    298|                      : PrepareInsertLarge(
 3259|    298|                            common(), GetPolicyFunctions(), hash, mask_empty,
 3260|    298|                            FindInfo{target_group_offset, seq.index()});
 3261|    298|          inserted = true;
 3262|    298|          return;
 3263|    298|        }
 3264|      0|        seq.next();
 3265|       |        ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 3266|      0|      }
 3267|    298|    }();
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE10emplace_atIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKS8_EEENSF_IJRKiEEEEEEvNSA_8iteratorEDpOT_:
 3373|    298|  void emplace_at(iterator iter, Args&&... args) {
 3374|    298|    construct(iter.slot(), std::forward<Args>(args)...);
 3375|       |
 3376|       |    // When is_small, find calls find_small and if size is 0, then it will
 3377|       |    // return an end iterator. This can happen in the raw_hash_set copy ctor.
 3378|       |    assert((is_small() ||
 3379|    298|            PolicyTraits::apply(FindElement{*this}, *iter) == iter) &&
 3380|    298|           "constructed value does not match the lookup key");
 3381|    298|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKS8_EEENSF_IJRKiEEEEEEvPNS1_13map_slot_typeIS8_iEEDpOT_:
 2929|    298|  inline void construct(slot_type* slot, Args&&... args) {
 2930|    298|    common().RunWithReentrancyGuard([&] {
 2931|    298|      allocator_type alloc(char_alloc_ref());
 2932|    298|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|    298|    });
 2934|    298|  }
_ZN4absl12lts_2026010718container_internal12CommonFields22RunWithReentrancyGuardIZNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEiEEJEE9constructIJRKNS6_21piecewise_construct_tENS6_5tupleIJRKSA_EEENSH_IJRKiEEEEEEvPNS1_13map_slot_typeISA_iEEDpOT_EUlvE_EEvT_:
 1099|    298|  void RunWithReentrancyGuard(F f) {
 1100|    298|#ifdef NDEBUG
 1101|    298|    f();
 1102|    298|    return;
 1103|      0|#endif
 1104|      0|    const size_t cap = capacity();
 1105|      0|    set_capacity(InvalidCapacity::kReentrance);
 1106|      0|    f();
 1107|      0|    set_capacity(cap);
 1108|      0|  }
_ZZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE9constructIJRKNS4_21piecewise_construct_tENS4_5tupleIJRKS8_EEENSF_IJRKiEEEEEEvPNS1_13map_slot_typeIS8_iEEDpOT_ENKUlvE_clEv:
 2930|    298|    common().RunWithReentrancyGuard([&] {
 2931|    298|      allocator_type alloc(char_alloc_ref());
 2932|    298|      PolicyTraits::construct(&alloc, slot, std::forward<Args>(args)...);
 2933|    298|    });
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator4slotEv:
 2042|    298|    slot_type* slot() const { return slot_; }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE4findINS4_17basic_string_viewIcS7_EEEENSC_14const_iteratorERKT_:
 2803|    256|      ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2804|    256|    return const_cast<raw_hash_set*>(this)->find(key);
 2805|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE4findINS4_17basic_string_viewIcS7_EEEENSC_8iteratorERKT_:
 2788|    256|  iterator find(const key_arg<K>& key) ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2789|    256|    AssertOnFind(key);
 2790|    256|    if (is_small()) return find_small(key);
  ------------------
  |  Branch (2790:9): [True: 0, False: 256]
  ------------------
 2791|    256|    prefetch_heap_block();
 2792|    256|    return find_large(key, hash_of(key));
 2793|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE12AssertOnFindINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3279|    256|  void AssertOnFind([[maybe_unused]] const K& key) {
 3280|    256|    AssertHashEqConsistent(key);
 3281|    256|    AssertNotDebugCapacity();
 3282|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE22AssertHashEqConsistentINS4_17basic_string_viewIcS7_EEEEvRKT_:
 3317|    256|  void AssertHashEqConsistent(const K& key) {
 3318|    256|#ifdef NDEBUG
 3319|    256|    return;
 3320|      0|#endif
 3321|       |    // If the hash/eq functors are known to be consistent, then skip validation.
 3322|      0|    if (std::is_same<hasher, absl::container_internal::StringHash>::value &&
  ------------------
  |  Branch (3322:9): [True: 0, Folded]
  ------------------
 3323|      0|        std::is_same<key_equal, absl::container_internal::StringEq>::value) {
  ------------------
  |  Branch (3323:9): [True: 0, Folded]
  ------------------
 3324|      0|      return;
 3325|      0|    }
 3326|      0|    if (std::is_scalar<key_type>::value &&
  ------------------
  |  Branch (3326:9): [Folded, False: 0]
  ------------------
 3327|      0|        std::is_same<hasher, absl::Hash<key_type>>::value &&
  ------------------
  |  Branch (3327:9): [Folded, False: 0]
  ------------------
 3328|      0|        std::is_same<key_equal, std::equal_to<key_type>>::value) {
  ------------------
  |  Branch (3328:9): [Folded, False: 0]
  ------------------
 3329|      0|      return;
 3330|      0|    }
 3331|      0|    if (empty()) return;
  ------------------
  |  Branch (3331:9): [True: 0, False: 0]
  ------------------
 3332|       |
 3333|      0|    const size_t hash_of_arg = hash_of(key);
 3334|      0|    const auto assert_consistent = [&](const ctrl_t*, void* slot) {
 3335|      0|      const bool is_key_equal = equal_to(key, to_slot(slot));
 3336|      0|      if (!is_key_equal) return;
 3337|       |
 3338|      0|      [[maybe_unused]] const bool is_hash_equal =
 3339|      0|          hash_of_arg == hash_of(to_slot(slot));
 3340|      0|      assert((!is_key_equal || is_hash_equal) &&
 3341|      0|             "eq(k1, k2) must imply that hash(k1) == hash(k2). "
 3342|      0|             "hash/eq functors are inconsistent.");
 3343|      0|    };
 3344|       |
 3345|      0|    if (is_small()) {
  ------------------
  |  Branch (3345:9): [True: 0, False: 0]
  ------------------
 3346|      0|      assert_consistent(/*unused*/ nullptr, single_slot());
 3347|      0|      return;
 3348|      0|    }
 3349|       |    // We only do validation for small tables so that it's constant time.
 3350|      0|    if (capacity() > 16) return;
  ------------------
  |  Branch (3350:9): [True: 0, False: 0]
  ------------------
 3351|      0|    IterateOverFullSlots(common(), sizeof(slot_type), assert_consistent);
 3352|      0|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8equal_toINS4_17basic_string_viewIcS7_EEEEbRKT_PNS1_13map_slot_typeISA_hEE:
 3056|    260|                                             slot_type* slot) const {
 3057|    260|    return PolicyTraits::apply(EqualElement<K, key_equal>{key, eq_ref()},
 3058|    260|                               PolicyTraits::element(slot));
 3059|    260|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE3endEv:
 2310|    256|  iterator end() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2311|    256|    AssertNotDebugCapacity();
 2312|    256|    return iterator(common().generation_ptr());
 2313|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iteratorC2EPKh:
 2014|    256|        : HashSetIteratorGenerationInfo(generation_ptr), ctrl_(nullptr) {}
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE10find_largeINS4_17basic_string_viewIcS7_EEEENSC_8iteratorERKT_m:
 2957|    256|  iterator find_large(const key_arg<K>& key, size_t hash) {
 2958|    256|    ABSL_SWISSTABLE_ASSERT(!is_small());
  ------------------
  |  |  248|    256|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2959|    256|    auto seq = probe(common(), hash);
 2960|    256|    const h2_t h2 = H2(hash);
 2961|    256|    const ctrl_t* ctrl = control();
 2962|    256|    while (true) {
  ------------------
  |  Branch (2962:12): [True: 256, Folded]
  ------------------
 2963|    256|#ifndef ABSL_HAVE_MEMORY_SANITIZER
 2964|    256|      absl::PrefetchToLocalCache(slot_array() + seq.offset());
 2965|    256|#endif
 2966|    256|      Group g{ctrl + seq.offset()};
 2967|    260|      for (uint32_t i : g.Match(h2)) {
  ------------------
  |  Branch (2967:23): [True: 260, False: 0]
  ------------------
 2968|    260|        if (ABSL_PREDICT_TRUE(equal_to(key, slot_array() + seq.offset(i))))
  ------------------
  |  |  190|    260|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 256, False: 4]
  |  |  |  Branch (190:48): [Folded, False: 260]
  |  |  |  Branch (190:57): [True: 256, False: 4]
  |  |  ------------------
  ------------------
 2969|    256|          return iterator_at(seq.offset(i));
 2970|    260|      }
 2971|      0|      if (ABSL_PREDICT_TRUE(g.MaskEmpty())) return end();
  ------------------
  |  |  190|      0|#define ABSL_PREDICT_TRUE(x) (__builtin_expect(false || (x), true))
  |  |  ------------------
  |  |  |  Branch (190:30): [True: 0, False: 0]
  |  |  |  Branch (190:48): [Folded, False: 0]
  |  |  |  Branch (190:57): [True: 0, False: 0]
  |  |  ------------------
  ------------------
 2972|      0|      seq.next();
 2973|       |      ABSL_SWISSTABLE_ASSERT(seq.index() <= capacity() && "full table!");
  ------------------
  |  |  248|      0|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2974|      0|    }
 2975|    256|  }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE7hash_ofINS4_17basic_string_viewIcS7_EEEEmRKT_:
 3061|    256|  ABSL_ATTRIBUTE_ALWAYS_INLINE size_t hash_of(const K& key) const {
 3062|    256|    return HashElement<hasher, kIsDefaultHash>{hash_ref(),
 3063|    256|                                               common().seed().seed()}(key);
 3064|    256|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE14const_iteratorC2ENSC_8iteratorE:
 2069|    512|    const_iterator(iterator i) : inner_(std::move(i)) {}  // NOLINT
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE3endEv:
 2318|    256|  const_iterator end() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2319|    256|    return const_cast<raw_hash_set*>(this)->end();
 2320|    256|  }
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE14const_iteratorESF_:
 2083|    256|    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
 2084|    256|      return !(a == b);
 2085|    256|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE14const_iteratorESF_:
 2080|    256|    friend bool operator==(const const_iterator& a, const const_iterator& b) {
 2081|    256|      return a.inner_ == b.inner_;
 2082|    256|    }
_ZN4absl12lts_2026010718container_internaleqERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iteratorESF_:
 1979|    256|    friend bool operator==(const iterator& a, const iterator& b) {
 1980|    256|      AssertIsValidForComparison(a.ctrl_, a.generation(), a.generation_ptr());
 1981|    256|      AssertIsValidForComparison(b.ctrl_, b.generation(), b.generation_ptr());
 1982|    256|      AssertSameContainer(a.ctrl_, b.ctrl_, a.slot_, b.slot_,
 1983|    256|                          a.generation_ptr(), b.generation_ptr());
 1984|    256|      return a.ctrl_ == b.ctrl_;
 1985|    256|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE14const_iteratorptEv:
 2072|    256|    pointer operator->() const { return inner_.operator->(); }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iteratorptEv:
 1958|    256|    pointer operator->() const {
 1959|    256|      assert_is_full("operator->");
 1960|    256|      return &operator*();
 1961|    256|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iterator14assert_is_fullEPKc:
 2016|    512|    void assert_is_full(const char* operation) const {
 2017|    512|      AssertIsFull(ctrl_, generation(), generation_ptr(), operation);
 2018|    512|    }
_ZNK4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEhEEJEE8iteratordeEv:
 1952|    256|    reference operator*() const {
 1953|    256|      assert_is_full("operator*()");
 1954|    256|      return unchecked_deref();
 1955|    256|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE5beginEv:
 2301|      1|  iterator begin() ABSL_ATTRIBUTE_LIFETIME_BOUND {
 2302|      1|    if (ABSL_PREDICT_FALSE(empty())) return end();
  ------------------
  |  |  189|      1|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 0, False: 1]
  |  |  |  Branch (189:49): [Folded, False: 1]
  |  |  |  Branch (189:58): [True: 0, False: 1]
  |  |  ------------------
  ------------------
 2303|      1|    if (is_small()) return single_iterator();
  ------------------
  |  Branch (2303:9): [True: 0, False: 1]
  ------------------
 2304|      1|    iterator it = {control(), common().slots_union(),
 2305|      1|                   common().generation_ptr()};
 2306|      1|    it.skip_empty_or_deleted();
 2307|       |    ABSL_SWISSTABLE_ASSERT(IsFull(*it.control()));
  ------------------
  |  |  248|      1|  assert((CONDITION) && "Try enabling sanitizers.")
  ------------------
 2308|      1|    return it;
 2309|      1|  }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorC2EPNS1_6ctrl_tENS1_19MaybeInitializedPtrIvEEPKh:
 2005|      1|        : HashSetIteratorGenerationInfo(generation_ptr),
 2006|      1|          ctrl_(ctrl),
 2007|      1|          slot_(to_slot(slot.get())) {
 2008|       |      // This assumption helps the compiler know that any non-end iterator is
 2009|       |      // not equal to any end iterator.
 2010|      1|      ABSL_ASSUME(ctrl != nullptr);
  ------------------
  |  |  270|      1|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 2011|      1|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iterator21skip_empty_or_deletedEv:
 2022|     40|    void skip_empty_or_deleted() {
 2023|     64|      while (IsEmptyOrDeleted(*ctrl_)) {
  ------------------
  |  Branch (2023:14): [True: 24, False: 40]
  ------------------
 2024|     24|        ++ctrl_;
 2025|     24|        ++slot_;
 2026|     24|      }
 2027|     40|    }
_ZN4absl12lts_2026010718container_internalneERKNS1_12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorESD_:
 1986|     40|    friend bool operator!=(const iterator& a, const iterator& b) {
 1987|     40|      return !(a == b);
 1988|     40|    }
_ZN4absl12lts_2026010718container_internal12raw_hash_setINS1_17FlatHashMapPolicyINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEEiEEJEE8iteratorppEv:
 1964|     39|    iterator& operator++() {
 1965|     39|      assert_is_full("operator++");
 1966|     39|      ++ctrl_;
 1967|     39|      ++slot_;
 1968|     39|      skip_empty_or_deleted();
 1969|     39|      if (ABSL_PREDICT_FALSE(*ctrl_ == ctrl_t::kSentinel)) ctrl_ = nullptr;
  ------------------
  |  |  189|     39|#define ABSL_PREDICT_FALSE(x) (__builtin_expect(false || (x), false))
  |  |  ------------------
  |  |  |  Branch (189:31): [True: 1, False: 38]
  |  |  |  Branch (189:49): [Folded, False: 39]
  |  |  |  Branch (189:58): [True: 1, False: 38]
  |  |  ------------------
  ------------------
 1970|     39|      return *this;
 1971|     39|    }

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

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

_ZN4absl12lts_2026010713hash_internal15MixingHashState18combine_contiguousES2_PKhm:
 1343|  1.24k|                                            size_t size) {
 1344|  1.24k|    return MixingHashState(
 1345|  1.24k|        CombineContiguousImpl(hash_state.state_, first, size,
 1346|  1.24k|                              std::integral_constant<int, sizeof(size_t)>{}));
 1347|  1.24k|  }
_ZN4absl12lts_2026010713hash_internal15MixingHashStateC2Em:
 1394|  2.48k|  explicit MixingHashState(uint64_t state) : state_(state) {}
_ZN4absl12lts_2026010713hash_internal19PrecombineLengthMixEmm:
  989|  1.24k|inline uint64_t PrecombineLengthMix(uint64_t state, size_t len) {
  990|  1.24k|  ABSL_ASSUME(len + sizeof(uint64_t) <= sizeof(kStaticRandomData));
  ------------------
  |  |  270|  1.24k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
  991|  1.24k|  uint64_t data = absl::base_internal::UnalignedLoad64(
  992|  1.24k|      reinterpret_cast<const unsigned char*>(&kStaticRandomData[0]) + len);
  993|  1.24k|  return state ^ data;
  994|  1.24k|}
_ZN4absl12lts_2026010713hash_internal3MixEmm:
  996|  1.24k|ABSL_ATTRIBUTE_ALWAYS_INLINE inline uint64_t Mix(uint64_t lhs, uint64_t rhs) {
  997|       |  // Though the 128-bit product needs multiple instructions on non-x86-64
  998|       |  // platforms, it is still a good balance between speed and hash quality.
  999|  1.24k|  absl::uint128 m = lhs;
 1000|  1.24k|  m *= rhs;
 1001|  1.24k|  return Uint128High64(m) ^ Uint128Low64(m);
 1002|  1.24k|}
_ZN4absl12lts_2026010713hash_internal8Read4To8EPKhm:
 1029|  1.21k|inline uint64_t Read4To8(const unsigned char* p, size_t len) {
 1030|       |  // If `len < 8`, we duplicate bytes. We always put low memory at the end.
 1031|       |  // E.g., on little endian platforms:
 1032|       |  // `ABCD` will be read as `ABCDABCD`.
 1033|       |  // `ABCDE` will be read as `BCDEABCD`.
 1034|       |  // `ABCDEF` will be read as `CDEFABCD`.
 1035|       |  // `ABCDEFG` will be read as `DEFGABCD`.
 1036|       |  // `ABCDEFGH` will be read as `EFGHABCD`.
 1037|       |  // We also do not care about endianness. On big-endian platforms, bytes will
 1038|       |  // be permuted differently. We always shift low memory by 32, because that
 1039|       |  // can be pipelined earlier. Reading high memory requires computing
 1040|       |  // `p + len - 4`.
 1041|  1.21k|  uint64_t most_significant =
 1042|  1.21k|      static_cast<uint64_t>(absl::base_internal::UnalignedLoad32(p)) << 32;
 1043|  1.21k|  uint64_t least_significant =
 1044|  1.21k|      absl::base_internal::UnalignedLoad32(p + len - 4);
 1045|  1.21k|  return most_significant | least_significant;
 1046|  1.21k|}
_ZN4absl12lts_2026010713hash_internal8Read1To3EPKhm:
 1049|     32|inline uint32_t Read1To3(const unsigned char* p, size_t len) {
 1050|       |  // The trick used by this implementation is to avoid branches.
 1051|       |  // We always read three bytes by duplicating.
 1052|       |  // E.g.,
 1053|       |  // `A` is read as `AAA`.
 1054|       |  // `AB` is read as `ABB`.
 1055|       |  // `ABC` is read as `ABC`.
 1056|       |  // We always shift `p[0]` so that it can be pipelined better.
 1057|       |  // Other bytes require extra computation to find indices.
 1058|     32|  uint32_t mem0 = (static_cast<uint32_t>(p[0]) << 16) | p[len - 1];
 1059|     32|  uint32_t mem1 = static_cast<uint32_t>(p[len / 2]) << 8;
 1060|     32|  return mem0 | mem1;
 1061|     32|}
_ZN4absl12lts_2026010713hash_internal14CombineRawImplEmm:
 1064|  1.24k|                                                            uint64_t value) {
 1065|  1.24k|  return Mix(state ^ value, kMul);
 1066|  1.24k|}
_ZN4absl12lts_2026010713hash_internal26CombineSmallContiguousImplEmPKhm:
 1079|  1.24k|    uint64_t state, const unsigned char* first, size_t len) {
 1080|  1.24k|  ABSL_ASSUME(len <= 8);
  ------------------
  |  |  270|  1.24k|#define ABSL_ASSUME(cond) __builtin_assume(cond)
  ------------------
 1081|  1.24k|  uint64_t v;
 1082|  1.24k|  if (len >= 4) {
  ------------------
  |  Branch (1082:7): [True: 1.21k, False: 32]
  ------------------
 1083|  1.21k|    v = Read4To8(first, len);
 1084|  1.21k|  } else if (len > 0) {
  ------------------
  |  Branch (1084:14): [True: 32, False: 0]
  ------------------
 1085|     32|    v = Read1To3(first, len);
 1086|     32|  } else {
 1087|       |    // Empty string must modify the state.
 1088|      0|    v = 0x57;
 1089|      0|  }
 1090|  1.24k|  return CombineRawImpl(state, v);
 1091|  1.24k|}
_ZN4absl12lts_2026010713hash_internal21CombineContiguousImplEmPKhmNSt3__117integral_constantIiLi8EEE:
 1203|  1.24k|    std::integral_constant<int, 8> /* sizeof_size_t */) {
 1204|       |  // For large values we use LowLevelHash or CityHash depending on the platform,
 1205|       |  // for small ones we use custom low latency hash.
 1206|  1.24k|  if (len <= 8) {
  ------------------
  |  Branch (1206:7): [True: 1.24k, False: 0]
  ------------------
 1207|  1.24k|    return CombineSmallContiguousImpl(PrecombineLengthMix(state, len), first,
 1208|  1.24k|                                      len);
 1209|  1.24k|  }
 1210|      0|  if (len <= 16) {
  ------------------
  |  Branch (1210:7): [True: 0, False: 0]
  ------------------
 1211|      0|    return CombineContiguousImpl9to16(PrecombineLengthMix(state, len), first,
 1212|      0|                                      len);
 1213|      0|  }
 1214|      0|  if (len <= 32) {
  ------------------
  |  Branch (1214:7): [True: 0, False: 0]
  ------------------
 1215|      0|    return CombineContiguousImpl17to32(PrecombineLengthMix(state, len), first,
 1216|      0|                                       len);
 1217|      0|  }
 1218|       |  // We must not mix length into the state here because calling
 1219|       |  // CombineContiguousImpl twice with PiecewiseChunkSize() must be equivalent
 1220|       |  // to calling CombineLargeContiguousImpl once with 2 * PiecewiseChunkSize().
 1221|      0|  return CombineLargeContiguousImplOn64BitLengthGt32(state, first, len);
 1222|      0|}
_ZN4absl12lts_2026010713hash_internal15MixingHashState14hash_with_seedINSt3__117basic_string_viewIcNS4_11char_traitsIcEEEETnNS4_9enable_ifIXntsr16IntegralFastPathIT_EE5valueEiE4typeELi0EEEmRKSA_m:
 1367|  1.24k|  static size_t hash_with_seed(const T& value, size_t seed) {
 1368|  1.24k|    return static_cast<size_t>(combine(MixingHashState{seed}, value).state_);
 1369|  1.24k|  }
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineINSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEJEEES3_S3_RKT_DpRKT0_:
 1492|  1.24k|H HashStateBase<H>::combine(H state, const T& value, const Ts&... values) {
 1493|  1.24k|  return H::combine(hash_internal::HashSelect::template Apply<T>::Invoke(
 1494|  1.24k|                        std::move(state), value),
 1495|  1.24k|                    values...);
 1496|  1.24k|}
_ZN4absl12lts_2026010713hash_internal10HashSelect14HashValueProbe6InvokeINS1_15MixingHashStateENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEENS6_9enable_ifIXsr3std7is_sameIT_DTcl13AbslHashValueclsr3stdE4movefp_Efp0_EEEE5valueESC_E4typeESC_RKT0_:
 1270|  1.24k|        H> {
 1271|  1.24k|      return AbslHashValue(std::move(state), value);
 1272|  1.24k|    }
_ZN4absl12lts_2026010713hash_internal13AbslHashValueINS1_15MixingHashStateEEET_S4_NSt3__117basic_string_viewIcNS5_11char_traitsIcEEEE:
  645|  1.24k|H AbslHashValue(H hash_state, absl::string_view str) {
  646|  1.24k|  return H::combine_contiguous(std::move(hash_state), str.data(), str.size());
  647|  1.24k|}
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE18combine_contiguousIcEES3_S3_PKT_m:
 1500|  1.24k|H HashStateBase<H>::combine_contiguous(H state, const T* data, size_t size) {
 1501|  1.24k|  return hash_internal::hash_range_or_bytes(std::move(state), data, size);
 1502|  1.24k|}
_ZN4absl12lts_2026010713hash_internal19hash_range_or_bytesINS1_15MixingHashStateEcEENSt3__19enable_ifIXsr23is_uniquely_representedIT0_EE5valueET_E4typeES7_PKS6_m:
  962|  1.24k|hash_range_or_bytes(H hash_state, const T* data, size_t size) {
  963|  1.24k|  const auto* bytes = reinterpret_cast<const unsigned char*>(data);
  964|  1.24k|  return H::combine_contiguous(std::move(hash_state), bytes, sizeof(T) * size);
  965|  1.24k|}
_ZN4absl12lts_2026010713hash_internal13HashStateBaseINS1_15MixingHashStateEE7combineES3_:
  283|  1.24k|  static H combine(H state) { return state; }
_ZNK4absl12lts_2026010713hash_internal12HashWithSeed4hashINS1_4HashINSt3__117basic_string_viewIcNS5_11char_traitsIcEEEEEES9_EEmRKT_RKT0_m:
  396|  1.24k|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  397|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  398|  1.24k|    return hasher.hash_with_seed(value, seed);
  399|  1.24k|  }
_ZNK4absl12lts_2026010713hash_internal8HashImplINSt3__117basic_string_viewIcNS3_11char_traitsIcEEEEE14hash_with_seedERKS7_m:
 1481|  1.24k|  size_t hash_with_seed(const T& value, size_t seed) const {
 1482|  1.24k|    return MixingHashState::hash_with_seed(value, seed);
 1483|  1.24k|  }
_ZNK4absl12lts_2026010713hash_internal12HashWithSeed4hashINS0_18container_internal10StringHashENSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEmRKT_RKT0_m:
  396|    690|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  397|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  398|    690|    return hasher.hash_with_seed(value, seed);
  399|    690|  }
_ZNK4absl12lts_2026010713hash_internal12HashWithSeed4hashINS0_18container_internal10StringHashENSt3__117basic_string_viewIcNS6_11char_traitsIcEEEEEEmRKT_RKT0_m:
  396|    554|  size_t hash(const Hasher& hasher, const T& value, size_t seed) const {
  397|       |    // NOLINTNEXTLINE(clang-diagnostic-sign-conversion)
  398|    554|    return hasher.hash_with_seed(value, seed);
  399|    554|  }

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

_ZN4absl12lts_202601077uint128mLES1_:
  646|  1.24k|inline uint128& uint128::operator*=(uint128 other) {
  647|  1.24k|  *this = *this * other;
  648|  1.24k|  return *this;
  649|  1.24k|}
_ZN4absl12lts_2026010712Uint128Low64ENS0_7uint128E:
  661|  1.24k|constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
_ZN4absl12lts_2026010713Uint128High64ENS0_7uint128E:
  663|  1.24k|constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
_ZNK4absl12lts_202601077uint128cvoEv:
  794|  2.48k|constexpr uint128::operator unsigned __int128() const {
  795|  2.48k|  return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
  796|  2.48k|}
_ZN4absl12lts_20260107mlENS0_7uint128ES1_:
 1059|  1.24k|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|  1.24k|  return static_cast<unsigned __int128>(lhs) *
 1063|  1.24k|         static_cast<unsigned __int128>(rhs);
 1064|  1.24k|}
_ZN4absl12lts_202601077uint128C2Em:
  683|  2.48k|constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
_ZN4absl12lts_202601077uint128C2Eo:
  692|  1.24k|    : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
  693|  1.24k|      hi_{static_cast<uint64_t>(v >> 64)} {}

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

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

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

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

_ZN4absl12lts_2026010717UntypedFormatSpecC2ENSt3__117basic_string_viewIcNS2_11char_traitsIcEEEE:
  111|    256|  explicit UntypedFormatSpec(string_view s) : spec_(s) {}
_ZN4absl12lts_202601079StrFormatIJhEEENSt3__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_202601074SpanIKNS0_19str_format_internal13FormatArgImplEEC2IS4_S4_EESt16initializer_listIS3_E:
  310|    256|      : Span(v.begin(), v.size()) {}
_ZN4absl12lts_202601074SpanIKNS0_19str_format_internal13FormatArgImplEEC2EPS4_m:
  230|    256|      : ptr_(array), len_(length) {}

_ZN5Darts7Details15DoubleArrayUnitC2Ev:
   52|    256|  DoubleArrayUnit() : unit_() {}
_ZNK5Darts7Details15DoubleArrayUnit8has_leafEv:
   56|     93|  bool has_leaf() const {
   57|     93|    return ((unit_ >> 8) & 1) == 1;
   58|     93|  }
_ZNK5Darts7Details15DoubleArrayUnit5valueEv:
   61|     58|  value_type value() const {
   62|     58|    return static_cast<value_type>(unit_ & ((1U << 31) - 1));
   63|     58|  }
_ZNK5Darts7Details15DoubleArrayUnit5labelEv:
   68|     93|  id_type label() const {
   69|     93|    return unit_ & ((1U << 31) | 0xFF);
   70|     93|  }
_ZNK5Darts7Details15DoubleArrayUnit6offsetEv:
   72|    132|  id_type offset() const {
   73|    132|    return (unit_ >> 10) << ((unit_ & (1U << 9)) >> 6);
   74|    132|  }
_ZN5Darts7Details9BitVectorC2Ev:
  796|      1|  BitVector() : units_(), ranks_(), num_ones_(0), size_(0) {}
_ZN5Darts7Details9BitVectorD2Ev:
  797|      1|  ~BitVector() {
  798|      1|    clear();
  799|      1|  }
_ZNK5Darts7Details9BitVectorixEm:
  801|    120|  bool operator[](std::size_t id) const {
  802|    120|    return (units_[id / UNIT_SIZE] >> (id % UNIT_SIZE) & 1) == 1;
  803|    120|  }
_ZNK5Darts7Details9BitVector8num_onesEv:
  822|      2|  std::size_t num_ones() const {
  823|      2|    return num_ones_;
  824|      2|  }
_ZNK5Darts7Details9BitVector4sizeEv:
  825|     99|  std::size_t size() const {
  826|     99|    return size_;
  827|     99|  }
_ZN5Darts7Details9BitVector6appendEv:
  829|     99|  void append() {
  830|     99|    if ((size_ % UNIT_SIZE) == 0) {
  ------------------
  |  Branch (830:9): [True: 4, False: 95]
  ------------------
  831|      4|      units_.append(0);
  832|      4|    }
  833|     99|    ++size_;
  834|     99|  }
_ZN5Darts7Details9BitVector5clearEv:
  837|      3|  void clear() {
  838|      3|    units_.clear();
  839|      3|    ranks_.clear();
  840|      3|  }
_ZN5Darts7Details9BitVector9pop_countEj:
  854|      4|  static id_type pop_count(id_type unit) {
  855|      4|    unit = ((unit & 0xAAAAAAAA) >> 1) + (unit & 0x55555555);
  856|      4|    unit = ((unit & 0xCCCCCCCC) >> 2) + (unit & 0x33333333);
  857|      4|    unit = ((unit >> 4) + unit) & 0x0F0F0F0F;
  858|      4|    unit += unit >> 8;
  859|      4|    unit += unit >> 16;
  860|      4|    return unit & 0xFF;
  861|      4|  }
_ZN5Darts7Details8DawgNodeC2Ev:
  942|     99|  DawgNode() : child_(0), sibling_(0), label_('\0'),
  943|     99|    is_state_(false), has_sibling_(false) {}
_ZN5Darts7Details8DawgNode9set_childEj:
  945|    158|  void set_child(id_type child) {
  946|    158|    child_ = child;
  947|    158|  }
_ZN5Darts7Details8DawgNode11set_siblingEj:
  948|     98|  void set_sibling(id_type sibling) {
  949|     98|    sibling_ = sibling;
  950|     98|  }
_ZN5Darts7Details8DawgNode9set_valueEi:
  951|     39|  void set_value(value_type value) {
  952|     39|    child_ = value;
  953|     39|  }
_ZN5Darts7Details8DawgNode9set_labelEh:
  954|     99|  void set_label(uchar_type label) {
  955|     99|    label_ = label;
  956|     99|  }
_ZN5Darts7Details8DawgNode12set_is_stateEb:
  957|     60|  void set_is_state(bool is_state) {
  958|     60|    is_state_ = is_state;
  959|     60|  }
_ZN5Darts7Details8DawgNode15set_has_siblingEb:
  960|     38|  void set_has_sibling(bool has_sibling) {
  961|     38|    has_sibling_ = has_sibling;
  962|     38|  }
_ZNK5Darts7Details8DawgNode5childEv:
  964|    269|  id_type child() const {
  965|    269|    return child_;
  966|    269|  }
_ZNK5Darts7Details8DawgNode7siblingEv:
  967|    394|  id_type sibling() const {
  968|    394|    return sibling_;
  969|    394|  }
_ZNK5Darts7Details8DawgNode5labelEv:
  973|    269|  uchar_type label() const {
  974|    269|    return label_;
  975|    269|  }
_ZNK5Darts7Details8DawgNode4unitEv:
  983|    199|  id_type unit() const {
  984|    199|    if (label_ == '\0') {
  ------------------
  |  Branch (984:9): [True: 78, False: 121]
  ------------------
  985|     78|      return (child_ << 1) | (has_sibling_ ? 1 : 0);
  ------------------
  |  Branch (985:31): [True: 18, False: 60]
  ------------------
  986|     78|    }
  987|    121|    return (child_ << 2) | (is_state_ ? 2 : 0) | (has_sibling_ ? 1 : 0);
  ------------------
  |  Branch (987:29): [True: 44, False: 77]
  |  Branch (987:51): [True: 58, False: 63]
  ------------------
  988|    199|  }
_ZN5Darts7Details8DawgUnitC2Ej:
 1006|     99|  explicit DawgUnit(id_type unit = 0) : unit_(unit) {}
_ZN5Darts7Details8DawgUnitC2ERKS1_:
 1007|    127|  DawgUnit(const DawgUnit &unit) : unit_(unit.unit_) {}
_ZN5Darts7Details8DawgUnitaSEj:
 1009|     99|  DawgUnit &operator=(id_type unit) {
 1010|     99|    unit_ = unit;
 1011|     99|    return *this;
 1012|     99|  }
_ZNK5Darts7Details8DawgUnit4unitEv:
 1014|      2|  id_type unit() const {
 1015|      2|    return unit_;
 1016|      2|  }
_ZNK5Darts7Details8DawgUnit5childEv:
 1018|    181|  id_type child() const {
 1019|    181|    return unit_ >> 2;
 1020|    181|  }
_ZNK5Darts7Details8DawgUnit11has_siblingEv:
 1021|    296|  bool has_sibling() const {
 1022|    296|    return (unit_ & 1) == 1;
 1023|    296|  }
_ZNK5Darts7Details8DawgUnit5valueEv:
 1024|     39|  value_type value() const {
 1025|     39|    return static_cast<value_type>(unit_ >> 1);
 1026|     39|  }
_ZN5Darts7Details11DawgBuilderC2Ev:
 1043|      1|  DawgBuilder() : nodes_(), units_(), labels_(), is_intersections_(),
 1044|      1|    table_(), node_stack_(), recycle_bin_(), num_states_(0) {}
_ZN5Darts7Details11DawgBuilderD2Ev:
 1045|      1|  ~DawgBuilder() {
 1046|      1|    clear();
 1047|      1|  }
_ZNK5Darts7Details11DawgBuilder4rootEv:
 1049|      2|  id_type root() const {
 1050|      2|    return 0;
 1051|      2|  }
_ZNK5Darts7Details11DawgBuilder5childEj:
 1053|    181|  id_type child(id_type id) const {
 1054|    181|    return units_[id].child();
 1055|    181|  }
_ZNK5Darts7Details11DawgBuilder7siblingEj:
 1056|    294|  id_type sibling(id_type id) const {
 1057|    294|    return units_[id].has_sibling() ? (id + 1) : 0;
  ------------------
  |  Branch (1057:12): [True: 114, False: 180]
  ------------------
 1058|    294|  }
_ZNK5Darts7Details11DawgBuilder5valueEj:
 1059|     39|  int value(id_type id) const {
 1060|     39|    return units_[id].value();
 1061|     39|  }
_ZNK5Darts7Details11DawgBuilder7is_leafEj:
 1063|     98|  bool is_leaf(id_type id) const {
 1064|     98|    return label(id) == '\0';
 1065|     98|  }
_ZNK5Darts7Details11DawgBuilder5labelEj:
 1066|    294|  uchar_type label(id_type id) const {
 1067|    294|    return labels_[id];
 1068|    294|  }
_ZNK5Darts7Details11DawgBuilder15is_intersectionEj:
 1070|    120|  bool is_intersection(id_type id) const {
 1071|    120|    return is_intersections_[id];
 1072|    120|  }
_ZNK5Darts7Details11DawgBuilder17num_intersectionsEv:
 1077|      2|  std::size_t num_intersections() const {
 1078|      2|    return is_intersections_.num_ones();
 1079|      2|  }
_ZNK5Darts7Details11DawgBuilder4sizeEv:
 1081|      8|  std::size_t size() const {
 1082|      8|    return units_.size();
 1083|      8|  }
_ZN5Darts7Details11DawgBuilder9free_nodeEj:
 1123|     98|  void free_node(id_type id) {
 1124|     98|    recycle_bin_.push(id);
 1125|     98|  }
_ZN5Darts7Details11DawgBuilder4hashEj:
 1127|     98|  static id_type hash(id_type key) {
 1128|     98|    key = ~key + (key << 15);  // key = (key << 15) - key - 1;
 1129|     98|    key = key ^ (key >> 12);
 1130|     98|    key = key + (key << 2);
 1131|     98|    key = key ^ (key >> 4);
 1132|     98|    key = key * 2057;  // key = (key + (key << 3)) + (key << 11);
 1133|     98|    key = key ^ (key >> 16);
 1134|     98|    return key;
 1135|     98|  }
_ZN5Darts7Details22DoubleArrayBuilderUnitC2Ev:
 1389|    256|  DoubleArrayBuilderUnit() : unit_(0) {}
_ZN5Darts7Details22DoubleArrayBuilderUnit12set_has_leafEb:
 1391|     39|  void set_has_leaf(bool has_leaf) {
 1392|     39|    if (has_leaf) {
  ------------------
  |  Branch (1392:9): [True: 39, False: 0]
  ------------------
 1393|     39|      unit_ |= 1U << 8;
 1394|     39|    } else {
 1395|      0|      unit_ &= ~(1U << 8);
 1396|      0|    }
 1397|     39|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit9set_valueEi:
 1398|     39|  void set_value(value_type value) {
 1399|     39|    unit_ = value | (1U << 31);
 1400|     39|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit9set_labelEh:
 1401|    217|  void set_label(uchar_type label) {
 1402|    217|    unit_ = (unit_ & ~0xFFU) | label;
 1403|    217|  }
_ZN5Darts7Details22DoubleArrayBuilderUnit10set_offsetEj:
 1404|     61|  void set_offset(id_type offset) {
 1405|     61|    if (offset >= 1U << 29) {
  ------------------
  |  Branch (1405:9): [True: 0, False: 61]
  ------------------
 1406|      0|      DARTS_THROW("failed to modify unit: too large offset");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1407|      0|    }
 1408|     61|    unit_ &= (1U << 31) | (1U << 8) | 0xFF;
 1409|     61|    if (offset < 1U << 21) {
  ------------------
  |  Branch (1409:9): [True: 61, False: 0]
  ------------------
 1410|     61|      unit_ |= (offset << 10);
 1411|     61|    } else {
 1412|      0|      unit_ |= (offset << 2) | (1U << 9);
 1413|      0|    }
 1414|     61|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnitC2Ev:
 1428|  4.09k|  DoubleArrayBuilderExtraUnit() : prev_(0), next_(0),
 1429|  4.09k|      is_fixed_(false), is_used_(false) {}
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit8set_prevEj:
 1431|    514|  void set_prev(id_type prev) {
 1432|    514|    prev_ = prev;
 1433|    514|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit8set_nextEj:
 1434|    514|  void set_next(id_type next) {
 1435|    514|    next_ = next;
 1436|    514|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit12set_is_fixedEb:
 1437|    256|  void set_is_fixed(bool is_fixed) {
 1438|    256|    is_fixed_ = is_fixed;
 1439|    256|  }
_ZN5Darts7Details27DoubleArrayBuilderExtraUnit11set_is_usedEb:
 1440|     61|  void set_is_used(bool is_used) {
 1441|     61|    is_used_ = is_used;
 1442|     61|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit4prevEv:
 1444|    514|  id_type prev() const {
 1445|    514|    return prev_;
 1446|    514|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit4nextEv:
 1447|    787|  id_type next() const {
 1448|    787|    return next_;
 1449|    787|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit8is_fixedEv:
 1450|    305|  bool is_fixed() const {
 1451|    305|    return is_fixed_;
 1452|    305|  }
_ZNK5Darts7Details27DoubleArrayBuilderExtraUnit7is_usedEv:
 1453|    132|  bool is_used() const {
 1454|    132|    return is_used_;
 1455|    132|  }
_ZN5Darts7Details18DoubleArrayBuilderC2EPFimmE:
 1473|      1|      : progress_func_(progress_func), units_(), extras_(), labels_(),
 1474|      1|        table_(), extras_head_(0) {}
_ZN5Darts7Details18DoubleArrayBuilderD2Ev:
 1475|      1|  ~DoubleArrayBuilder() {
 1476|      1|    clear();
 1477|      1|  }
_ZNK5Darts7Details18DoubleArrayBuilder10num_blocksEv:
 1507|      3|  std::size_t num_blocks() const {
 1508|      3|    return units_.size() / BLOCK_SIZE;
 1509|      3|  }
_ZNK5Darts7Details18DoubleArrayBuilder6extrasEj:
 1511|    249|  const extra_type &extras(id_type id) const {
 1512|    249|    return extras_[id % NUM_EXTRAS];
 1513|    249|  }
_ZN5Darts7Details18DoubleArrayBuilder6extrasEj:
 1514|  2.83k|  extra_type &extras(id_type id) {
 1515|  2.83k|    return extras_[id % NUM_EXTRAS];
 1516|  2.83k|  }
_ZN5Darts7Details9BitVector5buildEv:
  864|      1|inline void BitVector::build() {
  865|      1|  try {
  866|      1|    ranks_.reset(new id_type[units_.size()]);
  867|      1|  } catch (const std::bad_alloc &) {
  868|      0|    DARTS_THROW("failed to build rank index: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  869|      0|  }
  870|       |
  871|      1|  num_ones_ = 0;
  872|      5|  for (std::size_t i = 0; i < units_.size(); ++i) {
  ------------------
  |  Branch (872:27): [True: 4, False: 1]
  ------------------
  873|      4|    ranks_[i] = num_ones_;
  874|      4|    num_ones_ += pop_count(units_[i]);
  875|      4|  }
  876|      1|}
_ZN5Darts7Details11DawgBuilder4initEv:
 1138|      1|inline void DawgBuilder::init() {
 1139|      1|  table_.resize(INITIAL_TABLE_SIZE, 0);
 1140|       |
 1141|      1|  append_node();
 1142|      1|  append_unit();
 1143|       |
 1144|      1|  num_states_ = 1;
 1145|       |
 1146|      1|  nodes_[0].set_label(0xFF);
 1147|      1|  node_stack_.push(0);
 1148|      1|}
_ZN5Darts7Details11DawgBuilder6finishEv:
 1150|      1|inline void DawgBuilder::finish() {
 1151|      1|  flush(0);
 1152|       |
 1153|      1|  units_[0] = nodes_[0].unit();
 1154|      1|  labels_[0] = nodes_[0].label();
 1155|       |
 1156|      1|  nodes_.clear();
 1157|      1|  table_.clear();
 1158|      1|  node_stack_.clear();
 1159|      1|  recycle_bin_.clear();
 1160|       |
 1161|      1|  is_intersections_.build();
 1162|      1|}
_ZN5Darts7Details11DawgBuilder6insertEPKcmi:
 1165|     39|    value_type value) {
 1166|     39|  if (value < 0) {
  ------------------
  |  Branch (1166:7): [True: 0, False: 39]
  ------------------
 1167|      0|    DARTS_THROW("failed to insert key: negative value");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1168|     39|  } else if (length == 0) {
  ------------------
  |  Branch (1168:14): [True: 0, False: 39]
  ------------------
 1169|      0|    DARTS_THROW("failed to insert key: zero-length key");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1170|      0|  }
 1171|       |
 1172|     39|  id_type id = 0;
 1173|     39|  std::size_t key_pos = 0;
 1174|       |
 1175|     73|  for ( ; key_pos <= length; ++key_pos) {
  ------------------
  |  Branch (1175:11): [True: 73, False: 0]
  ------------------
 1176|     73|    id_type child_id = nodes_[id].child();
 1177|     73|    if (child_id == 0) {
  ------------------
  |  Branch (1177:9): [True: 1, False: 72]
  ------------------
 1178|      1|      break;
 1179|      1|    }
 1180|       |
 1181|     72|    uchar_type key_label = static_cast<uchar_type>(key[key_pos]);
 1182|     72|    if (key_pos < length && key_label == '\0') {
  ------------------
  |  Branch (1182:9): [True: 72, False: 0]
  |  Branch (1182:29): [True: 0, False: 72]
  ------------------
 1183|      0|      DARTS_THROW("failed to insert key: invalid null character");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1184|      0|    }
 1185|       |
 1186|     72|    uchar_type unit_label = nodes_[child_id].label();
 1187|     72|    if (key_label < unit_label) {
  ------------------
  |  Branch (1187:9): [True: 0, False: 72]
  ------------------
 1188|      0|      DARTS_THROW("failed to insert key: wrong key order");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
 1189|     72|    } else if (key_label > unit_label) {
  ------------------
  |  Branch (1189:16): [True: 38, False: 34]
  ------------------
 1190|     38|      nodes_[child_id].set_has_sibling(true);
 1191|     38|      flush(child_id);
 1192|     38|      break;
 1193|     38|    }
 1194|     34|    id = child_id;
 1195|     34|  }
 1196|       |
 1197|     39|  if (key_pos > length) {
  ------------------
  |  Branch (1197:7): [True: 0, False: 39]
  ------------------
 1198|      0|    return;
 1199|      0|  }
 1200|       |
 1201|    137|  for ( ; key_pos <= length; ++key_pos) {
  ------------------
  |  Branch (1201:11): [True: 98, False: 39]
  ------------------
 1202|     98|    uchar_type key_label = static_cast<uchar_type>(
 1203|     98|        (key_pos < length) ? key[key_pos] : '\0');
  ------------------
  |  Branch (1203:9): [True: 59, False: 39]
  ------------------
 1204|     98|    id_type child_id = append_node();
 1205|       |
 1206|     98|    if (nodes_[id].child() == 0) {
  ------------------
  |  Branch (1206:9): [True: 60, False: 38]
  ------------------
 1207|     60|      nodes_[child_id].set_is_state(true);
 1208|     60|    }
 1209|     98|    nodes_[child_id].set_sibling(nodes_[id].child());
 1210|     98|    nodes_[child_id].set_label(key_label);
 1211|     98|    nodes_[id].set_child(child_id);
 1212|     98|    node_stack_.push(child_id);
 1213|       |
 1214|     98|    id = child_id;
 1215|     98|  }
 1216|     39|  nodes_[id].set_value(value);
 1217|     39|}
_ZN5Darts7Details11DawgBuilder5clearEv:
 1219|      2|inline void DawgBuilder::clear() {
 1220|      2|  nodes_.clear();
 1221|      2|  units_.clear();
 1222|      2|  labels_.clear();
 1223|      2|  is_intersections_.clear();
 1224|      2|  table_.clear();
 1225|      2|  node_stack_.clear();
 1226|      2|  recycle_bin_.clear();
 1227|      2|  num_states_ = 0;
 1228|      2|}
_ZN5Darts7Details11DawgBuilder5flushEj:
 1230|     39|inline void DawgBuilder::flush(id_type id) {
 1231|     99|  while (node_stack_.top() != id) {
  ------------------
  |  Branch (1231:10): [True: 60, False: 39]
  ------------------
 1232|     60|    id_type node_id = node_stack_.top();
 1233|     60|    node_stack_.pop();
 1234|       |
 1235|     60|    if (num_states_ >= table_.size() - (table_.size() >> 2)) {
  ------------------
  |  Branch (1235:9): [True: 0, False: 60]
  ------------------
 1236|      0|      expand_table();
 1237|      0|    }
 1238|       |
 1239|     60|    id_type num_siblings = 0;
 1240|    158|    for (id_type i = node_id; i != 0; i = nodes_[i].sibling()) {
  ------------------
  |  Branch (1240:31): [True: 98, False: 60]
  ------------------
 1241|     98|      ++num_siblings;
 1242|     98|    }
 1243|       |
 1244|     60|    id_type hash_id;
 1245|     60|    id_type match_id = find_node(node_id, &hash_id);
 1246|     60|    if (match_id != 0) {
  ------------------
  |  Branch (1246:9): [True: 0, False: 60]
  ------------------
 1247|      0|      is_intersections_.set(match_id, true);
 1248|     60|    } else {
 1249|     60|      id_type unit_id = 0;
 1250|    158|      for (id_type i = 0; i < num_siblings; ++i) {
  ------------------
  |  Branch (1250:27): [True: 98, False: 60]
  ------------------
 1251|     98|        unit_id = append_unit();
 1252|     98|      }
 1253|    158|      for (id_type i = node_id; i != 0; i = nodes_[i].sibling()) {
  ------------------
  |  Branch (1253:33): [True: 98, False: 60]
  ------------------
 1254|     98|        units_[unit_id] = nodes_[i].unit();
 1255|     98|        labels_[unit_id] = nodes_[i].label();
 1256|     98|        --unit_id;
 1257|     98|      }
 1258|     60|      match_id = unit_id + 1;
 1259|     60|      table_[hash_id] = match_id;
 1260|     60|      ++num_states_;
 1261|     60|    }
 1262|       |
 1263|    158|    for (id_type i = node_id, next; i != 0; i = next) {
  ------------------
  |  Branch (1263:37): [True: 98, False: 60]
  ------------------
 1264|     98|      next = nodes_[i].sibling();
 1265|     98|      free_node(i);
 1266|     98|    }
 1267|       |
 1268|     60|    nodes_[node_stack_.top()].set_child(match_id);
 1269|     60|  }
 1270|     39|  node_stack_.pop();
 1271|     39|}
_ZNK5Darts7Details11DawgBuilder9find_nodeEjPj:
 1302|     60|    id_type *hash_id) const {
 1303|     60|  *hash_id = hash_node(node_id) % table_.size();
 1304|     62|  for ( ; ; *hash_id = (*hash_id + 1) % table_.size()) {
 1305|     62|    id_type unit_id = table_[*hash_id];
 1306|     62|    if (unit_id == 0) {
  ------------------
  |  Branch (1306:9): [True: 60, False: 2]
  ------------------
 1307|     60|      break;
 1308|     60|    }
 1309|       |
 1310|      2|    if (are_equal(node_id, unit_id)) {
  ------------------
  |  Branch (1310:9): [True: 0, False: 2]
  ------------------
 1311|      0|      return unit_id;
 1312|      0|    }
 1313|      2|  }
 1314|     60|  return 0;
 1315|     60|}
_ZNK5Darts7Details11DawgBuilder9are_equalEjj:
 1317|      2|inline bool DawgBuilder::are_equal(id_type node_id, id_type unit_id) const {
 1318|      2|  for (id_type i = nodes_[node_id].sibling(); i != 0;
  ------------------
  |  Branch (1318:47): [True: 0, False: 2]
  ------------------
 1319|      2|      i = nodes_[i].sibling()) {
 1320|      0|    if (units_[unit_id].has_sibling() == false) {
  ------------------
  |  Branch (1320:9): [True: 0, False: 0]
  ------------------
 1321|      0|      return false;
 1322|      0|    }
 1323|      0|    ++unit_id;
 1324|      0|  }
 1325|      2|  if (units_[unit_id].has_sibling() == true) {
  ------------------
  |  Branch (1325:7): [True: 0, False: 2]
  ------------------
 1326|      0|    return false;
 1327|      0|  }
 1328|       |
 1329|      2|  for (id_type i = node_id; i != 0; i = nodes_[i].sibling(), --unit_id) {
  ------------------
  |  Branch (1329:29): [True: 2, False: 0]
  ------------------
 1330|      2|    if (nodes_[i].unit() != units_[unit_id].unit() ||
  ------------------
  |  Branch (1330:9): [True: 2, False: 0]
  ------------------
 1331|      2|        nodes_[i].label() != labels_[unit_id]) {
  ------------------
  |  Branch (1331:9): [True: 0, False: 0]
  ------------------
 1332|      2|      return false;
 1333|      2|    }
 1334|      2|  }
 1335|      0|  return true;
 1336|      2|}
_ZNK5Darts7Details11DawgBuilder9hash_nodeEj:
 1352|     60|inline id_type DawgBuilder::hash_node(id_type id) const {
 1353|     60|  id_type hash_value = 0;
 1354|    158|  for ( ; id != 0; id = nodes_[id].sibling()) {
  ------------------
  |  Branch (1354:11): [True: 98, False: 60]
  ------------------
 1355|     98|    id_type unit = nodes_[id].unit();
 1356|     98|    uchar_type label = nodes_[id].label();
 1357|     98|    hash_value ^= hash((label << 24) ^ unit);
 1358|     98|  }
 1359|     60|  return hash_value;
 1360|     60|}
_ZN5Darts7Details11DawgBuilder11append_unitEv:
 1362|     99|inline id_type DawgBuilder::append_unit() {
 1363|     99|  is_intersections_.append();
 1364|     99|  units_.append();
 1365|     99|  labels_.append();
 1366|       |
 1367|     99|  return static_cast<id_type>(is_intersections_.size() - 1);
 1368|     99|}
_ZN5Darts7Details11DawgBuilder11append_nodeEv:
 1370|     99|inline id_type DawgBuilder::append_node() {
 1371|     99|  id_type id;
 1372|     99|  if (recycle_bin_.empty()) {
  ------------------
  |  Branch (1372:7): [True: 36, False: 63]
  ------------------
 1373|     36|    id = static_cast<id_type>(nodes_.size());
 1374|     36|    nodes_.append();
 1375|     63|  } else {
 1376|     63|    id = recycle_bin_.top();
 1377|     63|    nodes_[id] = DawgNode();
 1378|     63|    recycle_bin_.pop();
 1379|     63|  }
 1380|     99|  return id;
 1381|     99|}
_ZNK5Darts7Details18DoubleArrayBuilder4copyEPmPPNS0_15DoubleArrayUnitE:
 1558|      1|    DoubleArrayUnit **buf_ptr) const {
 1559|      1|  if (size_ptr != NULL) {
  ------------------
  |  Branch (1559:7): [True: 1, False: 0]
  ------------------
 1560|      1|    *size_ptr = units_.size();
 1561|      1|  }
 1562|      1|  if (buf_ptr != NULL) {
  ------------------
  |  Branch (1562:7): [True: 1, False: 0]
  ------------------
 1563|      1|    *buf_ptr = new DoubleArrayUnit[units_.size()];
 1564|      1|    unit_type *units = reinterpret_cast<unit_type *>(*buf_ptr);
 1565|    257|    for (std::size_t i = 0; i < units_.size(); ++i) {
  ------------------
  |  Branch (1565:29): [True: 256, False: 1]
  ------------------
 1566|    256|      units[i] = units_[i];
 1567|    256|    }
 1568|      1|  }
 1569|      1|}
_ZN5Darts7Details18DoubleArrayBuilder5clearEv:
 1571|      1|inline void DoubleArrayBuilder::clear() {
 1572|      1|  units_.clear();
 1573|      1|  extras_.clear();
 1574|      1|  labels_.clear();
 1575|      1|  table_.clear();
 1576|      1|  extras_head_ = 0;
 1577|      1|}
_ZN5Darts7Details18DoubleArrayBuilder15build_from_dawgERKNS0_11DawgBuilderE:
 1592|      1|inline void DoubleArrayBuilder::build_from_dawg(const DawgBuilder &dawg) {
 1593|      1|  std::size_t num_units = 1;
 1594|      8|  while (num_units < dawg.size()) {
  ------------------
  |  Branch (1594:10): [True: 7, False: 1]
  ------------------
 1595|      7|    num_units <<= 1;
 1596|      7|  }
 1597|      1|  units_.reserve(num_units);
 1598|       |
 1599|      1|  table_.reset(new id_type[dawg.num_intersections()]);
 1600|      1|  for (std::size_t i = 0; i < dawg.num_intersections(); ++i) {
  ------------------
  |  Branch (1600:27): [True: 0, False: 1]
  ------------------
 1601|      0|    table_[i] = 0;
 1602|      0|  }
 1603|       |
 1604|      1|  extras_.reset(new extra_type[NUM_EXTRAS]);
 1605|       |
 1606|      1|  reserve_id(0);
 1607|      1|  extras(0).set_is_used(true);
 1608|      1|  units_[0].set_offset(1);
 1609|      1|  units_[0].set_label('\0');
 1610|       |
 1611|      1|  if (dawg.child(dawg.root()) != 0) {
  ------------------
  |  Branch (1611:7): [True: 1, False: 0]
  ------------------
 1612|      1|    build_from_dawg(dawg, dawg.root(), 0);
 1613|      1|  }
 1614|       |
 1615|      1|  fix_all_blocks();
 1616|       |
 1617|      1|  extras_.clear();
 1618|      1|  labels_.clear();
 1619|      1|  table_.clear();
 1620|      1|}
_ZN5Darts7Details18DoubleArrayBuilder15build_from_dawgERKNS0_11DawgBuilderEjj:
 1623|     60|    id_type dawg_id, id_type dic_id) {
 1624|     60|  id_type dawg_child_id = dawg.child(dawg_id);
 1625|     60|  if (dawg.is_intersection(dawg_child_id)) {
  ------------------
  |  Branch (1625:7): [True: 0, False: 60]
  ------------------
 1626|      0|    id_type intersection_id = dawg.intersection_id(dawg_child_id);
 1627|      0|    id_type offset = table_[intersection_id];
 1628|      0|    if (offset != 0) {
  ------------------
  |  Branch (1628:9): [True: 0, False: 0]
  ------------------
 1629|      0|      offset ^= dic_id;
 1630|      0|      if (!(offset & UPPER_MASK) || !(offset & LOWER_MASK)) {
  ------------------
  |  Branch (1630:11): [True: 0, False: 0]
  |  Branch (1630:37): [True: 0, False: 0]
  ------------------
 1631|      0|        if (dawg.is_leaf(dawg_child_id)) {
  ------------------
  |  Branch (1631:13): [True: 0, False: 0]
  ------------------
 1632|      0|          units_[dic_id].set_has_leaf(true);
 1633|      0|        }
 1634|      0|        units_[dic_id].set_offset(offset);
 1635|      0|        return;
 1636|      0|      }
 1637|      0|    }
 1638|      0|  }
 1639|       |
 1640|     60|  id_type offset = arrange_from_dawg(dawg, dawg_id, dic_id);
 1641|     60|  if (dawg.is_intersection(dawg_child_id)) {
  ------------------
  |  Branch (1641:7): [True: 0, False: 60]
  ------------------
 1642|      0|    table_[dawg.intersection_id(dawg_child_id)] = offset;
 1643|      0|  }
 1644|       |
 1645|     98|  do {
 1646|     98|    uchar_type child_label = dawg.label(dawg_child_id);
 1647|     98|    id_type dic_child_id = offset ^ child_label;
 1648|     98|    if (child_label != '\0') {
  ------------------
  |  Branch (1648:9): [True: 59, False: 39]
  ------------------
 1649|     59|      build_from_dawg(dawg, dawg_child_id, dic_child_id);
 1650|     59|    }
 1651|     98|    dawg_child_id = dawg.sibling(dawg_child_id);
 1652|     98|  } while (dawg_child_id != 0);
  ------------------
  |  Branch (1652:12): [True: 38, False: 60]
  ------------------
 1653|     60|}
_ZN5Darts7Details18DoubleArrayBuilder17arrange_from_dawgERKNS0_11DawgBuilderEjj:
 1656|     60|    id_type dawg_id, id_type dic_id) {
 1657|     60|  labels_.resize(0);
 1658|       |
 1659|     60|  id_type dawg_child_id = dawg.child(dawg_id);
 1660|    158|  while (dawg_child_id != 0) {
  ------------------
  |  Branch (1660:10): [True: 98, False: 60]
  ------------------
 1661|     98|    labels_.append(dawg.label(dawg_child_id));
 1662|     98|    dawg_child_id = dawg.sibling(dawg_child_id);
 1663|     98|  }
 1664|       |
 1665|     60|  id_type offset = find_valid_offset(dic_id);
 1666|     60|  units_[dic_id].set_offset(dic_id ^ offset);
 1667|       |
 1668|     60|  dawg_child_id = dawg.child(dawg_id);
 1669|    158|  for (std::size_t i = 0; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1669:27): [True: 98, False: 60]
  ------------------
 1670|     98|    id_type dic_child_id = offset ^ labels_[i];
 1671|     98|    reserve_id(dic_child_id);
 1672|       |
 1673|     98|    if (dawg.is_leaf(dawg_child_id)) {
  ------------------
  |  Branch (1673:9): [True: 39, False: 59]
  ------------------
 1674|     39|      units_[dic_id].set_has_leaf(true);
 1675|     39|      units_[dic_child_id].set_value(dawg.value(dawg_child_id));
 1676|     59|    } else {
 1677|     59|      units_[dic_child_id].set_label(labels_[i]);
 1678|     59|    }
 1679|       |
 1680|     98|    dawg_child_id = dawg.sibling(dawg_child_id);
 1681|     98|  }
 1682|     60|  extras(offset).set_is_used(true);
 1683|       |
 1684|     60|  return offset;
 1685|     60|}
_ZNK5Darts7Details18DoubleArrayBuilder17find_valid_offsetEj:
 1793|     60|inline id_type DoubleArrayBuilder::find_valid_offset(id_type id) const {
 1794|     60|  if (extras_head_ >= units_.size()) {
  ------------------
  |  Branch (1794:7): [True: 0, False: 60]
  ------------------
 1795|      0|    return units_.size() | (id & LOWER_MASK);
 1796|      0|  }
 1797|       |
 1798|     60|  id_type unfixed_id = extras_head_;
 1799|    130|  do {
 1800|    130|    id_type offset = unfixed_id ^ labels_[0];
 1801|    130|    if (is_valid_offset(id, offset)) {
  ------------------
  |  Branch (1801:9): [True: 60, False: 70]
  ------------------
 1802|     60|      return offset;
 1803|     60|    }
 1804|     70|    unfixed_id = extras(unfixed_id).next();
 1805|     70|  } while (unfixed_id != extras_head_);
  ------------------
  |  Branch (1805:12): [True: 70, False: 0]
  ------------------
 1806|       |
 1807|      0|  return units_.size() | (id & LOWER_MASK);
 1808|     60|}
_ZNK5Darts7Details18DoubleArrayBuilder15is_valid_offsetEjj:
 1811|    130|    id_type offset) const {
 1812|    130|  if (extras(offset).is_used()) {
  ------------------
  |  Branch (1812:7): [True: 64, False: 66]
  ------------------
 1813|     64|    return false;
 1814|     64|  }
 1815|       |
 1816|     66|  id_type rel_offset = id ^ offset;
 1817|     66|  if ((rel_offset & LOWER_MASK) && (rel_offset & UPPER_MASK)) {
  ------------------
  |  Branch (1817:7): [True: 66, False: 0]
  |  Branch (1817:36): [True: 0, False: 66]
  ------------------
 1818|      0|    return false;
 1819|      0|  }
 1820|       |
 1821|    109|  for (std::size_t i = 1; i < labels_.size(); ++i) {
  ------------------
  |  Branch (1821:27): [True: 49, False: 60]
  ------------------
 1822|     49|    if (extras(offset ^ labels_[i]).is_fixed()) {
  ------------------
  |  Branch (1822:9): [True: 6, False: 43]
  ------------------
 1823|      6|      return false;
 1824|      6|    }
 1825|     49|  }
 1826|       |
 1827|     60|  return true;
 1828|     66|}
_ZN5Darts7Details18DoubleArrayBuilder10reserve_idEj:
 1830|    256|inline void DoubleArrayBuilder::reserve_id(id_type id) {
 1831|    256|  if (id >= units_.size()) {
  ------------------
  |  Branch (1831:7): [True: 1, False: 255]
  ------------------
 1832|      1|    expand_units();
 1833|      1|  }
 1834|       |
 1835|    256|  if (id == extras_head_) {
  ------------------
  |  Branch (1835:7): [True: 205, False: 51]
  ------------------
 1836|    205|    extras_head_ = extras(id).next();
 1837|    205|    if (extras_head_ == id) {
  ------------------
  |  Branch (1837:9): [True: 1, False: 204]
  ------------------
 1838|      1|      extras_head_ = units_.size();
 1839|      1|    }
 1840|    205|  }
 1841|    256|  extras(extras(id).prev()).set_next(extras(id).next());
 1842|    256|  extras(extras(id).next()).set_prev(extras(id).prev());
 1843|    256|  extras(id).set_is_fixed(true);
 1844|    256|}
_ZN5Darts7Details18DoubleArrayBuilder12expand_unitsEv:
 1846|      1|inline void DoubleArrayBuilder::expand_units() {
 1847|      1|  id_type src_num_units = units_.size();
 1848|      1|  id_type src_num_blocks = num_blocks();
 1849|       |
 1850|      1|  id_type dest_num_units = src_num_units + BLOCK_SIZE;
 1851|      1|  id_type dest_num_blocks = src_num_blocks + 1;
 1852|       |
 1853|      1|  if (dest_num_blocks > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1853:7): [True: 0, False: 1]
  ------------------
 1854|      0|    fix_block(src_num_blocks - NUM_EXTRA_BLOCKS);
 1855|      0|  }
 1856|       |
 1857|      1|  units_.resize(dest_num_units);
 1858|       |
 1859|      1|  if (dest_num_blocks > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1859:7): [True: 0, False: 1]
  ------------------
 1860|      0|    for (std::size_t id = src_num_units; id < dest_num_units; ++id) {
  ------------------
  |  Branch (1860:42): [True: 0, False: 0]
  ------------------
 1861|      0|      extras(id).set_is_used(false);
 1862|      0|      extras(id).set_is_fixed(false);
 1863|      0|    }
 1864|      0|  }
 1865|       |
 1866|    256|  for (id_type i = src_num_units + 1; i < dest_num_units; ++i) {
  ------------------
  |  Branch (1866:39): [True: 255, False: 1]
  ------------------
 1867|    255|    extras(i - 1).set_next(i);
 1868|    255|    extras(i).set_prev(i - 1);
 1869|    255|  }
 1870|       |
 1871|      1|  extras(src_num_units).set_prev(dest_num_units - 1);
 1872|      1|  extras(dest_num_units - 1).set_next(src_num_units);
 1873|       |
 1874|      1|  extras(src_num_units).set_prev(extras(extras_head_).prev());
 1875|      1|  extras(dest_num_units - 1).set_next(extras_head_);
 1876|       |
 1877|      1|  extras(extras(extras_head_).prev()).set_next(src_num_units);
 1878|      1|  extras(extras_head_).set_prev(dest_num_units - 1);
 1879|      1|}
_ZN5Darts7Details18DoubleArrayBuilder14fix_all_blocksEv:
 1881|      1|inline void DoubleArrayBuilder::fix_all_blocks() {
 1882|      1|  id_type begin = 0;
 1883|      1|  if (num_blocks() > NUM_EXTRA_BLOCKS) {
  ------------------
  |  Branch (1883:7): [True: 0, False: 1]
  ------------------
 1884|      0|    begin = num_blocks() - NUM_EXTRA_BLOCKS;
 1885|      0|  }
 1886|      1|  id_type end = num_blocks();
 1887|       |
 1888|      2|  for (id_type block_id = begin; block_id != end; ++block_id) {
  ------------------
  |  Branch (1888:34): [True: 1, False: 1]
  ------------------
 1889|      1|    fix_block(block_id);
 1890|      1|  }
 1891|      1|}
_ZN5Darts7Details18DoubleArrayBuilder9fix_blockEj:
 1893|      1|inline void DoubleArrayBuilder::fix_block(id_type block_id) {
 1894|      1|  id_type begin = block_id * BLOCK_SIZE;
 1895|      1|  id_type end = begin + BLOCK_SIZE;
 1896|       |
 1897|      1|  id_type unused_offset = 0;
 1898|      2|  for (id_type offset = begin; offset != end; ++offset) {
  ------------------
  |  Branch (1898:32): [True: 2, False: 0]
  ------------------
 1899|      2|    if (!extras(offset).is_used()) {
  ------------------
  |  Branch (1899:9): [True: 1, False: 1]
  ------------------
 1900|      1|      unused_offset = offset;
 1901|      1|      break;
 1902|      1|    }
 1903|      2|  }
 1904|       |
 1905|    257|  for (id_type id = begin; id != end; ++id) {
  ------------------
  |  Branch (1905:28): [True: 256, False: 1]
  ------------------
 1906|    256|    if (!extras(id).is_fixed()) {
  ------------------
  |  Branch (1906:9): [True: 157, False: 99]
  ------------------
 1907|    157|      reserve_id(id);
 1908|    157|      units_[id].set_label(static_cast<uchar_type>(id ^ unused_offset));
 1909|    157|    }
 1910|    256|  }
 1911|      1|}
_ZN5Darts7Details9AutoArrayIcE5clearEv:
  600|    136|  void clear() {
  601|    136|    if (array_ != NULL) {
  ------------------
  |  Branch (601:9): [True: 47, False: 89]
  ------------------
  602|     47|      delete[] array_;
  603|       |      array_ = NULL;
  604|     47|    }
  605|    136|  }
_ZNK5Darts7Details8AutoPoolIjEixEm:
  633|    182|  const T &operator[](std::size_t id) const {
  634|    182|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|    182|  }
_ZNK5Darts7Details9AutoArrayIcEixEm:
  589|  1.72k|  const T &operator[](std::size_t id) const {
  590|  1.72k|    return array_[id];
  591|  1.72k|  }
_ZN5Darts7Details8AutoPoolIjEixEm:
  636|  2.79k|  T &operator[](std::size_t id) {
  637|  2.79k|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|  2.79k|  }
_ZN5Darts7Details9AutoArrayIcEixEm:
  592|  6.14k|  T &operator[](std::size_t id) {
  593|  6.14k|    return array_[id];
  594|  6.14k|  }
_ZNK5Darts7Details8AutoPoolIjE5emptyEv:
  640|     99|  bool empty() const {
  641|     99|    return size_ == 0;
  642|     99|  }
_ZN5Darts7Details8AutoPoolIjE6appendERKj:
  666|    201|  void append(const T &value) {
  667|    201|    if (size_ == capacity_)
  ------------------
  |  Branch (667:9): [True: 15, False: 186]
  ------------------
  668|     15|      resize_buf(size_ + 1);
  669|    201|    new(&(*this)[size_++]) T(value);
  670|    201|  }
_ZN5Darts7Details8AutoPoolIjE10resize_bufEm:
  714|     16|void AutoPool<T>::resize_buf(std::size_t size) {
  715|     16|  std::size_t capacity;
  716|     16|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 7, False: 9]
  ------------------
  717|      7|    capacity = size;
  718|      9|  } else {
  719|      9|    capacity = 1;
  720|     40|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 31, False: 9]
  ------------------
  721|     31|      capacity <<= 1;
  722|     31|    }
  723|      9|  }
  724|       |
  725|     16|  AutoArray<char> buf;
  726|     16|  try {
  727|     16|    buf.reset(new char[sizeof(T) * capacity]);
  728|     16|  } catch (const std::bad_alloc &) {
  729|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  730|      0|  }
  731|       |
  732|     16|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 12, False: 4]
  ------------------
  733|     12|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|     12|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|     93|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 81, False: 12]
  ------------------
  736|     81|      new(&dest[i]) T(src[i]);
  737|     81|      src[i].~T();
  738|     81|    }
  739|     12|  }
  740|       |
  741|     16|  buf_.swap(&buf);
  742|     16|  capacity_ = capacity;
  743|     16|}
_ZN5Darts7Details9AutoArrayIcE5resetEPc:
  611|     47|  void reset(T *array = NULL) {
  612|     47|    AutoArray(array).swap(this);
  613|     47|  }
_ZN5Darts7Details9AutoArrayIcE4swapEPS2_:
  606|     94|  void swap(AutoArray *array) {
  607|     94|    T *temp = array_;
  608|     94|    array_ = array->array_;
  609|     94|    array->array_ = temp;
  610|     94|  }
_ZN5Darts7Details8AutoPoolIjE5clearEv:
  647|     18|  void clear() {
  648|     18|    resize(0);
  649|     18|    buf_.clear();
  650|     18|    size_ = 0;
  651|     18|    capacity_ = 0;
  652|     18|  }
_ZN5Darts7Details8AutoPoolIjE6resizeEm:
  672|     18|  void resize(std::size_t size) {
  673|  1.08k|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 1.06k, False: 18]
  ------------------
  674|  1.06k|      (*this)[--size_].~T();
  675|  1.06k|    }
  676|     18|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 18]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|     18|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 18]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|     18|  }
_ZN5Darts7Details9AutoArrayIjE5clearEv:
  600|      9|  void clear() {
  601|      9|    if (array_ != NULL) {
  ------------------
  |  Branch (601:9): [True: 2, False: 7]
  ------------------
  602|      2|      delete[] array_;
  603|       |      array_ = NULL;
  604|      2|    }
  605|      9|  }
_ZN5Darts7Details9AutoArrayIjE5resetEPj:
  611|      2|  void reset(T *array = NULL) {
  612|      2|    AutoArray(array).swap(this);
  613|      2|  }
_ZN5Darts7Details9AutoArrayIjE4swapEPS2_:
  606|      2|  void swap(AutoArray *array) {
  607|      2|    T *temp = array_;
  608|      2|    array_ = array->array_;
  609|      2|    array->array_ = temp;
  610|      2|  }
_ZNK5Darts7Details8AutoPoolIjE4sizeEv:
  643|    470|  std::size_t size() const {
  644|    470|    return size_;
  645|    470|  }
_ZN5Darts7Details9AutoArrayIjEixEm:
  592|      4|  T &operator[](std::size_t id) {
  593|      4|    return array_[id];
  594|      4|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgUnitEEixEm:
  633|    518|  const T &operator[](std::size_t id) const {
  634|    518|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|    518|  }
_ZNK5Darts7Details8AutoPoolIhEixEm:
  633|    473|  const T &operator[](std::size_t id) const {
  634|    473|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|    473|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgUnitEE4sizeEv:
  643|      8|  std::size_t size() const {
  644|      8|    return size_;
  645|      8|  }
_ZN5Darts7Details9AutoStackIjE4pushERKj:
  771|    197|  void push(const T &value) {
  772|    197|    pool_.push_back(value);
  773|    197|  }
_ZN5Darts7Details8AutoPoolIjE9push_backERKj:
  654|    197|  void push_back(const T &value) {
  655|    197|    append(value);
  656|    197|  }
_ZN5Darts7Details8AutoPoolIjE6resizeEmRKj:
  683|      1|  void resize(std::size_t size, const T &value) {
  684|      1|    while (size_ > size) {
  ------------------
  |  Branch (684:12): [True: 0, False: 1]
  ------------------
  685|      0|      (*this)[--size_].~T();
  686|      0|    }
  687|      1|    if (size > capacity_) {
  ------------------
  |  Branch (687:9): [True: 1, False: 0]
  ------------------
  688|      1|      resize_buf(size);
  689|      1|    }
  690|  1.02k|    while (size_ < size) {
  ------------------
  |  Branch (690:12): [True: 1.02k, False: 1]
  ------------------
  691|  1.02k|      new(&(*this)[size_++]) T(value);
  692|  1.02k|    }
  693|      1|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEEixEm:
  636|  1.46k|  T &operator[](std::size_t id) {
  637|  1.46k|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|  1.46k|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEEixEm:
  636|    297|  T &operator[](std::size_t id) {
  637|    297|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|    297|  }
_ZN5Darts7Details8AutoPoolIhEixEm:
  636|    650|  T &operator[](std::size_t id) {
  637|    650|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|    650|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE5clearEv:
  647|      4|  void clear() {
  648|      4|    resize(0);
  649|      4|    buf_.clear();
  650|      4|    size_ = 0;
  651|      4|    capacity_ = 0;
  652|      4|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE6resizeEm:
  672|      4|  void resize(std::size_t size) {
  673|     40|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 36, False: 4]
  ------------------
  674|     36|      (*this)[--size_].~T();
  675|     36|    }
  676|      4|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 4]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|      4|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 4]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|      4|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE10resize_bufEm:
  714|      7|void AutoPool<T>::resize_buf(std::size_t size) {
  715|      7|  std::size_t capacity;
  716|      7|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 2, False: 5]
  ------------------
  717|      2|    capacity = size;
  718|      5|  } else {
  719|      5|    capacity = 1;
  720|     25|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 20, False: 5]
  ------------------
  721|     20|      capacity <<= 1;
  722|     20|    }
  723|      5|  }
  724|       |
  725|      7|  AutoArray<char> buf;
  726|      7|  try {
  727|      7|    buf.reset(new char[sizeof(T) * capacity]);
  728|      7|  } catch (const std::bad_alloc &) {
  729|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  730|      0|  }
  731|       |
  732|      7|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 6, False: 1]
  ------------------
  733|      6|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|      6|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|     69|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 63, False: 6]
  ------------------
  736|     63|      new(&dest[i]) T(src[i]);
  737|     63|      src[i].~T();
  738|     63|    }
  739|      6|  }
  740|       |
  741|      7|  buf_.swap(&buf);
  742|      7|  capacity_ = capacity;
  743|      7|}
_ZN5Darts7Details9AutoStackIjE5clearEv:
  778|      8|  void clear() {
  779|      8|    pool_.clear();
  780|      8|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE5clearEv:
  647|      3|  void clear() {
  648|      3|    resize(0);
  649|      3|    buf_.clear();
  650|      3|    size_ = 0;
  651|      3|    capacity_ = 0;
  652|      3|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE6resizeEm:
  672|      3|  void resize(std::size_t size) {
  673|    102|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 99, False: 3]
  ------------------
  674|     99|      (*this)[--size_].~T();
  675|     99|    }
  676|      3|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 3]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|      3|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 3]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|      3|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE10resize_bufEm:
  714|      8|void AutoPool<T>::resize_buf(std::size_t size) {
  715|      8|  std::size_t capacity;
  716|      8|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 2, False: 6]
  ------------------
  717|      2|    capacity = size;
  718|      6|  } else {
  719|      6|    capacity = 1;
  720|     33|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 27, False: 6]
  ------------------
  721|     27|      capacity <<= 1;
  722|     27|    }
  723|      6|  }
  724|       |
  725|      8|  AutoArray<char> buf;
  726|      8|  try {
  727|      8|    buf.reset(new char[sizeof(T) * capacity]);
  728|      8|  } catch (const std::bad_alloc &) {
  729|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  730|      0|  }
  731|       |
  732|      8|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 7, False: 1]
  ------------------
  733|      7|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|      7|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|    134|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 127, False: 7]
  ------------------
  736|    127|      new(&dest[i]) T(src[i]);
  737|    127|      src[i].~T();
  738|    127|    }
  739|      7|  }
  740|       |
  741|      8|  buf_.swap(&buf);
  742|      8|  capacity_ = capacity;
  743|      8|}
_ZN5Darts7Details8AutoPoolIhE5clearEv:
  647|      6|  void clear() {
  648|      6|    resize(0);
  649|      6|    buf_.clear();
  650|      6|    size_ = 0;
  651|      6|    capacity_ = 0;
  652|      6|  }
_ZN5Darts7Details9AutoStackIjE3topEv:
  760|    282|  T &top() {
  761|    282|    return pool_[size() - 1];
  762|    282|  }
_ZNK5Darts7Details9AutoStackIjE4sizeEv:
  767|    282|  std::size_t size() const {
  768|    282|    return pool_.size();
  769|    282|  }
_ZN5Darts7Details9AutoStackIjE3popEv:
  774|    162|  void pop() {
  775|    162|    pool_.pop_back();
  776|    162|  }
_ZN5Darts7Details8AutoPoolIjE8pop_backEv:
  657|    162|  void pop_back() {
  658|    162|    (*this)[--size_].~T();
  659|    162|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgNodeEEixEm:
  633|    298|  const T &operator[](std::size_t id) const {
  634|    298|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|    298|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEE6appendEv:
  661|     99|  void append() {
  662|     99|    if (size_ == capacity_)
  ------------------
  |  Branch (662:9): [True: 8, False: 91]
  ------------------
  663|      8|      resize_buf(size_ + 1);
  664|     99|    new(&(*this)[size_++]) T;
  665|     99|  }
_ZN5Darts7Details8AutoPoolIhE6appendEv:
  661|     99|  void append() {
  662|     99|    if (size_ == capacity_)
  ------------------
  |  Branch (662:9): [True: 8, False: 91]
  ------------------
  663|      8|      resize_buf(size_ + 1);
  664|     99|    new(&(*this)[size_++]) T;
  665|     99|  }
_ZN5Darts7Details8AutoPoolIhE10resize_bufEm:
  714|     14|void AutoPool<T>::resize_buf(std::size_t size) {
  715|     14|  std::size_t capacity;
  716|     14|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 4, False: 10]
  ------------------
  717|      4|    capacity = size;
  718|     10|  } else {
  719|     10|    capacity = 1;
  720|     51|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 41, False: 10]
  ------------------
  721|     41|      capacity <<= 1;
  722|     41|    }
  723|     10|  }
  724|       |
  725|     14|  AutoArray<char> buf;
  726|     14|  try {
  727|     14|    buf.reset(new char[sizeof(T) * capacity]);
  728|     14|  } catch (const std::bad_alloc &) {
  729|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  730|      0|  }
  731|       |
  732|     14|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 12, False: 2]
  ------------------
  733|     12|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|     12|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|    170|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 158, False: 12]
  ------------------
  736|    158|      new(&dest[i]) T(src[i]);
  737|    158|      src[i].~T();
  738|    158|    }
  739|     12|  }
  740|       |
  741|     14|  buf_.swap(&buf);
  742|     14|  capacity_ = capacity;
  743|     14|}
_ZNK5Darts7Details9AutoStackIjE5emptyEv:
  764|     99|  bool empty() const {
  765|     99|    return pool_.empty();
  766|     99|  }
_ZNK5Darts7Details8AutoPoolINS0_8DawgNodeEE4sizeEv:
  643|     36|  std::size_t size() const {
  644|     36|    return size_;
  645|     36|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEE6appendEv:
  661|     36|  void append() {
  662|     36|    if (size_ == capacity_)
  ------------------
  |  Branch (662:9): [True: 7, False: 29]
  ------------------
  663|      7|      resize_buf(size_ + 1);
  664|     36|    new(&(*this)[size_++]) T;
  665|     36|  }
_ZNK5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE4sizeEv:
  643|    580|  std::size_t size() const {
  644|    580|    return size_;
  645|    580|  }
_ZNK5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEixEm:
  589|    249|  const T &operator[](std::size_t id) const {
  590|    249|    return array_[id];
  591|    249|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEixEm:
  592|  2.83k|  T &operator[](std::size_t id) {
  593|  2.83k|    return array_[id];
  594|  2.83k|  }
_ZNK5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEixEm:
  633|    256|  const T &operator[](std::size_t id) const {
  634|    256|    return *(reinterpret_cast<const T *>(&buf_[0]) + id);
  635|    256|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE5clearEv:
  647|      2|  void clear() {
  648|      2|    resize(0);
  649|      2|    buf_.clear();
  650|      2|    size_ = 0;
  651|      2|    capacity_ = 0;
  652|      2|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE5clearEv:
  600|      4|  void clear() {
  601|      4|    if (array_ != NULL) {
  ------------------
  |  Branch (601:9): [True: 1, False: 3]
  ------------------
  602|      1|      delete[] array_;
  603|       |      array_ = NULL;
  604|      1|    }
  605|      4|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE7reserveEm:
  695|      1|  void reserve(std::size_t size) {
  696|      1|    if (size > capacity_) {
  ------------------
  |  Branch (696:9): [True: 1, False: 0]
  ------------------
  697|      1|      resize_buf(size);
  698|      1|    }
  699|      1|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE10resize_bufEm:
  714|      2|void AutoPool<T>::resize_buf(std::size_t size) {
  715|      2|  std::size_t capacity;
  716|      2|  if (size >= capacity_ * 2) {
  ------------------
  |  Branch (716:7): [True: 2, False: 0]
  ------------------
  717|      2|    capacity = size;
  718|      2|  } else {
  719|      0|    capacity = 1;
  720|      0|    while (capacity < size) {
  ------------------
  |  Branch (720:12): [True: 0, False: 0]
  ------------------
  721|      0|      capacity <<= 1;
  722|      0|    }
  723|      0|  }
  724|       |
  725|      2|  AutoArray<char> buf;
  726|      2|  try {
  727|      2|    buf.reset(new char[sizeof(T) * capacity]);
  728|      2|  } catch (const std::bad_alloc &) {
  729|      0|    DARTS_THROW("failed to resize pool: std::bad_alloc");
  ------------------
  |  |   18|      0|#define DARTS_THROW(msg) throw Darts::Details::Exception( \
  |  |   19|       |  __FILE__ ":" DARTS_LINE_STR ": exception: " msg)
  ------------------
  730|      0|  }
  731|       |
  732|      2|  if (size_ > 0) {
  ------------------
  |  Branch (732:7): [True: 0, False: 2]
  ------------------
  733|      0|    T *src = reinterpret_cast<T *>(&buf_[0]);
  734|      0|    T *dest = reinterpret_cast<T *>(&buf[0]);
  735|      0|    for (std::size_t i = 0; i < size_; ++i) {
  ------------------
  |  Branch (735:29): [True: 0, False: 0]
  ------------------
  736|      0|      new(&dest[i]) T(src[i]);
  737|      0|      src[i].~T();
  738|      0|    }
  739|      0|  }
  740|       |
  741|      2|  buf_.swap(&buf);
  742|      2|  capacity_ = capacity;
  743|      2|}
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE5resetEPS2_:
  611|      1|  void reset(T *array = NULL) {
  612|      1|    AutoArray(array).swap(this);
  613|      1|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEE4swapEPS3_:
  606|      1|  void swap(AutoArray *array) {
  607|      1|    T *temp = array_;
  608|      1|    array_ = array->array_;
  609|      1|    array->array_ = temp;
  610|      1|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEixEm:
  636|    868|  T &operator[](std::size_t id) {
  637|    868|    return *(reinterpret_cast<T *>(&buf_[0]) + id);
  638|    868|  }
_ZN5Darts7Details8AutoPoolIhE6resizeEm:
  672|     66|  void resize(std::size_t size) {
  673|    263|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 197, False: 66]
  ------------------
  674|    197|      (*this)[--size_].~T();
  675|    197|    }
  676|     66|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 0, False: 66]
  ------------------
  677|      0|      resize_buf(size);
  678|      0|    }
  679|     66|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 0, False: 66]
  ------------------
  680|      0|      new(&(*this)[size_++]) T;
  681|      0|    }
  682|     66|  }
_ZN5Darts7Details8AutoPoolIhE6appendERKh:
  666|     98|  void append(const T &value) {
  667|     98|    if (size_ == capacity_)
  ------------------
  |  Branch (667:9): [True: 6, False: 92]
  ------------------
  668|      6|      resize_buf(size_ + 1);
  669|     98|    new(&(*this)[size_++]) T(value);
  670|     98|  }
_ZNK5Darts7Details8AutoPoolIhE4sizeEv:
  643|    267|  std::size_t size() const {
  644|    267|    return size_;
  645|    267|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEE6resizeEm:
  672|      3|  void resize(std::size_t size) {
  673|    259|    while (size_ > size) {
  ------------------
  |  Branch (673:12): [True: 256, False: 3]
  ------------------
  674|    256|      (*this)[--size_].~T();
  675|    256|    }
  676|      3|    if (size > capacity_) {
  ------------------
  |  Branch (676:9): [True: 1, False: 2]
  ------------------
  677|      1|      resize_buf(size);
  678|      1|    }
  679|    259|    while (size_ < size) {
  ------------------
  |  Branch (679:12): [True: 256, False: 3]
  ------------------
  680|    256|      new(&(*this)[size_++]) T;
  681|    256|    }
  682|      3|  }
_ZN5Darts15DoubleArrayImplIvvivE5clearEv:
  185|      1|  void clear() {
  186|      1|    size_ = 0;
  187|      1|    array_ = NULL;
  188|      1|    if (buf_ != NULL) {
  ------------------
  |  Branch (188:9): [True: 0, False: 1]
  ------------------
  189|      0|      delete[] buf_;
  190|       |      buf_ = NULL;
  191|      0|    }
  192|      1|  }
_ZN5Darts15DoubleArrayImplIvvivEC2Ev:
  138|      1|  DoubleArrayImpl() : size_(0), array_(NULL), buf_(NULL) {}
_ZNK5Darts15DoubleArrayImplIvvivE18commonPrefixSearchINS1_16result_pair_typeEEEmPKcPT_mmm:
  497|     39|    std::size_t length, std::size_t node_pos) const {
  498|     39|  std::size_t num_results = 0;
  499|       |
  500|     39|  unit_type unit = array_[node_pos];
  501|     39|  node_pos ^= unit.offset();
  502|     39|  if (length != 0) {
  ------------------
  |  Branch (502:7): [True: 39, False: 0]
  ------------------
  503|    132|    for (std::size_t i = 0; i < length; ++i) {
  ------------------
  |  Branch (503:29): [True: 93, False: 39]
  ------------------
  504|     93|      node_pos ^= static_cast<uchar_type>(key[i]);
  505|     93|      unit = array_[node_pos];
  506|     93|      if (unit.label() != static_cast<uchar_type>(key[i])) {
  ------------------
  |  Branch (506:11): [True: 0, False: 93]
  ------------------
  507|      0|        return num_results;
  508|      0|      }
  509|       |
  510|     93|      node_pos ^= unit.offset();
  511|     93|      if (unit.has_leaf()) {
  ------------------
  |  Branch (511:11): [True: 58, False: 35]
  ------------------
  512|     58|        if (num_results < max_num_results) {
  ------------------
  |  Branch (512:13): [True: 58, False: 0]
  ------------------
  513|     58|          set_result(&results[num_results], static_cast<value_type>(
  514|     58|              array_[node_pos].value()), i + 1);
  515|     58|        }
  516|     58|        ++num_results;
  517|     58|      }
  518|     93|    }
  519|     39|  } else {
  520|      0|    for ( ; key[length] != '\0'; ++length) {
  ------------------
  |  Branch (520:13): [True: 0, False: 0]
  ------------------
  521|      0|      node_pos ^= static_cast<uchar_type>(key[length]);
  522|      0|      unit = array_[node_pos];
  523|      0|      if (unit.label() != static_cast<uchar_type>(key[length])) {
  ------------------
  |  Branch (523:11): [True: 0, False: 0]
  ------------------
  524|      0|        return num_results;
  525|      0|      }
  526|       |
  527|      0|      node_pos ^= unit.offset();
  528|      0|      if (unit.has_leaf()) {
  ------------------
  |  Branch (528:11): [True: 0, False: 0]
  ------------------
  529|      0|        if (num_results < max_num_results) {
  ------------------
  |  Branch (529:13): [True: 0, False: 0]
  ------------------
  530|      0|          set_result(&results[num_results], static_cast<value_type>(
  531|      0|              array_[node_pos].value()), length + 1);
  532|      0|        }
  533|      0|        ++num_results;
  534|      0|      }
  535|      0|    }
  536|      0|  }
  537|       |
  538|     39|  return num_results;
  539|     39|}
_ZNK5Darts15DoubleArrayImplIvvivE10set_resultEPNS1_16result_pair_typeEim:
  159|     58|      value_type value, std::size_t length) const {
  160|     58|    result->value = value;
  161|     58|    result->length = length;
  162|     58|  }
_ZN5Darts15DoubleArrayImplIvvivE5buildEmPKPKcPKmPKiPFimmE:
 1922|      1|    const value_type *values, Details::progress_func_type progress_func) {
 1923|      1|  Details::Keyset<value_type> keyset(num_keys, keys, lengths, values);
 1924|       |
 1925|      1|  Details::DoubleArrayBuilder builder(progress_func);
 1926|      1|  builder.build(keyset);
 1927|       |
 1928|      1|  std::size_t size = 0;
 1929|      1|  unit_type *buf = NULL;
 1930|      1|  builder.copy(&size, &buf);
 1931|       |
 1932|      1|  clear();
 1933|       |
 1934|      1|  size_ = size;
 1935|      1|  array_ = buf;
 1936|      1|  buf_ = buf;
 1937|       |
 1938|      1|  if (progress_func != NULL) {
  ------------------
  |  Branch (1938:7): [True: 0, False: 1]
  ------------------
 1939|      0|    progress_func(num_keys + 1, num_keys + 1);
 1940|      0|  }
 1941|       |
 1942|      1|  return 0;
 1943|      1|}
_ZN5Darts7Details6KeysetIiEC2EmPKPKcPKmPKi:
  887|      1|      num_keys_(num_keys), keys_(keys), lengths_(lengths), values_(values) {}
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEEC2Ev:
  630|      1|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoArrayIcEC2EPc:
  584|    103|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEEC2EPS2_:
  584|      2|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details8AutoPoolIhEC2Ev:
  630|      2|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoArrayIjEC2EPj:
  584|      4|  explicit AutoArray(T *array = NULL) : array_(array) {}
_ZN5Darts7Details8AutoPoolIhED2Ev:
  631|      2|  ~AutoPool() { clear(); }
_ZN5Darts7Details9AutoArrayIcED2Ev:
  585|    103|  ~AutoArray() {
  586|    103|    clear();
  587|    103|  }
_ZN5Darts7Details9AutoArrayINS0_27DoubleArrayBuilderExtraUnitEED2Ev:
  585|      2|  ~AutoArray() {
  586|      2|    clear();
  587|      2|  }
_ZN5Darts7Details8AutoPoolINS0_22DoubleArrayBuilderUnitEED2Ev:
  631|      1|  ~AutoPool() { clear(); }
_ZN5Darts7Details18DoubleArrayBuilder5buildIiEEvRKNS0_6KeysetIT_EE:
 1546|      1|void DoubleArrayBuilder::build(const Keyset<T> &keyset) {
 1547|      1|  if (keyset.has_values()) {
  ------------------
  |  Branch (1547:7): [True: 1, False: 0]
  ------------------
 1548|      1|    Details::DawgBuilder dawg_builder;
 1549|      1|    build_dawg(keyset, &dawg_builder);
 1550|      1|    build_from_dawg(dawg_builder);
 1551|      1|    dawg_builder.clear();
 1552|      1|  } else {
 1553|      0|    build_from_keyset(keyset);
 1554|      0|  }
 1555|      1|}
_ZNK5Darts7Details6KeysetIiE10has_valuesEv:
  915|     40|  bool has_values() const {
  916|       |    return values_ != NULL;
  917|     40|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEEC2Ev:
  630|      1|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEEC2Ev:
  630|      1|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details8AutoPoolIjEC2Ev:
  630|      4|  AutoPool() : buf_(), size_(0), capacity_(0) {}
_ZN5Darts7Details9AutoStackIjEC2Ev:
  752|      2|  AutoStack() : pool_() {}
_ZN5Darts7Details9AutoStackIjED2Ev:
  753|      2|  ~AutoStack() {
  754|      2|    clear();
  755|      2|  }
_ZN5Darts7Details8AutoPoolIjED2Ev:
  631|      4|  ~AutoPool() { clear(); }
_ZN5Darts7Details9AutoArrayIjED2Ev:
  585|      4|  ~AutoArray() {
  586|      4|    clear();
  587|      4|  }
_ZN5Darts7Details8AutoPoolINS0_8DawgUnitEED2Ev:
  631|      1|  ~AutoPool() { clear(); }
_ZN5Darts7Details8AutoPoolINS0_8DawgNodeEED2Ev:
  631|      1|  ~AutoPool() { clear(); }
_ZN5Darts7Details18DoubleArrayBuilder10build_dawgIiEEvRKNS0_6KeysetIT_EEPNS0_11DawgBuilderE:
 1581|      1|    DawgBuilder *dawg_builder) {
 1582|      1|  dawg_builder->init();
 1583|     40|  for (std::size_t i = 0; i < keyset.num_keys(); ++i) {
  ------------------
  |  Branch (1583:27): [True: 39, False: 1]
  ------------------
 1584|     39|    dawg_builder->insert(keyset.keys(i), keyset.lengths(i), keyset.values(i));
 1585|     39|    if (progress_func_ != NULL) {
  ------------------
  |  Branch (1585:9): [True: 0, False: 39]
  ------------------
 1586|      0|      progress_func_(i + 1, keyset.num_keys() + 1);
 1587|      0|    }
 1588|     39|  }
 1589|      1|  dawg_builder->finish();
 1590|      1|}
_ZNK5Darts7Details6KeysetIiE8num_keysEv:
  889|     40|  std::size_t num_keys() const {
  890|     40|    return num_keys_;
  891|     40|  }
_ZNK5Darts7Details6KeysetIiE4keysEm:
  892|     39|  const char_type *keys(std::size_t id) const {
  893|     39|    return keys_[id];
  894|     39|  }
_ZNK5Darts7Details6KeysetIiE7lengthsEm:
  904|     39|  std::size_t lengths(std::size_t id) const {
  905|     39|    if (has_lengths()) {
  ------------------
  |  Branch (905:9): [True: 39, False: 0]
  ------------------
  906|     39|      return lengths_[id];
  907|     39|    }
  908|      0|    std::size_t length = 0;
  909|      0|    while (keys_[id][length] != '\0') {
  ------------------
  |  Branch (909:12): [True: 0, False: 0]
  ------------------
  910|      0|      ++length;
  911|      0|    }
  912|      0|    return length;
  913|     39|  }
_ZNK5Darts7Details6KeysetIiE11has_lengthsEv:
  901|     39|  bool has_lengths() const {
  902|       |    return lengths_ != NULL;
  903|     39|  }
_ZNK5Darts7Details6KeysetIiE6valuesEm:
  918|     39|  const value_type values(std::size_t id) const {
  919|     39|    if (has_values()) {
  ------------------
  |  Branch (919:9): [True: 39, False: 0]
  ------------------
  920|     39|      return static_cast<value_type>(values_[id]);
  921|     39|    }
  922|      0|    return static_cast<value_type>(id);
  923|     39|  }

_ZN6google8protobuf8internal14ArenaStringPtr7MutableENS2_12EmptyDefaultEPNS0_5ArenaE:
  112|    298|std::string* ArenaStringPtr::Mutable(EmptyDefault, ::google::protobuf::Arena* arena) {
  113|    298|  if (!IsDonatedString() && !IsDefault(&GetEmptyStringAlreadyInited())) {
  ------------------
  |  Branch (113:7): [True: 298, False: 0]
  |  Branch (113:29): [True: 0, False: 298]
  ------------------
  114|      0|    return UnsafeMutablePointer();
  115|    298|  } else {
  116|    298|    return MutableSlow(arena);
  117|    298|  }
  118|    298|}
_ZN6google8protobuf8internal14ArenaStringPtr11MutableSlowIJEEEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPNS0_5ArenaEDpRKT_:
  144|    298|                                         const Lazy&... lazy_default) {
  145|    298|  const std::string* const default_value =
  146|    298|      sizeof...(Lazy) == 0 ? &GetEmptyStringAlreadyInited() : nullptr;
  ------------------
  |  Branch (146:7): [True: 298, Folded]
  ------------------
  147|    298|  GOOGLE_DCHECK(IsDefault(default_value));
  ------------------
  |  |  181|    298|#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: 298]
  |  |  ------------------
  ------------------
  148|    298|  std::string* new_string =
  149|    298|      Arena::Create<std::string>(arena, lazy_default.get()...);
  150|    298|  tagged_ptr_.Set(new_string);
  151|    298|  return new_string;
  152|    298|}

_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|    306|    : arena_(arena),
  189|    306|      flat_capacity_(0),
  190|    306|      flat_size_(0),
  191|    306|      map_{flat_capacity_ == 0
  ------------------
  |  Branch (191:12): [True: 306, False: 0]
  ------------------
  192|    306|               ? NULL
  193|    306|               : Arena::CreateArray<KeyValue>(arena_, flat_capacity_)} {}
_ZN6google8protobuf8internal12ExtensionSet5ClearEv:
  877|      1|void ExtensionSet::Clear() {
  878|      1|  ForEach([](int /* number */, Extension& ext) { ext.Clear(); });
  879|      1|}
_ZNK6google8protobuf8internal12ExtensionSet13IsInitializedEv:
 1127|    301|bool ExtensionSet::IsInitialized() const {
 1128|       |  // Extensions are never required.  However, we need to check that all
 1129|       |  // embedded messages are initialized.
 1130|    301|  if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|    301|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 301]
  |  |  ------------------
  ------------------
 1131|      0|    for (const auto& kv : *map_.large) {
  ------------------
  |  Branch (1131:25): [True: 0, False: 0]
  ------------------
 1132|      0|      if (!kv.second.IsInitialized()) return false;
  ------------------
  |  Branch (1132:11): [True: 0, False: 0]
  ------------------
 1133|      0|    }
 1134|      0|    return true;
 1135|      0|  }
 1136|    301|  for (const KeyValue* it = flat_begin(); it != flat_end(); ++it) {
  ------------------
  |  Branch (1136:43): [True: 0, False: 301]
  ------------------
 1137|      0|    if (!it->second.IsInitialized()) return false;
  ------------------
  |  Branch (1137:9): [True: 0, False: 0]
  ------------------
 1138|      0|  }
 1139|    301|  return true;
 1140|    301|}

_ZN6google8protobuf8internal24InitProtobufDefaultsSlowEv:
   89|      1|void InitProtobufDefaultsSlow() {
   90|      1|  static bool is_inited = InitProtobufDefaultsImpl();
   91|      1|  (void)is_inited;
   92|      1|}
_ZN6google8protobuf8internal11InitSCCImplEPNS1_11SCCInfoBaseE:
  764|      7|void InitSCCImpl(SCCInfoBase* scc) {
  765|      7|  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|      7|#ifndef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
  769|      7|  static std::atomic<std::thread::id> runner;
  770|      7|  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|      7|  if (runner.load(std::memory_order_relaxed) == me) {
  ------------------
  |  Branch (781:7): [True: 6, False: 1]
  ------------------
  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|      1|  InitProtobufDefaults();
  789|      1|  mu.Lock();
  790|      1|  runner.store(me, std::memory_order_relaxed);
  791|      1|  InitSCC_DFS(scc);
  792|       |
  793|      1|#ifndef GOOGLE_PROTOBUF_SUPPORT_WINDOWS_XP
  794|      1|  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|      1|  mu.Unlock();
  800|      1|}
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|      6|void InitSCC_DFS(SCCInfoBase* scc) {
  737|      6|  if (scc->visit_status.load(std::memory_order_relaxed) !=
  ------------------
  |  Branch (737:7): [True: 0, False: 6]
  ------------------
  738|      6|      SCCInfoBase::kUninitialized)
  739|      0|    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|    298|  PROTOBUF_ALWAYS_INLINE static T* Create(Arena* arena, Args&&... args) {
  293|    298|    return CreateNoMessage<T>(arena, is_arena_constructable<T>(),
  294|    298|                              std::forward<Args>(args)...);
  295|    298|  }
_ZN6google8protobuf5Arena15CreateNoMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  547|    298|                                                   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|    298|    return CreateMaybeMessage<T>(arena, std::forward<Args>(args)...);
  552|    298|  }
_ZN6google8protobuf5Arena18CreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_:
  530|    298|                                                      Args&&... args) {
  531|    298|    return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(),
  532|    298|                                   std::forward<Args>(args)...);
  533|    298|  }
_ZN6google8protobuf5Arena20DoCreateMaybeMessageINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_NS3_17integral_constantIbLb0EEEDpOT0_:
  524|    298|                                                        Args&&... args) {
  525|    298|    return CreateInternal<T>(arena, std::forward<Args>(args)...);
  526|    298|  }
_ZN6google8protobuf5Arena14CreateInternalINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEPT_PS1_DpOT0_:
  472|    298|                                                  Args&&... args) {
  473|    298|    if (arena == NULL) {
  ------------------
  |  Branch (473:9): [True: 298, False: 0]
  ------------------
  474|    298|      return new T(std::forward<Args>(args)...);
  475|    298|    } else {
  476|      0|      return arena->DoCreate<T>(std::is_trivially_destructible<T>::value,
  477|      0|                                std::forward<Args>(args)...);
  478|      0|    }
  479|    298|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece11TrainerSpecEEEPT_PS1_:
  459|      1|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|      1|    static_assert(
  461|      1|        InternalHelper<T>::is_arena_constructable::value,
  462|      1|        "CreateMessage can only construct types that are ArenaConstructable");
  463|      1|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 1, False: 0]
  ------------------
  464|      1|      return new T();
  465|      1|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|      1|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece14NormalizerSpecEEEPT_PS1_:
  459|      1|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|      1|    static_assert(
  461|      1|        InternalHelper<T>::is_arena_constructable::value,
  462|      1|        "CreateMessage can only construct types that are ArenaConstructable");
  463|      1|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 1, False: 0]
  ------------------
  464|      1|      return new T();
  465|      1|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|      1|  }
_ZN6google8protobuf5Arena21CreateMessageInternalIN13sentencepiece24ModelProto_SentencePieceEEEPT_PS1_:
  459|    298|  PROTOBUF_ALWAYS_INLINE static T* CreateMessageInternal(Arena* arena) {
  460|    298|    static_assert(
  461|    298|        InternalHelper<T>::is_arena_constructable::value,
  462|    298|        "CreateMessage can only construct types that are ArenaConstructable");
  463|    298|    if (arena == NULL) {
  ------------------
  |  Branch (463:9): [True: 298, False: 0]
  ------------------
  464|    298|      return new T();
  465|    298|    } else {
  466|      0|      return arena->DoCreateMessage<T>();
  467|      0|    }
  468|    298|  }

_ZNK6google8protobuf8internal14ArenaStringPtr3GetEv:
  194|  1.15k|  const std::string& Get() const PROTOBUF_ALWAYS_INLINE {
  195|       |    // Unconditionally mask away the tag.
  196|  1.15k|    return *tagged_ptr_.Get();
  197|  1.15k|  }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3GetEv:
   99|  1.15k|  T* Get() const { return reinterpret_cast<T*>(as_int() & -2); }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE6as_intEv:
  109|  1.15k|  uintptr_t as_int() const { return reinterpret_cast<uintptr_t>(ptr_); }
_ZNK6google8protobuf8internal14ArenaStringPtr9IsDefaultEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  279|    298|  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|    298|    return tagged_ptr_.UnsafeGet() == default_value;
  285|    298|  }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE9UnsafeGetEv:
  104|    298|  T* UnsafeGet() const { return static_cast<T*>(ptr_); }
_ZNK6google8protobuf8internal14ArenaStringPtr15IsDonatedStringEv:
  290|    298|  bool IsDonatedString() const { return false; }
_ZN6google8protobuf8internal14ArenaStringPtr16UnsafeSetDefaultEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  301|    327|inline void ArenaStringPtr::UnsafeSetDefault(const std::string* value) {
  302|    327|  tagged_ptr_.Set(const_cast<std::string*>(value));
  303|    327|}
_ZN6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3SetEPS9_:
   98|    625|  void Set(T* p) { ptr_ = p; }

_ZNK6google8protobuf8internal12ExtensionSet8is_largeEv:
  667|    302|  bool is_large() const { return flat_capacity_ > kMaximumFlatCapacity; }
_ZN6google8protobuf8internal12ExtensionSet10flat_beginEv:
  816|      1|  KeyValue* flat_begin() {
  817|       |    assert(!is_large());
  818|      1|    return map_.flat;
  819|      1|  }
_ZNK6google8protobuf8internal12ExtensionSet10flat_beginEv:
  820|    301|  const KeyValue* flat_begin() const {
  821|       |    assert(!is_large());
  822|    301|    return map_.flat;
  823|    301|  }
_ZN6google8protobuf8internal12ExtensionSet8flat_endEv:
  824|      1|  KeyValue* flat_end() {
  825|       |    assert(!is_large());
  826|      1|    return map_.flat + flat_size_;
  827|      1|  }
_ZNK6google8protobuf8internal12ExtensionSet8flat_endEv:
  828|    301|  const KeyValue* flat_end() const {
  829|       |    assert(!is_large());
  830|    301|    return map_.flat + flat_size_;
  831|    301|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIZNS2_5ClearEvE3$_0EET_S5_:
  688|      1|  KeyValueFunctor ForEach(KeyValueFunctor func) {
  689|      1|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  690|      0|      return ForEach(map_.large->begin(), map_.large->end(), std::move(func));
  691|      0|    }
  692|      1|    return ForEach(flat_begin(), flat_end(), std::move(func));
  693|      1|  }
extension_set.cc:_ZN6google8protobuf8internal12ExtensionSet7ForEachIPNS2_8KeyValueEZNS2_5ClearEvE3$_0EET0_T_S8_S7_:
  681|      1|                                 KeyValueFunctor func) {
  682|      1|    for (Iterator it = begin; it != end; ++it) func(it->first, it->second);
  ------------------
  |  Branch (682:31): [True: 0, False: 1]
  ------------------
  683|      1|    return std::move(func);
  684|      1|  }

_ZN6google8protobuf8internal20InitProtobufDefaultsEv:
   93|      1|PROTOBUF_EXPORT inline void InitProtobufDefaults() {
   94|      1|  if (PROTOBUF_PREDICT_FALSE(
  ------------------
  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 1, False: 0]
  |  |  ------------------
  ------------------
   95|      1|          !init_protobuf_defaults_state.load(std::memory_order_acquire))) {
   96|      1|    InitProtobufDefaultsSlow();
   97|      1|  }
   98|      1|}
_ZN6google8protobuf8internal7InitSCCEPNS1_11SCCInfoBaseE:
  247|    307|inline void InitSCC(SCCInfoBase* scc) {
  248|    307|  auto status = scc->visit_status.load(std::memory_order_acquire);
  249|    307|  if (PROTOBUF_PREDICT_FALSE(status != SCCInfoBase::kInitialized))
  ------------------
  |  |  247|    307|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 7, False: 300]
  |  |  ------------------
  ------------------
  250|      7|    InitSCCImpl(scc);
  251|    307|}
_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|}
_ZN6google8protobuf8internal17AllAreInitializedIN13sentencepiece24ModelProto_SentencePieceEEEbRKNS0_16RepeatedPtrFieldIT_EE:
  113|      1|bool AllAreInitialized(const RepeatedPtrField<Msg>& t) {
  114|    299|  for (int i = t.size(); --i >= 0;) {
  ------------------
  |  Branch (114:26): [True: 298, False: 1]
  ------------------
  115|    298|    if (!t.Get(i).IsInitialized()) return false;
  ------------------
  |  Branch (115:9): [True: 0, False: 298]
  ------------------
  116|    298|  }
  117|      1|  return true;
  118|      1|}

_ZNK6google8protobuf8internal7HasBitsILm1EEixEi:
   60|    305|  const uint32& operator[](int index) const PROTOBUF_ALWAYS_INLINE {
   61|    305|    return has_bits_[index];
   62|    305|  }
_ZN6google8protobuf8internal7HasBitsILm1EEixEi:
   56|    861|  uint32& operator[](int index) PROTOBUF_ALWAYS_INLINE {
   57|    861|    return has_bits_[index];
   58|    861|  }
_ZN6google8protobuf8internal7HasBitsILm2EEixEi:
   56|      3|  uint32& operator[](int index) PROTOBUF_ALWAYS_INLINE {
   57|      3|    return has_bits_[index];
   58|      3|  }
_ZN6google8protobuf8internal7HasBitsILm1EEC2Ev:
   50|    604|  constexpr HasBits() PROTOBUF_ALWAYS_INLINE : has_bits_{} {}
_ZN6google8protobuf8internal7HasBitsILm1EE5ClearEv:
   52|      1|  void Clear() PROTOBUF_ALWAYS_INLINE {
   53|      1|    memset(has_bits_, 0, sizeof(has_bits_));
   54|      1|  }
_ZN6google8protobuf8internal7HasBitsILm1EE2OrERKS3_:
   72|    300|  void Or(const HasBits<doublewords>& rhs) {
   73|    600|    for (size_t i = 0; i < doublewords; i++) has_bits_[i] |= rhs[i];
  ------------------
  |  Branch (73:24): [True: 300, False: 300]
  ------------------
   74|    300|  }
_ZN6google8protobuf8internal7HasBitsILm2EEC2Ev:
   50|      2|  constexpr HasBits() PROTOBUF_ALWAYS_INLINE : has_bits_{} {}

_ZN6google8protobuf2io16CodedInputStream24GetDefaultRecursionLimitEv:
  415|      1|  static int GetDefaultRecursionLimit() { return default_recursion_limit_; }

_ZNK6google8protobuf11MessageLite8GetArenaEv:
  230|    300|  Arena* GetArena() const { return _internal_metadata_.arena(); }
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN13sentencepiece14NormalizerSpecEEEPT_PNS0_5ArenaE:
  479|      1|  static T* CreateMaybeMessage(Arena* arena) {
  480|      1|    return Arena::CreateMaybeMessage<T>(arena);
  481|      1|  }
_ZN6google8protobuf11MessageLiteC2EPNS0_5ArenaE:
  483|    307|  inline explicit MessageLite(Arena* arena) : _internal_metadata_(arena) {}
_ZNK6google8protobuf11MessageLite23IsInitializedWithErrorsEv:
  508|      1|  bool IsInitializedWithErrors() const {
  509|      1|    if (IsInitialized()) return true;
  ------------------
  |  Branch (509:9): [True: 1, False: 0]
  ------------------
  510|      0|    LogInitializationErrorMessage();
  511|      0|    return false;
  512|      1|  }
_ZN6google8protobuf8internal27GetEmptyStringAlreadyInitedEv:
  173|    913|PROTOBUF_EXPORT constexpr const std::string& GetEmptyStringAlreadyInited() {
  174|    913|  return fixed_address_empty_string.value;
  175|    913|}
_ZN6google8protobuf11MessageLite18CreateMaybeMessageIN13sentencepiece11TrainerSpecEEEPT_PNS0_5ArenaE:
  479|      1|  static T* CreateMaybeMessage(Arena* arena) {
  480|      1|    return Arena::CreateMaybeMessage<T>(arena);
  481|      1|  }
_ZN6google8protobuf11MessageLite9ParseFromILNS1_10ParseFlagsE1ENS0_11StringPieceEEEbRKT0_:
  576|      1|bool MessageLite::ParseFrom(const T& input) {
  577|      1|  if (flags & kParse) Clear();
  ------------------
  |  Branch (577:7): [True: 1, Folded]
  ------------------
  578|      1|  constexpr bool alias = (flags & kMergeWithAliasing) != 0;
  579|      1|  return internal::MergeFromImpl<alias>(input, this, flags);
  580|      1|}

_ZNK6google8protobuf8internal16InternalMetadata5arenaEv:
   72|    300|  PROTOBUF_ALWAYS_INLINE Arena* arena() const {
   73|    300|    if (PROTOBUF_PREDICT_FALSE(have_unknown_fields())) {
  ------------------
  |  |  247|    300|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 300]
  |  |  ------------------
  ------------------
   74|      0|      return PtrValue<ContainerBase>()->arena;
   75|    300|    } else {
   76|    300|      return PtrValue<Arena>();
   77|    300|    }
   78|    300|  }
_ZNK6google8protobuf8internal16InternalMetadata19have_unknown_fieldsEv:
   80|    301|  PROTOBUF_ALWAYS_INLINE bool have_unknown_fields() const {
   81|    301|    return PtrTag() == kTagContainer;
   82|    301|  }
_ZNK6google8protobuf8internal16InternalMetadata6PtrTagEv:
  146|    301|  PROTOBUF_ALWAYS_INLINE int PtrTag() const {
  147|    301|    return reinterpret_cast<intptr_t>(ptr_) & kPtrTagMask;
  148|    301|  }
_ZNK6google8protobuf8internal16InternalMetadata8PtrValueINS0_5ArenaEEEPT_v:
  151|    300|  U* PtrValue() const {
  152|    300|    return reinterpret_cast<U*>(reinterpret_cast<intptr_t>(ptr_) &
  153|    300|                                kPtrValueMask);
  154|    300|  }
_ZN6google8protobuf8internal16InternalMetadataC2EPNS0_5ArenaE:
   62|    307|  explicit InternalMetadata(Arena* arena) : ptr_(arena) {}
_ZN6google8protobuf8internal16InternalMetadata5ClearINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvv:
  126|      1|  PROTOBUF_ALWAYS_INLINE void Clear() {
  127|      1|    if (have_unknown_fields()) {
  ------------------
  |  Branch (127:9): [True: 0, False: 1]
  ------------------
  128|      0|      DoClear<T>();
  129|      0|    }
  130|      1|  }

_ZN6google8protobuf8internal18EpsCopyInputStreamC2Eb:
  113|      1|      : aliasing_(enable_aliasing ? kOnPatch : kNoAliasing) {}
  ------------------
  |  Branch (113:19): [True: 0, False: 1]
  ------------------
_ZN6google8protobuf8internal18EpsCopyInputStream9PushLimitEPKci:
  127|    300|  PROTOBUF_MUST_USE_RESULT int PushLimit(const char* ptr, int limit) {
  128|    300|    GOOGLE_DCHECK(limit >= 0 && limit <= INT_MAX - kSlopBytes);
  ------------------
  |  |  181|    300|#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: 300]
  |  |  ------------------
  ------------------
  129|       |    // This add is safe due to the invariant above, because
  130|       |    // ptr - buffer_end_ <= kSlopBytes.
  131|    300|    limit += static_cast<int>(ptr - buffer_end_);
  132|    300|    limit_end_ = buffer_end_ + (std::min)(0, limit);
  133|    300|    auto old_limit = limit_;
  134|    300|    limit_ = limit;
  135|    300|    return old_limit - limit;
  136|    300|  }
_ZN6google8protobuf8internal18EpsCopyInputStream8PopLimitEi:
  138|    300|  PROTOBUF_MUST_USE_RESULT bool PopLimit(int delta) {
  139|    300|    if (PROTOBUF_PREDICT_FALSE(!EndedAtLimit())) return false;
  ------------------
  |  |  247|    300|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 300]
  |  |  ------------------
  ------------------
  140|    300|    limit_ = limit_ + delta;
  141|       |    // TODO(gerbens) We could remove this line and hoist the code to
  142|       |    // DoneFallback. Study the perf/bin-size effects.
  143|    300|    limit_end_ = buffer_end_ + (std::min)(0, limit_);
  144|    300|    return true;
  145|    300|  }
_ZN6google8protobuf8internal18EpsCopyInputStream10ReadStringEPKciPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
  154|    298|                                                  std::string* s) {
  155|    298|    if (size <= buffer_end_ + kSlopBytes - ptr) {
  ------------------
  |  Branch (155:9): [True: 298, False: 0]
  ------------------
  156|    298|      s->assign(ptr, size);
  157|    298|      return ptr + size;
  158|    298|    }
  159|      0|    return ReadStringFallback(ptr, size, s);
  160|    298|  }
_ZNK6google8protobuf8internal18EpsCopyInputStream12EndedAtLimitEv:
  189|    301|  bool EndedAtLimit() const { return last_tag_minus_1_ == 0; }
_ZN6google8protobuf8internal18EpsCopyInputStream13DataAvailableEPKc:
  202|    298|  bool DataAvailable(const char* ptr) { return ptr < limit_end_; }
_ZN6google8protobuf8internal18EpsCopyInputStream13DoneWithCheckEPPKci:
  208|  1.16k|  bool DoneWithCheck(const char** ptr, int d) {
  209|  1.16k|    GOOGLE_DCHECK(*ptr);
  ------------------
  |  |  181|  1.16k|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1.16k]
  |  |  ------------------
  ------------------
  210|  1.16k|    if (PROTOBUF_PREDICT_TRUE(*ptr < limit_end_)) return false;
  ------------------
  |  |  236|  1.16k|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 863, False: 302]
  |  |  ------------------
  ------------------
  211|    302|    int overrun = *ptr - buffer_end_;
  212|    302|    GOOGLE_DCHECK_LE(overrun, kSlopBytes);  // Guaranteed by parse loop.
  ------------------
  |  |  186|    302|#define GOOGLE_DCHECK_LE(A, B) GOOGLE_DCHECK((A) <= (B))
  |  |  ------------------
  |  |  |  |  181|    302|#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: 302]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
  213|    302|    if (overrun ==
  ------------------
  |  Branch (213:9): [True: 301, False: 1]
  ------------------
  214|    302|        limit_) {  //  No need to flip buffers if we ended on a limit.
  215|       |      // If we actually overrun the buffer and next_chunk_ is null. It means
  216|       |      // the stream ended and we passed the stream end.
  217|    301|      if (overrun > 0 && next_chunk_ == nullptr) *ptr = nullptr;
  ------------------
  |  Branch (217:11): [True: 0, False: 301]
  |  Branch (217:26): [True: 0, False: 0]
  ------------------
  218|    301|      return true;
  219|    301|    }
  220|      1|    auto res = DoneFallback(overrun, d);
  221|      1|    *ptr = res.first;
  222|      1|    return res.second;
  223|    302|  }
_ZN6google8protobuf8internal18EpsCopyInputStream8InitFromENS0_11StringPieceE:
  225|      1|  const char* InitFrom(StringPiece flat) {
  226|      1|    overall_limit_ = 0;
  227|      1|    if (flat.size() > kSlopBytes) {
  ------------------
  |  Branch (227:9): [True: 1, False: 0]
  ------------------
  228|      1|      limit_ = kSlopBytes;
  229|      1|      limit_end_ = buffer_end_ = flat.data() + flat.size() - kSlopBytes;
  230|      1|      next_chunk_ = buffer_;
  231|      1|      if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
  ------------------
  |  Branch (231:11): [True: 0, False: 1]
  ------------------
  232|      1|      return flat.data();
  233|      1|    } else {
  234|      0|      std::memcpy(buffer_, flat.data(), flat.size());
  235|      0|      limit_ = 0;
  236|      0|      limit_end_ = buffer_end_ = buffer_ + flat.size();
  237|      0|      next_chunk_ = nullptr;
  238|      0|      if (aliasing_ == kOnPatch) {
  ------------------
  |  Branch (238:11): [True: 0, False: 0]
  ------------------
  239|      0|        aliasing_ = reinterpret_cast<std::uintptr_t>(flat.data()) -
  240|      0|                    reinterpret_cast<std::uintptr_t>(buffer_);
  241|      0|      }
  242|      0|      return buffer_;
  243|      0|    }
  244|      1|  }
_ZN6google8protobuf8internal12ParseContext4DoneEPPKc:
  390|  1.16k|  bool Done(const char** ptr) { return DoneWithCheck(ptr, group_depth_); }
_ZN6google8protobuf8internal12EndianHelperILi4EE4LoadEPKv:
  461|    298|  static uint32 Load(const void* p) {
  462|    298|    uint32 tmp;
  463|    298|    std::memcpy(&tmp, p, 4);
  464|       |#ifndef PROTOBUF_LITTLE_ENDIAN
  465|       |    tmp = bswap_32(tmp);
  466|       |#endif
  467|    298|    return tmp;
  468|    298|  }
_ZN6google8protobuf8internal7ReadTagEPKcPjj:
  532|    864|inline const char* ReadTag(const char* p, uint32* out, uint32 /*max_tag*/ = 0) {
  533|    864|  uint32 res = static_cast<uint8>(p[0]);
  534|    864|  if (res < 128) {
  ------------------
  |  Branch (534:7): [True: 863, False: 1]
  ------------------
  535|    863|    *out = res;
  536|    863|    return p + 1;
  537|    863|  }
  538|      1|  uint32 second = static_cast<uint8>(p[1]);
  539|      1|  res += (second - 1) << 7;
  540|      1|  if (second < 128) {
  ------------------
  |  Branch (540:7): [True: 1, False: 0]
  ------------------
  541|      1|    *out = res;
  542|      1|    return p + 2;
  543|      1|  }
  544|      0|  auto tmp = ReadTagFallback(p, res);
  545|      0|  *out = tmp.second;
  546|      0|  return tmp.first;
  547|      1|}
_ZN6google8protobuf8internal8ReadSizeEPPKc:
  599|    598|inline uint32 ReadSize(const char** pp) {
  600|    598|  auto p = *pp;
  601|    598|  uint32 res = static_cast<uint8>(p[0]);
  602|    598|  if (res < 128) {
  ------------------
  |  Branch (602:7): [True: 598, False: 0]
  ------------------
  603|    598|    *pp = p + 1;
  604|    598|    return res;
  605|    598|  }
  606|      0|  auto x = ReadSizeFallback(p, res);
  607|      0|  *pp = x.first;
  608|      0|  return x.second;
  609|    598|}
_ZN6google8protobuf8internal12ReadVarint64EPPKc:
  616|    265|inline uint64 ReadVarint64(const char** p) {
  617|    265|  uint64 tmp;
  618|    265|  *p = VarintParse(*p, &tmp);
  619|    265|  return tmp;
  620|    265|}
_ZN6google8protobuf8internal11VarintParseImEEPKcS4_PT_:
  509|    265|PROTOBUF_MUST_USE_RESULT const char* VarintParse(const char* p, T* out) {
  510|    265|  auto ptr = reinterpret_cast<const uint8*>(p);
  511|    265|  uint32 res = ptr[0];
  512|    265|  if (!(res & 0x80)) {
  ------------------
  |  Branch (512:7): [True: 265, False: 0]
  ------------------
  513|    265|    *out = res;
  514|    265|    return p + 1;
  515|    265|  }
  516|      0|  uint32 byte = ptr[1];
  517|      0|  res += (byte - 1) << 7;
  518|      0|  if (!(byte & 0x80)) {
  ------------------
  |  Branch (518:7): [True: 0, False: 0]
  ------------------
  519|      0|    *out = res;
  520|      0|    return p + 2;
  521|      0|  }
  522|      0|  return VarintParseSlow(p, res, out);
  523|      0|}
_ZN6google8protobuf8internal13UnalignedLoadIfEET_PKc:
  484|    298|T UnalignedLoad(const char* p) {
  485|    298|  auto tmp = EndianHelper<sizeof(T)>::Load(p);
  486|    298|  T res;
  487|    298|  memcpy(&res, &tmp, sizeof(T));
  488|    298|  return res;
  489|    298|}
_ZN6google8protobuf8internal12ParseContextC2IJRNS0_11StringPieceEEEEibPPKcDpOT_:
  384|      1|      : EpsCopyInputStream(aliasing), depth_(depth) {
  385|      1|    *start = InitFrom(std::forward<T>(args)...);
  386|      1|  }
_ZN6google8protobuf8internal9ExpectTagILj10EEEbPKc:
  429|    298|bool ExpectTag(const char* ptr) {
  430|    298|  if (tag < 128) {
  ------------------
  |  Branch (430:7): [True: 298, Folded]
  ------------------
  431|    298|    return *ptr == tag;
  432|    298|  } else {
  433|      0|    static_assert(tag < 128 * 128, "We only expect tags for 1 or 2 bytes");
  434|      0|    char buf[2] = {static_cast<char>(tag | 0x80), static_cast<char>(tag >> 7)};
  435|      0|    return std::memcmp(ptr, buf, 2) == 0;
  436|      0|  }
  437|    298|}
_ZN6google8protobuf8internal12ParseContext12ParseMessageIN13sentencepiece24ModelProto_SentencePieceEEEPKcPT_S7_:
  642|    298|    T* msg, const char* ptr) {
  643|    298|  int size = ReadSize(&ptr);
  644|    298|  if (!ptr) return nullptr;
  ------------------
  |  Branch (644:7): [True: 0, False: 298]
  ------------------
  645|    298|  auto old = PushLimit(ptr, size);
  646|    298|  if (--depth_ < 0) return nullptr;
  ------------------
  |  Branch (646:7): [True: 0, False: 298]
  ------------------
  647|    298|  ptr = msg->_InternalParse(ptr, this);
  648|    298|  if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) return nullptr;
  ------------------
  |  |  247|    298|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 298]
  |  |  ------------------
  ------------------
  649|    298|  depth_++;
  650|    298|  if (!PopLimit(old)) return nullptr;
  ------------------
  |  Branch (650:7): [True: 0, False: 298]
  ------------------
  651|    298|  return ptr;
  652|    298|}
_ZN6google8protobuf8internal12ParseContext12ParseMessageIN13sentencepiece11TrainerSpecEEEPKcPT_S7_:
  642|      1|    T* msg, const char* ptr) {
  643|      1|  int size = ReadSize(&ptr);
  644|      1|  if (!ptr) return nullptr;
  ------------------
  |  Branch (644:7): [True: 0, False: 1]
  ------------------
  645|      1|  auto old = PushLimit(ptr, size);
  646|      1|  if (--depth_ < 0) return nullptr;
  ------------------
  |  Branch (646:7): [True: 0, False: 1]
  ------------------
  647|      1|  ptr = msg->_InternalParse(ptr, this);
  648|      1|  if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) return nullptr;
  ------------------
  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  649|      1|  depth_++;
  650|      1|  if (!PopLimit(old)) return nullptr;
  ------------------
  |  Branch (650:7): [True: 0, False: 1]
  ------------------
  651|      1|  return ptr;
  652|      1|}
_ZN6google8protobuf8internal12ParseContext12ParseMessageIN13sentencepiece14NormalizerSpecEEEPKcPT_S7_:
  642|      1|    T* msg, const char* ptr) {
  643|      1|  int size = ReadSize(&ptr);
  644|      1|  if (!ptr) return nullptr;
  ------------------
  |  Branch (644:7): [True: 0, False: 1]
  ------------------
  645|      1|  auto old = PushLimit(ptr, size);
  646|      1|  if (--depth_ < 0) return nullptr;
  ------------------
  |  Branch (646:7): [True: 0, False: 1]
  ------------------
  647|      1|  ptr = msg->_InternalParse(ptr, this);
  648|      1|  if (PROTOBUF_PREDICT_FALSE(ptr == nullptr)) return nullptr;
  ------------------
  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  649|      1|  depth_++;
  650|      1|  if (!PopLimit(old)) return nullptr;
  ------------------
  |  Branch (650:7): [True: 0, False: 1]
  ------------------
  651|      1|  return ptr;
  652|      1|}

_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE4sizeEv:
 2167|      1|inline int RepeatedPtrField<Element>::size() const {
 2168|      1|  return RepeatedPtrFieldBase::size();
 2169|      1|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv:
 1700|    601|inline int RepeatedPtrFieldBase::size() const { return current_size_; }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE4sizeEv:
 2167|    600|inline int RepeatedPtrField<Element>::size() const {
 2168|    600|  return RepeatedPtrFieldBase::size();
 2169|    600|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase4castINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEPNT_4TypeEPv:
  748|    894|  static inline typename TypeHandler::Type* cast(void* element) {
  749|    894|    return reinterpret_cast<typename TypeHandler::Type*>(element);
  750|    894|  }
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8raw_dataEv:
 1857|      4|inline void* const* RepeatedPtrFieldBase::raw_data() const {
 1858|      4|  return rep_ ? rep_->elements : NULL;
  ------------------
  |  Branch (1858:10): [True: 2, False: 2]
  ------------------
 1859|      4|}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE5beginEv:
 2613|      1|RepeatedPtrField<Element>::begin() const {
 2614|      1|  return iterator(raw_data());
 2615|      1|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN13sentencepiece19SelfTestData_SampleEEC2EPKPv:
 2432|      2|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece19SelfTestData_SampleEEC2IS4_EERKNS2_IT_EE:
 2438|      2|      : it_(other.it_) {
 2439|       |    // Force a compiler error if the other type is not convertible to ours.
 2440|      2|    if (false) {
  ------------------
  |  Branch (2440:9): [Folded, False: 2]
  ------------------
 2441|      0|      implicit_cast<Element*>(static_cast<OtherElement*>(nullptr));
 2442|      0|    }
 2443|      2|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEE3endEv:
 2628|      1|RepeatedPtrField<Element>::end() const {
 2629|      1|  return iterator(raw_data() + size());
 2630|      1|}
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece19SelfTestData_SampleEEneERKS6_:
 2463|      1|  bool operator!=(const iterator& x) const { return it_ != x.it_; }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN13sentencepiece24ModelProto_SentencePieceEEC2EPKPv:
 2432|      2|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8GetArenaEv:
  719|      8|  inline Arena* GetArena() const { return arena_; }
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE5ClearEv:
 2293|      1|inline void RepeatedPtrField<Element>::Clear() {
 2294|      1|  RepeatedPtrFieldBase::Clear<TypeHandler>();
 2295|      1|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase5ClearINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEvv:
 1778|      1|void RepeatedPtrFieldBase::Clear() {
 1779|      1|  const int n = current_size_;
 1780|      1|  GOOGLE_DCHECK_GE(n, 0);
  ------------------
  |  |  188|      1|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|      1|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  |  |  ------------------
  |  |  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (181:41): [Folded, False: 1]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1781|      1|  if (n > 0) {
  ------------------
  |  Branch (1781:7): [True: 0, False: 1]
  ------------------
 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|      1|}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3GetEi:
 2172|    894|inline const Element& RepeatedPtrField<Element>::Get(int index) const {
 2173|    894|  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
 2174|    894|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase3GetINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEERKNT_4TypeEi:
 1704|    894|    int index) const {
 1705|    894|  GOOGLE_DCHECK_GE(index, 0);
  ------------------
  |  |  188|    894|#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
  |  |  ------------------
  |  |  |  |  181|    894|#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: 894]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1706|    894|  GOOGLE_DCHECK_LT(index, current_size_);
  ------------------
  |  |  185|    894|#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
  |  |  ------------------
  |  |  |  |  181|    894|#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: 894]
  |  |  |  |  ------------------
  |  |  ------------------
  ------------------
 1707|    894|  return *cast<TypeHandler>(rep_->elements[index]);
 1708|    894|}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3AddEv:
 2193|    298|inline Element* RepeatedPtrField<Element>::Add() {
 2194|    298|  return RepeatedPtrFieldBase::Add<TypeHandler>();
 2195|    298|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase3AddINS0_16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE11TypeHandlerEEEPNT_4TypeESB_:
 1741|    298|    typename TypeHandler::Type* prototype) {
 1742|    298|  if (rep_ != NULL && current_size_ < rep_->allocated_size) {
  ------------------
  |  Branch (1742:7): [True: 297, False: 1]
  |  Branch (1742:23): [True: 0, False: 297]
  ------------------
 1743|      0|    return cast<TypeHandler>(rep_->elements[current_size_++]);
 1744|      0|  }
 1745|    298|  if (!rep_ || rep_->allocated_size == total_size_) {
  ------------------
  |  Branch (1745:7): [True: 1, False: 297]
  |  Branch (1745:16): [True: 7, False: 290]
  ------------------
 1746|      8|    Reserve(total_size_ + 1);
 1747|      8|  }
 1748|    298|  ++rep_->allocated_size;
 1749|    298|  typename TypeHandler::Type* result =
 1750|    298|      TypeHandler::NewFromPrototype(prototype, arena_);
 1751|    298|  rep_->elements[current_size_++] = result;
 1752|    298|  return result;
 1753|    298|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE16NewFromPrototypeEPKS4_PNS0_5ArenaE:
  836|    298|    const GenericType* /* prototype */, Arena* arena) {
  837|    298|  return New(arena);
  838|    298|}
_ZN6google8protobuf8internal18GenericTypeHandlerIN13sentencepiece24ModelProto_SentencePieceEE3NewEPNS0_5ArenaE:
  806|    298|  static inline GenericType* New(Arena* arena) {
  807|    298|    return Arena::CreateMaybeMessage<Type>(arena);
  808|    298|  }
_ZN6google8protobuf16RepeatedPtrFieldINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEC2EPNS0_5ArenaE:
 2098|      8|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2EPNS0_5ArenaE:
 1654|     11|    : arena_(arena), current_size_(0), total_size_(0), rep_(NULL) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece19SelfTestData_SampleEEC2EPNS0_5ArenaE:
 2098|      1|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEEC2EPNS0_5ArenaE:
 2098|      2|    : RepeatedPtrFieldBase(arena) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE5beginEv:
 2613|      1|RepeatedPtrField<Element>::begin() const {
 2614|      1|  return iterator(raw_data());
 2615|      1|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEC2IS4_EERKNS2_IT_EE:
 2438|      2|      : it_(other.it_) {
 2439|       |    // Force a compiler error if the other type is not convertible to ours.
 2440|      2|    if (false) {
  ------------------
  |  Branch (2440:9): [Folded, False: 2]
  ------------------
 2441|      0|      implicit_cast<Element*>(static_cast<OtherElement*>(nullptr));
 2442|      0|    }
 2443|      2|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece24ModelProto_SentencePieceEE3endEv:
 2628|      1|RepeatedPtrField<Element>::end() const {
 2629|      1|  return iterator(raw_data() + size());
 2630|      1|}
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEneERKS6_:
 2463|    299|  bool operator!=(const iterator& x) const { return it_ != x.it_; }
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEppEv:
 2450|    298|  iterator& operator++() {
 2451|    298|    ++it_;
 2452|    298|    return *this;
 2453|    298|  }
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece24ModelProto_SentencePieceEEdeEv:
 2446|    298|  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }

_ZN6google8protobuf8internal12WrappedMutex4LockEv:
   99|      8|  void Lock() GOOGLE_PROTOBUF_ACQUIRE() { mu_.lock(); }
_ZN6google8protobuf8internal12WrappedMutex6UnlockEv:
  100|      8|  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;

_ZN6google8protobuf11StringPiece22CheckedSsizeTFromSizeTEm:
  186|      2|  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|      2|    return static_cast<stringpiece_ssize_type>(size);
  199|      2|  }
_ZN6google8protobuf11StringPieceC2EPKc:
  214|      2|      : ptr_(str), length_(0) {
  215|      2|    if (str != nullptr) {
  ------------------
  |  Branch (215:9): [True: 2, False: 0]
  ------------------
  216|      2|      length_ = CheckedSsizeTFromSizeT(strlen(str));
  217|      2|    }
  218|      2|  }
_ZN6google8protobuf11StringPieceC2EPKcl:
  228|     11|      : ptr_(offset), length_(len) {
  229|       |    assert(len >= 0);
  230|     11|  }
_ZNK6google8protobuf11StringPiece4dataEv:
  246|      4|  const char* data() const { return ptr_; }
_ZNK6google8protobuf11StringPiece4sizeEv:
  247|      4|  stringpiece_ssize_type size() const { return length_; }
_ZNK6google8protobuf11StringPiece8ToStringEv:
  310|      2|  std::string ToString() const {
  311|      2|    if (ptr_ == nullptr) return "";
  ------------------
  |  Branch (311:9): [True: 0, False: 2]
  ------------------
  312|      2|    return std::string(data(), static_cast<size_type>(size()));
  313|      2|  }

_ZN6google8protobuf8internal13MergeFromImplILb0EEEbNS0_11StringPieceEPNS0_11MessageLiteENS4_10ParseFlagsE:
  140|      1|                   MessageLite::ParseFlags parse_flags) {
  141|      1|  const char* ptr;
  142|      1|  internal::ParseContext ctx(io::CodedInputStream::GetDefaultRecursionLimit(),
  143|      1|                             aliasing, &ptr, input);
  144|      1|  ptr = msg->_InternalParse(ptr, &ctx);
  145|       |  // ctx has an explicit limit set (length of string_view).
  146|      1|  if (PROTOBUF_PREDICT_TRUE(ptr && ctx.EndedAtLimit())) {
  ------------------
  |  |  236|      2|#define PROTOBUF_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
  |  |  ------------------
  |  |  |  Branch (236:34): [True: 1, False: 0]
  |  |  |  Branch (236:55): [True: 1, False: 0]
  |  |  |  Branch (236:55): [True: 1, False: 0]
  |  |  ------------------
  ------------------
  147|      1|    return CheckFieldPresence(ctx, *msg, parse_flags);
  148|      1|  }
  149|      0|  return false;
  150|      1|}
_ZN6google8protobuf11MessageLite14ParseFromArrayEPKvi:
  324|      1|bool MessageLite::ParseFromArray(const void* data, int size) {
  325|      1|  return ParseFrom<kParse>(as_string_view(data, size));
  326|      1|}
_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|}
message_lite.cc:_ZN6google8protobuf12_GLOBAL__N_118CheckFieldPresenceERKNS0_8internal12ParseContextERKNS0_11MessageLiteENS6_10ParseFlagsE:
  123|      1|                               MessageLite::ParseFlags parse_flags) {
  124|      1|  if (PROTOBUF_PREDICT_FALSE((parse_flags & MessageLite::kMergePartial) != 0)) {
  ------------------
  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  125|      0|    return true;
  126|      0|  }
  127|      1|  return msg.IsInitializedWithErrors();
  128|      1|}
message_lite.cc:_ZN6google8protobuf12_GLOBAL__N_114as_string_viewEPKvi:
  116|      1|inline StringPiece as_string_view(const void* data, int size) {
  117|      1|  return StringPiece(static_cast<const char*>(data), size);
  118|      1|}
_ZN6google8protobuf8internal12ShutdownData3getEv:
  546|      7|  static ShutdownData* get() {
  547|      7|    static auto* data = new ShutdownData;
  548|      7|    return data;
  549|      7|  }

_ZN6google8protobuf8internal18EpsCopyInputStream12DoneFallbackEii:
  172|      1|                                                              int depth) {
  173|       |  // Did we exceeded the limit (parse error).
  174|      1|  if (PROTOBUF_PREDICT_FALSE(overrun > limit_)) return {nullptr, true};
  ------------------
  |  |  247|      1|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 1]
  |  |  ------------------
  ------------------
  175|      1|  GOOGLE_DCHECK(overrun != limit_);  // Guaranteed by caller.
  ------------------
  |  |  181|      1|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1]
  |  |  ------------------
  ------------------
  176|      1|  GOOGLE_DCHECK(overrun < limit_);   // Follows from above
  ------------------
  |  |  181|      1|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1]
  |  |  ------------------
  ------------------
  177|       |  // TODO(gerbens) Instead of this dcheck we could just assign, and remove
  178|       |  // updating the limit_end from PopLimit, ie.
  179|       |  // limit_end_ = buffer_end_ + (std::min)(0, limit_);
  180|       |  // if (ptr < limit_end_) return {ptr, false};
  181|      1|  GOOGLE_DCHECK(limit_end_ == buffer_end_ + (std::min)(0, limit_));
  ------------------
  |  |  181|      1|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1]
  |  |  ------------------
  ------------------
  182|       |  // At this point we know the following assertion holds.
  183|      1|  GOOGLE_DCHECK(limit_ > 0);
  ------------------
  |  |  181|      1|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1]
  |  |  ------------------
  ------------------
  184|      1|  GOOGLE_DCHECK(limit_end_ == buffer_end_);  // because limit_ > 0
  ------------------
  |  |  181|      1|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1]
  |  |  ------------------
  ------------------
  185|      1|  const char* p;
  186|      1|  do {
  187|       |    // We are past the end of buffer_end_, in the slop region.
  188|      1|    GOOGLE_DCHECK(overrun >= 0);
  ------------------
  |  |  181|      1|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 1]
  |  |  ------------------
  ------------------
  189|      1|    p = NextBuffer(overrun, depth);
  190|      1|    if (p == nullptr) {
  ------------------
  |  Branch (190:9): [True: 0, False: 1]
  ------------------
  191|       |      // We are at the end of the stream
  192|      0|      if (PROTOBUF_PREDICT_FALSE(overrun != 0)) return {nullptr, true};
  ------------------
  |  |  247|      0|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 0]
  |  |  ------------------
  ------------------
  193|      0|      GOOGLE_DCHECK(limit_ > 0);
  ------------------
  |  |  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]
  |  |  ------------------
  ------------------
  194|      0|      limit_end_ = buffer_end_;
  195|       |      // Distinguish ending on a pushed limit or ending on end-of-stream.
  196|      0|      SetEndOfStream();
  197|      0|      return {buffer_end_, true};
  198|      0|    }
  199|      1|    limit_ -= buffer_end_ - p;  // Adjust limit_ relative to new anchor
  200|      1|    p += overrun;
  201|      1|    overrun = p - buffer_end_;
  202|      1|  } while (overrun >= 0);
  ------------------
  |  Branch (202:12): [True: 0, False: 1]
  ------------------
  203|      1|  limit_end_ = buffer_end_ + std::min(0, limit_);
  204|      1|  return {p, false};
  205|      1|}
_ZN6google8protobuf8internal24InlineGreedyStringParserEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKcPNS1_12ParseContextE:
  438|    298|                                     ParseContext* ctx) {
  439|    298|  int size = ReadSize(&ptr);
  440|    298|  if (!ptr) return nullptr;
  ------------------
  |  Branch (440:7): [True: 0, False: 298]
  ------------------
  441|    298|  return ctx->ReadString(ptr, size, s);
  442|    298|}
_ZN6google8protobuf8internal18EpsCopyInputStream10NextBufferEii:
  102|      1|const char* EpsCopyInputStream::NextBuffer(int overrun, int depth) {
  103|      1|  if (next_chunk_ == nullptr) return nullptr;  // We've reached end of stream.
  ------------------
  |  Branch (103:7): [True: 0, False: 1]
  ------------------
  104|      1|  if (next_chunk_ != buffer_) {
  ------------------
  |  Branch (104:7): [True: 0, False: 1]
  ------------------
  105|      0|    GOOGLE_DCHECK(size_ > kSlopBytes);
  ------------------
  |  |  181|      0|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 0]
  |  |  ------------------
  ------------------
  106|       |    // The chunk is large enough to be used directly
  107|      0|    buffer_end_ = next_chunk_ + size_ - kSlopBytes;
  108|      0|    auto res = next_chunk_;
  109|      0|    next_chunk_ = buffer_;
  110|      0|    if (aliasing_ == kOnPatch) aliasing_ = kNoDelta;
  ------------------
  |  Branch (110:9): [True: 0, False: 0]
  ------------------
  111|      0|    return res;
  112|      0|  }
  113|       |  // Move the slop bytes of previous buffer to start of the patch buffer.
  114|       |  // Note we must use memmove because the previous buffer could be part of
  115|       |  // buffer_.
  116|      1|  std::memmove(buffer_, buffer_end_, kSlopBytes);
  117|      1|  if (overall_limit_ > 0 &&
  ------------------
  |  Branch (117:7): [True: 0, False: 1]
  ------------------
  118|      0|      (depth < 0 || !ParseEndsInSlopRegion(buffer_, overrun, depth))) {
  ------------------
  |  Branch (118:8): [True: 0, False: 0]
  |  Branch (118:21): [True: 0, False: 0]
  ------------------
  119|      0|    const void* data;
  120|       |    // ZeroCopyInputStream indicates Next may return 0 size buffers. Hence
  121|       |    // we loop.
  122|      0|    while (StreamNext(&data)) {
  ------------------
  |  Branch (122:12): [True: 0, False: 0]
  ------------------
  123|      0|      if (size_ > kSlopBytes) {
  ------------------
  |  Branch (123:11): [True: 0, False: 0]
  ------------------
  124|       |        // We got a large chunk
  125|      0|        std::memcpy(buffer_ + kSlopBytes, data, kSlopBytes);
  126|      0|        next_chunk_ = static_cast<const char*>(data);
  127|      0|        buffer_end_ = buffer_ + kSlopBytes;
  128|      0|        if (aliasing_ >= kNoDelta) aliasing_ = kOnPatch;
  ------------------
  |  Branch (128:13): [True: 0, False: 0]
  ------------------
  129|      0|        return buffer_;
  130|      0|      } else if (size_ > 0) {
  ------------------
  |  Branch (130:18): [True: 0, False: 0]
  ------------------
  131|      0|        std::memcpy(buffer_ + kSlopBytes, data, size_);
  132|      0|        next_chunk_ = buffer_;
  133|      0|        buffer_end_ = buffer_ + size_;
  134|      0|        if (aliasing_ >= kNoDelta) aliasing_ = kOnPatch;
  ------------------
  |  Branch (134:13): [True: 0, False: 0]
  ------------------
  135|      0|        return buffer_;
  136|      0|      }
  137|      0|      GOOGLE_DCHECK(size_ == 0) << size_;
  ------------------
  |  |  181|      0|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:3): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 0]
  |  |  ------------------
  ------------------
  138|      0|    }
  139|      0|    overall_limit_ = 0;  // Next failed, no more needs for next
  140|      0|  }
  141|       |  // End of stream or array
  142|      1|  if (aliasing_ == kNoDelta) {
  ------------------
  |  Branch (142:7): [True: 0, False: 1]
  ------------------
  143|       |    // If there is no more block and aliasing is true, the previous block
  144|       |    // is still valid and we can alias. We have users relying on string_view's
  145|       |    // obtained from protos to outlive the proto, when the parse was from an
  146|       |    // array. This guarantees string_view's are always aliased if parsed from
  147|       |    // an array.
  148|      0|    aliasing_ = reinterpret_cast<std::uintptr_t>(buffer_end_) -
  149|      0|                reinterpret_cast<std::uintptr_t>(buffer_);
  150|      0|  }
  151|      1|  next_chunk_ = nullptr;
  152|      1|  buffer_end_ = buffer_ + kSlopBytes;
  153|      1|  size_ = 0;
  154|      1|  return buffer_;
  155|      1|}

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

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

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