LLVMFuzzerTestOneInput:
   24|    116|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   25|    116|  sentencepiece::SentencePieceProcessor fuzz_sp_processor;
   26|    116|  FuzzedDataProvider data_provider(data, size);
   27|    116|  const int nbest_size = data_provider.ConsumeIntegral<int>();
   28|    116|  const float alpha = data_provider.ConsumeFloatingPoint<float>();
   29|    116|  const std::string in_string = data_provider.ConsumeRemainingBytesAsString();
   30|       |
   31|    116|  fuzz_sp_processor.SampleEncodeAsSerializedProto(in_string, nbest_size, alpha);
   32|    116|  return 0;
   33|    116|}

_ZNK13sentencepiece22SentencePieceProcessor29SampleEncodeAsSerializedProtoENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEif:
  539|    116|                                                    float alpha) const {
  540|    116|    DEFINE_SPP_SERIALIZED_PROTO_IMPL(SampleEncode, ImmutableSentencePieceText,
  ------------------
  |  |  444|    116|  OutType output;                                                    \
  |  |  445|    116|  const auto status = FuncName(__VA_ARGS__, output.mutable_proto()); \
  |  |  446|    116|  SPP_SWIG_CHECK_AND_THROW;                                          \
  |  |  ------------------
  |  |  |  |  433|    116|  if (!status.ok()) {            \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (433:7): [True: 116, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  434|    116|  }
  |  |  ------------------
  |  |  447|    116|  return output.SerializeAsString();
  ------------------
  541|    116|                                     input, nbest_size, alpha);
  542|      0|  }
_ZNK13sentencepiece4util6Status2okEv:
   68|    232|  inline bool ok() const { return rep_ == nullptr; }

_ZN13sentencepiece31SentencePieceText_SentencePieceC2EPN6google8protobuf5ArenaE:
   96|      1|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
   97|      1|  _extensions_(arena) {
   98|      1|  SharedCtor();
   99|      1|  RegisterArenaDtor(arena);
  100|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.SentencePieceText.SentencePiece)
  101|      1|}
_ZN13sentencepiece17SentencePieceTextC2EPN6google8protobuf5ArenaE:
  451|    117|  : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena),
  452|    117|  _extensions_(arena),
  453|    117|  pieces_(arena) {
  454|    117|  SharedCtor();
  455|    117|  RegisterArenaDtor(arena);
  456|       |  // @@protoc_insertion_point(arena_constructor:sentencepiece.SentencePieceText)
  457|    117|}
_ZN13sentencepiece17SentencePieceTextD2Ev:
  479|    116|SentencePieceText::~SentencePieceText() {
  480|       |  // @@protoc_insertion_point(destructor:sentencepiece.SentencePieceText)
  481|    116|  SharedDtor();
  482|    116|  _internal_metadata_.Delete<std::string>();
  483|    116|}
_ZNK13sentencepiece17SentencePieceText13SetCachedSizeEi:
  496|    116|void SentencePieceText::SetCachedSize(int size) const {
  497|    116|  _cached_size_.Set(size);
  498|    116|}
_ZN13sentencepiece17SentencePieceText16default_instanceEv:
  499|    116|const SentencePieceText& SentencePieceText::default_instance() {
  500|    116|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&::scc_info_SentencePieceText_sentencepiece_2eproto.base);
  501|    116|  return *internal_default_instance();
  502|    116|}
_ZNK13sentencepiece17SentencePieceText18_InternalSerializeEPhPN6google8protobuf2io19EpsCopyOutputStreamE:
  588|    116|    ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
  589|       |  // @@protoc_insertion_point(serialize_to_array_start:sentencepiece.SentencePieceText)
  590|    116|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  591|    116|  (void) cached_has_bits;
  592|       |
  593|    116|  cached_has_bits = _has_bits_[0];
  594|       |  // optional string text = 1;
  595|    116|  if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (595:7): [True: 0, False: 116]
  ------------------
  596|      0|    target = stream->WriteStringMaybeAliased(
  597|      0|        1, this->_internal_text(), target);
  598|      0|  }
  599|       |
  600|       |  // repeated .sentencepiece.SentencePieceText.SentencePiece pieces = 2;
  601|    116|  for (unsigned int i = 0,
  602|    116|      n = static_cast<unsigned int>(this->_internal_pieces_size()); i < n; i++) {
  ------------------
  |  Branch (602:69): [True: 0, False: 116]
  ------------------
  603|      0|    target = stream->EnsureSpace(target);
  604|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
  605|      0|      InternalWriteMessage(2, this->_internal_pieces(i), target, stream);
  606|      0|  }
  607|       |
  608|       |  // optional float score = 3;
  609|    116|  if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (609:7): [True: 0, False: 116]
  ------------------
  610|      0|    target = stream->EnsureSpace(target);
  611|      0|    target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_score(), target);
  612|      0|  }
  613|       |
  614|       |  // Extension range [200, 536870912)
  615|    116|  target = _extensions_._InternalSerialize(
  616|    116|      200, 536870912, target, stream);
  617|       |
  618|    116|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|    116|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 116]
  |  |  ------------------
  ------------------
  619|      0|    target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
  620|      0|        static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
  621|      0|  }
  622|       |  // @@protoc_insertion_point(serialize_to_array_end:sentencepiece.SentencePieceText)
  623|    116|  return target;
  624|    116|}
_ZNK13sentencepiece17SentencePieceText12ByteSizeLongEv:
  626|    116|size_t SentencePieceText::ByteSizeLong() const {
  627|       |// @@protoc_insertion_point(message_byte_size_start:sentencepiece.SentencePieceText)
  628|    116|  size_t total_size = 0;
  629|       |
  630|    116|  total_size += _extensions_.ByteSize();
  631|       |
  632|    116|  ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0;
  633|       |  // Prevent compiler warnings about cached_has_bits being unused
  634|    116|  (void) cached_has_bits;
  635|       |
  636|       |  // repeated .sentencepiece.SentencePieceText.SentencePiece pieces = 2;
  637|    116|  total_size += 1UL * this->_internal_pieces_size();
  638|    116|  for (const auto& msg : this->pieces_) {
  ------------------
  |  Branch (638:24): [True: 0, False: 116]
  ------------------
  639|      0|    total_size +=
  640|      0|      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg);
  641|      0|  }
  642|       |
  643|    116|  cached_has_bits = _has_bits_[0];
  644|    116|  if (cached_has_bits & 0x00000003u) {
  ------------------
  |  Branch (644:7): [True: 0, False: 116]
  ------------------
  645|       |    // optional string text = 1;
  646|      0|    if (cached_has_bits & 0x00000001u) {
  ------------------
  |  Branch (646:9): [True: 0, False: 0]
  ------------------
  647|      0|      total_size += 1 +
  648|      0|        ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
  649|      0|          this->_internal_text());
  650|      0|    }
  651|       |
  652|       |    // optional float score = 3;
  653|      0|    if (cached_has_bits & 0x00000002u) {
  ------------------
  |  Branch (653:9): [True: 0, False: 0]
  ------------------
  654|      0|      total_size += 1 + 4;
  655|      0|    }
  656|       |
  657|      0|  }
  658|    116|  if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
  ------------------
  |  |  247|    116|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 116]
  |  |  ------------------
  ------------------
  659|      0|    total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
  660|      0|  }
  661|    116|  int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(total_size);
  662|    116|  SetCachedSize(cached_size);
  663|    116|  return total_size;
  664|    116|}
sentencepiece.pb.cc:_ZL60InitDefaultsscc_info_SentencePieceText_sentencepiece_2eprotov:
   44|      1|static void InitDefaultsscc_info_SentencePieceText_sentencepiece_2eproto() {
   45|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   46|       |
   47|      1|  {
   48|      1|    void* ptr = &::sentencepiece::_SentencePieceText_default_instance_;
   49|      1|    new (ptr) ::sentencepiece::SentencePieceText();
   50|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   51|      1|  }
   52|      1|}
sentencepiece.pb.cc:_ZL74InitDefaultsscc_info_SentencePieceText_SentencePiece_sentencepiece_2eprotov:
   58|      1|static void InitDefaultsscc_info_SentencePieceText_SentencePiece_sentencepiece_2eproto() {
   59|      1|  GOOGLE_PROTOBUF_VERIFY_VERSION;
  ------------------
  |  |  118|      1|  ::google::protobuf::internal::VerifyVersion(                            \
  |  |  119|      1|    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |   85|      1|#define GOOGLE_PROTOBUF_VERSION 3014000
  |  |  ------------------
  |  |                   GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
  |  |  ------------------
  |  |  |  |  328|      1|#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3014000
  |  |  ------------------
  |  |  120|       |    __FILE__)
  ------------------
   60|       |
   61|      1|  {
   62|      1|    void* ptr = &::sentencepiece::_SentencePieceText_SentencePiece_default_instance_;
   63|      1|    new (ptr) ::sentencepiece::SentencePieceText_SentencePiece();
   64|      1|    ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr);
   65|      1|  }
   66|      1|}
_ZN13sentencepiece31SentencePieceText_SentencePiece10SharedCtorEv:
  123|      1|void SentencePieceText_SentencePiece::SharedCtor() {
  124|      1|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SentencePieceText_SentencePiece_sentencepiece_2eproto.base);
  125|      1|  piece_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  126|      1|  surface_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  127|      1|  ::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
  128|      1|      reinterpret_cast<char*>(&id_) - reinterpret_cast<char*>(this)),
  129|      1|      0, static_cast<size_t>(reinterpret_cast<char*>(&end_) -
  130|      1|      reinterpret_cast<char*>(&id_)) + sizeof(end_));
  131|      1|}
_ZN13sentencepiece31SentencePieceText_SentencePiece17RegisterArenaDtorEPN6google8protobuf5ArenaE:
  149|      1|void SentencePieceText_SentencePiece::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  150|      1|}
_ZN13sentencepiece17SentencePieceText10SharedCtorEv:
  473|    117|void SentencePieceText::SharedCtor() {
  474|    117|  ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_SentencePieceText_sentencepiece_2eproto.base);
  475|    117|  text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  476|    117|  score_ = 0;
  477|    117|}
_ZN13sentencepiece17SentencePieceText10SharedDtorEv:
  485|    116|void SentencePieceText::SharedDtor() {
  486|    116|  GOOGLE_DCHECK(GetArena() == nullptr);
  ------------------
  |  |  181|    116|#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: 116]
  |  |  ------------------
  ------------------
  487|    116|  text_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  488|    116|}
_ZN13sentencepiece17SentencePieceText17RegisterArenaDtorEPN6google8protobuf5ArenaE:
  494|    117|void SentencePieceText::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
  495|    117|}

_ZNK13sentencepiece17SentencePieceText21_internal_pieces_sizeEv:
  917|    232|inline int SentencePieceText::_internal_pieces_size() const {
  918|    232|  return pieces_.size();
  919|    232|}
_ZN13sentencepiece17SentencePieceTextC2Ev:
  286|    117|  inline SentencePieceText() : SentencePieceText(nullptr) {}
_ZN13sentencepiece31SentencePieceText_SentencePieceC2Ev:
   76|      1|  inline SentencePieceText_SentencePiece() : SentencePieceText_SentencePiece(nullptr) {}
_ZN13sentencepiece17SentencePieceText25internal_default_instanceEv:
  317|    116|  static inline const SentencePieceText* internal_default_instance() {
  318|    116|    return reinterpret_cast<const SentencePieceText*>(
  319|    116|               &_SentencePieceText_default_instance_);
  320|    116|  }

_ZN13sentencepiece4util6StatusD2Ev:
   24|    116|Status::~Status() {}
_ZN13sentencepiece4util6StatusC2ENS0_10StatusCodeENSt3__117basic_string_viewIcNS3_11char_traitsIcEEEE:
   32|    116|    : rep_(new Rep) {
   33|    116|  rep_->code = code;
   34|    116|  rep_->error_message = std::string(error_message);
   35|    116|}

_ZN13sentencepiece26ImmutableSentencePieceTextC2Ev:
   96|    116|    : spt_(&SentencePieceText::default_instance()) {}
_ZN13sentencepiece26ImmutableSentencePieceTextD2Ev:
  102|    116|ImmutableSentencePieceText::~ImmutableSentencePieceText() {}
_ZN13sentencepiece26ImmutableSentencePieceText13mutable_protoEv:
  162|    116|SentencePieceText *ImmutableSentencePieceText::mutable_proto() {
  163|    116|  if (rep_ == nullptr) {
  ------------------
  |  Branch (163:7): [True: 116, False: 0]
  ------------------
  164|    116|    rep_ = std::make_shared<SentencePieceText>();
  165|    116|    spt_ = rep_.get();
  166|    116|  }
  167|    116|  return rep_.get();
  168|    116|}
_ZNK13sentencepiece26ImmutableSentencePieceText17SerializeAsStringEv:
  174|    116|util::bytes ImmutableSentencePieceText::SerializeAsString() const {
  175|    116|  return spt_->SerializeAsString();
  176|    116|}
_ZN13sentencepiece22SentencePieceProcessorC2Ev:
  217|    116|SentencePieceProcessor::SentencePieceProcessor() {}
_ZN13sentencepiece22SentencePieceProcessorD2Ev:
  218|    116|SentencePieceProcessor::~SentencePieceProcessor() {}
_ZNK13sentencepiece22SentencePieceProcessor6statusEv:
  295|    116|util::Status SentencePieceProcessor::status() const {
  296|    116|  CHECK_OR_RETURN(model_) << "Model is not initialized.";
  ------------------
  |  |  446|    232|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (446:7): [True: 0, False: 116]
  |  |  ------------------
  |  |  447|      0|  } else /* NOLINT */                                        \
  |  |  448|    232|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  449|    116|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  450|    116|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  297|      0|  CHECK_OR_RETURN(normalizer_) << "Normalizer is not initialized.";
  ------------------
  |  |  446|      0|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (446:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  447|      0|  } else /* NOLINT */                                        \
  |  |  448|      0|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  449|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  450|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  298|      0|  RETURN_IF_ERROR(model_->status());
  ------------------
  |  |   46|      0|  do {                                 \
  |  |   47|      0|    const auto _status = expr;         \
  |  |   48|      0|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (48:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   49|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (49:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  299|      0|  RETURN_IF_ERROR(normalizer_->status());
  ------------------
  |  |   46|      0|  do {                                 \
  |  |   47|      0|    const auto _status = expr;         \
  |  |   48|      0|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (48:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   49|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (49:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  300|      0|  return util::OkStatus();
  301|      0|}
_ZNK13sentencepiece22SentencePieceProcessor12SampleEncodeENSt3__117basic_string_viewIcNS1_11char_traitsIcEEEEifPNS_17SentencePieceTextE:
  686|    116|    SentencePieceText *spt) const {
  687|    116|  CHECK_OR_RETURN_STATUS_PROTO(spt);
  ------------------
  |  |  375|    116|  RETURN_IF_ERROR(status());                        \
  |  |  ------------------
  |  |  |  |   46|    116|  do {                                 \
  |  |  |  |   47|    116|    const auto _status = expr;         \
  |  |  |  |   48|    116|    if (!_status.ok()) return _status; \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (48:9): [True: 116, False: 0]
  |  |  |  |  ------------------
  |  |  |  |   49|    116|  } while (0)
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (49:12): [Folded, False: 0]
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  376|    116|  CHECK_OR_RETURN(proto) << "output proto is null"; \
  |  |  ------------------
  |  |  |  |  446|      0|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (446:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  447|      0|  } else /* NOLINT */                                        \
  |  |  |  |  448|      0|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  449|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  450|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  |  |  377|      0|  proto->Clear();
  ------------------
  688|       |
  689|      0|  CHECK_LE_OR_RETURN(nbest_size, 512) << "nbest_size must be nbest_size <= 512";
  ------------------
  |  |  455|      0|#define CHECK_LE_OR_RETURN(a, b) CHECK_OR_RETURN((a) <= (b))
  |  |  ------------------
  |  |  |  |  446|      0|  if (condition) {                                           \
  |  |  |  |  ------------------
  |  |  |  |  |  Branch (446:7): [True: 0, False: 0]
  |  |  |  |  ------------------
  |  |  |  |  447|      0|  } else /* NOLINT */                                        \
  |  |  |  |  448|      0|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  |  |  449|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  |  |  450|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  |  |  ------------------
  ------------------
  690|       |
  691|      0|  std::string normalized;
  692|      0|  std::vector<size_t> norm_to_orig;
  693|      0|  RETURN_IF_ERROR(normalizer_->Normalize(input, &normalized, &norm_to_orig));
  ------------------
  |  |   46|      0|  do {                                 \
  |  |   47|      0|    const auto _status = expr;         \
  |  |   48|      0|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (48:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   49|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (49:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  694|       |
  695|      0|  if (!model_->IsNBestEncodeAvailable() || nbest_size < 0) {
  ------------------
  |  Branch (695:7): [True: 0, False: 0]
  |  Branch (695:44): [True: 0, False: 0]
  ------------------
  696|      0|    CHECK_OR_RETURN(model_->IsSampleEncodeAvailable())
  ------------------
  |  |  446|      0|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (446:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  447|      0|  } else /* NOLINT */                                        \
  |  |  448|      0|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  449|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  450|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  697|      0|        << "SampleEncode is not available for the current model.";
  698|      0|    const auto result = model_->SampleEncode(normalized, alpha);
  699|      0|    RETURN_IF_ERROR(PopulateSentencePieceText(input, normalized, norm_to_orig,
  ------------------
  |  |   46|      0|  do {                                 \
  |  |   47|      0|    const auto _status = expr;         \
  |  |   48|      0|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (48:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   49|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (49:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  700|      0|                                              result, spt));
  701|      0|  } else if (nbest_size == 1 || nbest_size == 0) {
  ------------------
  |  Branch (701:14): [True: 0, False: 0]
  |  Branch (701:33): [True: 0, False: 0]
  ------------------
  702|      0|    const auto result = model_->Encode(normalized);
  703|      0|    RETURN_IF_ERROR(PopulateSentencePieceText(input, normalized, norm_to_orig,
  ------------------
  |  |   46|      0|  do {                                 \
  |  |   47|      0|    const auto _status = expr;         \
  |  |   48|      0|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (48:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   49|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (49:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  704|      0|                                              result, spt));
  705|      0|  } else if (nbest_size > 1) {
  ------------------
  |  Branch (705:14): [True: 0, False: 0]
  ------------------
  706|      0|    const auto nbests = model_->NBestEncode(normalized, nbest_size);
  707|      0|    CHECK_OR_RETURN(!nbests.empty()) << "NBestEncode returns empty result.";
  ------------------
  |  |  446|      0|  if (condition) {                                           \
  |  |  ------------------
  |  |  |  Branch (446:7): [True: 0, False: 0]
  |  |  ------------------
  |  |  447|      0|  } else /* NOLINT */                                        \
  |  |  448|      0|    return ::sentencepiece::util::StatusBuilder(             \
  |  |  449|      0|               ::sentencepiece::util::StatusCode::kInternal) \
  |  |  450|      0|           << __FILE__ << "(" << __LINE__ << ") [" << #condition << "] "
  ------------------
  708|       |
  709|      0|    std::vector<double> log_probs;
  710|      0|    log_probs.reserve(nbests.size());
  711|      0|    std::transform(nbests.begin(), nbests.end(), std::back_inserter(log_probs),
  712|      0|                   [alpha](const auto &nbest) { return alpha * nbest.second; });
  713|       |
  714|      0|    const double Z = log_domain::LogSum(log_probs);
  715|      0|    std::vector<double> probs;
  716|      0|    probs.reserve(log_probs.size());
  717|      0|    std::transform(
  718|      0|        log_probs.begin(), log_probs.end(), std::back_inserter(probs),
  719|      0|        [Z](const auto &log_prob) { return std::exp(log_prob - Z); });
  720|       |
  721|      0|    auto *mt = random::GetRandomGenerator();
  722|      0|    std::discrete_distribution<int> dist(probs.begin(), probs.end());
  723|      0|    RETURN_IF_ERROR(PopulateSentencePieceText(input, normalized, norm_to_orig,
  ------------------
  |  |   46|      0|  do {                                 \
  |  |   47|      0|    const auto _status = expr;         \
  |  |   48|      0|    if (!_status.ok()) return _status; \
  |  |  ------------------
  |  |  |  Branch (48:9): [True: 0, False: 0]
  |  |  ------------------
  |  |   49|      0|  } while (0)
  |  |  ------------------
  |  |  |  Branch (49:12): [Folded, False: 0]
  |  |  ------------------
  ------------------
  724|      0|                                              nbests[dist(*mt)].first, spt));
  725|      0|  }
  726|       |
  727|      0|  return util::OkStatus();
  728|      0|}

_ZN13sentencepiece4util13StatusBuilderC2ENS0_10StatusCodeE:
  429|    116|  explicit StatusBuilder(StatusCode code) : code_(code) {}
_ZNK13sentencepiece4util13StatusBuildercvNS0_6StatusEEv:
  438|    116|  operator Status() const { return Status(code_, os_.str()); }
_ZN13sentencepiece4util13StatusBuilderlsIA31_cEERS1_RKT_:
  433|    116|  StatusBuilder &operator<<(const T &value) {
  434|    116|    os_ << value;
  435|    116|    return *this;
  436|    116|  }
_ZN13sentencepiece4util13StatusBuilderlsIA2_cEERS1_RKT_:
  433|    116|  StatusBuilder &operator<<(const T &value) {
  434|    116|    os_ << value;
  435|    116|    return *this;
  436|    116|  }
_ZN13sentencepiece4util13StatusBuilderlsIiEERS1_RKT_:
  433|    116|  StatusBuilder &operator<<(const T &value) {
  434|    116|    os_ << value;
  435|    116|    return *this;
  436|    116|  }
_ZN13sentencepiece4util13StatusBuilderlsIA4_cEERS1_RKT_:
  433|    116|  StatusBuilder &operator<<(const T &value) {
  434|    116|    os_ << value;
  435|    116|    return *this;
  436|    116|  }
_ZN13sentencepiece4util13StatusBuilderlsIA3_cEERS1_RKT_:
  433|    116|  StatusBuilder &operator<<(const T &value) {
  434|    116|    os_ << value;
  435|    116|    return *this;
  436|    116|  }
_ZN13sentencepiece4util13StatusBuilderlsIA7_cEERS1_RKT_:
  433|    116|  StatusBuilder &operator<<(const T &value) {
  434|    116|    os_ << value;
  435|    116|    return *this;
  436|    116|  }
_ZN13sentencepiece4util13StatusBuilderlsIA26_cEERS1_RKT_:
  433|    116|  StatusBuilder &operator<<(const T &value) {
  434|    116|    os_ << value;
  435|    116|    return *this;
  436|    116|  }

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

_ZN6google8protobuf8internal12ExtensionSetC2EPNS0_5ArenaE:
  188|    118|    : arena_(arena),
  189|    118|      flat_capacity_(0),
  190|    118|      flat_size_(0),
  191|    118|      map_{flat_capacity_ == 0
  ------------------
  |  Branch (191:12): [True: 118, False: 0]
  ------------------
  192|    118|               ? NULL
  193|    118|               : Arena::CreateArray<KeyValue>(arena_, flat_capacity_)} {}
_ZN6google8protobuf8internal12ExtensionSetD2Ev:
  195|    116|ExtensionSet::~ExtensionSet() {
  196|       |  // Deletes all allocated extensions.
  197|    116|  if (arena_ == NULL) {
  ------------------
  |  Branch (197:7): [True: 116, False: 0]
  ------------------
  198|    116|    ForEach([](int /* number */, Extension& ext) { ext.Free(); });
  199|    116|    if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|    116|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 116]
  |  |  ------------------
  ------------------
  200|      0|      delete map_.large;
  201|    116|    } else {
  202|    116|      DeleteFlatMap(map_.flat, flat_capacity_);
  203|    116|    }
  204|    116|  }
  205|    116|}
_ZN6google8protobuf8internal12ExtensionSet13DeleteFlatMapEPKNS2_8KeyValueEt:
  208|    116|                                 uint16 flat_capacity) {
  209|    116|#ifdef __cpp_sized_deallocation
  210|       |  // Arena::CreateArray already requires a trivially destructible type, but
  211|       |  // ensure this constraint is not violated in the future.
  212|    116|  static_assert(std::is_trivially_destructible<KeyValue>::value,
  213|    116|                "CreateArray requires a trivially destructible type");
  214|       |  // A const-cast is needed, but this is safe as we are about to deallocate the
  215|       |  // array.
  216|    116|  ::operator delete[](const_cast<ExtensionSet::KeyValue*>(flat),
  217|    116|                      sizeof(*flat) * flat_capacity);
  218|       |#else   // !__cpp_sized_deallocation
  219|       |  delete[] flat;
  220|       |#endif  // !__cpp_sized_deallocation
  221|    116|}
_ZNK6google8protobuf8internal12ExtensionSet18_InternalSerializeEiiPhPNS0_2io19EpsCopyOutputStreamE:
 1460|    116|                                        io::EpsCopyOutputStream* stream) const {
 1461|    116|  if (PROTOBUF_PREDICT_FALSE(is_large())) {
  ------------------
  |  |  247|    116|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 0, False: 116]
  |  |  ------------------
  ------------------
 1462|      0|    const auto& end = map_.large->end();
 1463|      0|    for (auto it = map_.large->lower_bound(start_field_number);
 1464|      0|         it != end && it->first < end_field_number; ++it) {
  ------------------
  |  Branch (1464:10): [True: 0, False: 0]
  |  Branch (1464:23): [True: 0, False: 0]
  ------------------
 1465|      0|      target = it->second.InternalSerializeFieldWithCachedSizesToArray(
 1466|      0|          it->first, target, stream);
 1467|      0|    }
 1468|      0|    return target;
 1469|      0|  }
 1470|    116|  const KeyValue* end = flat_end();
 1471|    116|  for (const KeyValue* it = std::lower_bound(
 1472|    116|           flat_begin(), end, start_field_number, KeyValue::FirstComparator());
 1473|    116|       it != end && it->first < end_field_number; ++it) {
  ------------------
  |  Branch (1473:8): [True: 0, False: 116]
  |  Branch (1473:21): [True: 0, False: 0]
  ------------------
 1474|      0|    target = it->second.InternalSerializeFieldWithCachedSizesToArray(
 1475|      0|        it->first, target, stream);
 1476|      0|  }
 1477|    116|  return target;
 1478|    116|}
_ZNK6google8protobuf8internal12ExtensionSet8ByteSizeEv:
 1489|    116|size_t ExtensionSet::ByteSize() const {
 1490|    116|  size_t total_size = 0;
 1491|    116|  ForEach([&total_size](int number, const Extension& ext) {
 1492|    116|    total_size += ext.ByteSize(number);
 1493|    116|  });
 1494|    116|  return total_size;
 1495|    116|}

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

_ZNK6google8protobuf8internal14ArenaStringPtr9IsDefaultEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  279|    116|  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|    116|    return tagged_ptr_.UnsafeGet() == default_value;
  285|    116|  }
_ZNK6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE9UnsafeGetEv:
  104|    116|  T* UnsafeGet() const { return static_cast<T*>(ptr_); }
_ZN6google8protobuf8internal14ArenaStringPtr16UnsafeSetDefaultEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  301|    119|inline void ArenaStringPtr::UnsafeSetDefault(const std::string* value) {
  302|    119|  tagged_ptr_.Set(const_cast<std::string*>(value));
  303|    119|}
_ZN6google8protobuf8internal14ArenaStringPtr14DestroyNoArenaEPKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
  356|    116|inline void ArenaStringPtr::DestroyNoArena(const std::string* default_value) {
  357|    116|  if (!IsDefault(default_value)) {
  ------------------
  |  Branch (357:7): [True: 0, False: 116]
  ------------------
  358|      0|    delete UnsafeMutablePointer();
  359|      0|  }
  360|    116|}
_ZN6google8protobuf8internal9TaggedPtrINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEE3SetEPS9_:
   98|    119|  void Set(T* p) { ptr_ = p; }

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

_ZN6google8protobuf8internal10CachedSize3SetEi:
  189|    116|  void Set(int size) { size_.store(size, std::memory_order_relaxed); }
_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|    234|inline void InitSCC(SCCInfoBase* scc) {
  248|    234|  auto status = scc->visit_status.load(std::memory_order_acquire);
  249|    234|  if (PROTOBUF_PREDICT_FALSE(status != SCCInfoBase::kInitialized))
  ------------------
  |  |  247|    234|#define PROTOBUF_PREDICT_FALSE(x) (__builtin_expect(x, 0))
  |  |  ------------------
  |  |  |  Branch (247:35): [True: 3, False: 231]
  |  |  ------------------
  ------------------
  250|      3|    InitSCCImpl(scc);
  251|    234|}
_ZN6google8protobuf8internal24OnShutdownDestroyMessageEPKv:
  256|      2|inline void OnShutdownDestroyMessage(const void* ptr) {
  257|      2|  OnShutdownRun(DestroyMessage, ptr);
  258|      2|}
_ZN6google8protobuf8internal23OnShutdownDestroyStringEPKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  260|      1|inline void OnShutdownDestroyString(const std::string* ptr) {
  261|      1|  OnShutdownRun(DestroyString, ptr);
  262|      1|}

_ZNK6google8protobuf8internal7HasBitsILm1EEixEi:
   60|    232|  const uint32& operator[](int index) const PROTOBUF_ALWAYS_INLINE {
   61|    232|    return has_bits_[index];
   62|    232|  }
_ZN6google8protobuf8internal7HasBitsILm1EEC2Ev:
   50|    118|  constexpr HasBits() PROTOBUF_ALWAYS_INLINE : has_bits_{} {}

_ZN6google8protobuf2io19EpsCopyOutputStreamC2EPvib:
  669|    116|      : end_(static_cast<uint8*>(data) + size),
  670|    116|        buffer_end_(nullptr),
  671|    116|        stream_(nullptr),
  672|    116|        is_serialization_deterministic_(deterministic) {}
_ZN6google8protobuf2io17CodedOutputStream35IsDefaultSerializationDeterministicEv:
 1234|    116|  static bool IsDefaultSerializationDeterministic() {
 1235|    116|    return default_serialization_deterministic_.load(
 1236|    116|               std::memory_order_relaxed) != 0;
 1237|    116|  }

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

_ZN6google8protobuf11MessageLiteC2EPNS0_5ArenaE:
  483|    118|  inline explicit MessageLite(Arena* arena) : _internal_metadata_(arena) {}
_ZN6google8protobuf8internal12ToCachedSizeEm:
   97|    116|inline int ToCachedSize(size_t size) { return static_cast<int>(size); }
_ZN6google8protobuf8internal27GetEmptyStringAlreadyInitedEv:
  173|    235|PROTOBUF_EXPORT constexpr const std::string& GetEmptyStringAlreadyInited() {
  174|    235|  return fixed_address_empty_string.value;
  175|    235|}
_ZN6google8protobuf11MessageLiteD2Ev:
  210|    116|  virtual ~MessageLite() = default;

_ZNK6google8protobuf8internal16InternalMetadata19have_unknown_fieldsEv:
   80|    348|  PROTOBUF_ALWAYS_INLINE bool have_unknown_fields() const {
   81|    348|    return PtrTag() == kTagContainer;
   82|    348|  }
_ZNK6google8protobuf8internal16InternalMetadata6PtrTagEv:
  146|    348|  PROTOBUF_ALWAYS_INLINE int PtrTag() const {
  147|    348|    return reinterpret_cast<intptr_t>(ptr_) & kPtrTagMask;
  148|    348|  }
_ZN6google8protobuf8internal16InternalMetadataC2EPNS0_5ArenaE:
   62|    118|  explicit InternalMetadata(Arena* arena) : ptr_(arena) {}
_ZN6google8protobuf8internal16InternalMetadata6DeleteINSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEvv:
   65|    116|  void Delete() {
   66|       |    // Note that Delete<> should be called not more than once.
   67|    116|    if (have_unknown_fields() && arena() == NULL) {
  ------------------
  |  Branch (67:9): [True: 0, False: 116]
  |  Branch (67:34): [True: 0, False: 0]
  ------------------
   68|      0|      delete PtrValue<Container<T>>();
   69|      0|    }
   70|    116|  }

_ZNK6google8protobuf8internal20RepeatedPtrFieldBase4sizeEv:
 1700|    348|inline int RepeatedPtrFieldBase::size() const { return current_size_; }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE4sizeEv:
 2167|    348|inline int RepeatedPtrField<Element>::size() const {
 2168|    348|  return RepeatedPtrFieldBase::size();
 2169|    348|}
_ZNK6google8protobuf8internal20RepeatedPtrFieldBase8raw_dataEv:
 1857|    232|inline void* const* RepeatedPtrFieldBase::raw_data() const {
 1858|    232|  return rep_ ? rep_->elements : NULL;
  ------------------
  |  Branch (1858:10): [True: 0, False: 232]
  ------------------
 1859|    232|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIN13sentencepiece31SentencePieceText_SentencePieceEEC2EPKPv:
 2432|    232|  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE5beginEv:
 2613|    116|RepeatedPtrField<Element>::begin() const {
 2614|    116|  return iterator(raw_data());
 2615|    116|}
_ZN6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece31SentencePieceText_SentencePieceEEC2IS4_EERKNS2_IT_EE:
 2438|    232|      : it_(other.it_) {
 2439|       |    // Force a compiler error if the other type is not convertible to ours.
 2440|    232|    if (false) {
  ------------------
  |  Branch (2440:9): [Folded, False: 232]
  ------------------
 2441|      0|      implicit_cast<Element*>(static_cast<OtherElement*>(nullptr));
 2442|      0|    }
 2443|    232|  }
_ZNK6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE3endEv:
 2628|    116|RepeatedPtrField<Element>::end() const {
 2629|    116|  return iterator(raw_data() + size());
 2630|    116|}
_ZNK6google8protobuf8internal19RepeatedPtrIteratorIKN13sentencepiece31SentencePieceText_SentencePieceEEneERKS6_:
 2463|    116|  bool operator!=(const iterator& x) const { return it_ != x.it_; }
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseD2Ev:
  582|    116|  ~RepeatedPtrFieldBase() {
  583|       |#ifndef NDEBUG
  584|       |    // Try to trigger segfault / asan failure in non-opt builds. If arena_
  585|       |    // lifetime has ended before the destructor.
  586|       |    if (arena_) (void)arena_->SpaceAllocated();
  587|       |#endif
  588|    116|  }
_ZN6google8protobuf8internal20RepeatedPtrFieldBaseC2EPNS0_5ArenaE:
 1654|    117|    : arena_(arena), current_size_(0), total_size_(0), rep_(NULL) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEEC2EPNS0_5ArenaE:
 2098|    117|    : RepeatedPtrFieldBase(arena) {}
_ZN6google8protobuf16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEED2Ev:
 2121|    116|RepeatedPtrField<Element>::~RepeatedPtrField() {
 2122|    116|  Destroy<TypeHandler>();
 2123|    116|}
_ZN6google8protobuf8internal20RepeatedPtrFieldBase7DestroyINS0_16RepeatedPtrFieldIN13sentencepiece31SentencePieceText_SentencePieceEE11TypeHandlerEEEvv:
 1657|    116|void RepeatedPtrFieldBase::Destroy() {
 1658|    116|  if (rep_ != NULL && arena_ == NULL) {
  ------------------
  |  Branch (1658:7): [True: 0, False: 116]
  |  Branch (1658:23): [True: 0, False: 0]
  ------------------
 1659|      0|    int n = rep_->allocated_size;
 1660|      0|    void* const* elements = rep_->elements;
 1661|      0|    for (int i = 0; i < n; i++) {
  ------------------
  |  Branch (1661:21): [True: 0, False: 0]
  ------------------
 1662|      0|      TypeHandler::Delete(cast<TypeHandler>(elements[i]), NULL);
 1663|      0|    }
 1664|      0|#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
 1665|      0|    const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
 1666|      0|    ::operator delete(static_cast<void*>(rep_), size);
 1667|       |#else
 1668|       |    ::operator delete(static_cast<void*>(rep_));
 1669|       |#endif
 1670|      0|  }
 1671|       |  rep_ = NULL;
 1672|    116|}

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

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

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

_ZNK6google8protobuf11MessageLite14AppendToStringEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  448|    116|bool MessageLite::AppendToString(std::string* output) const {
  449|    116|  GOOGLE_DCHECK(IsInitialized()) << InitializationErrorMessage("serialize", *this);
  ------------------
  |  |  181|    116|#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: 116]
  |  |  ------------------
  ------------------
  450|    116|  return AppendPartialToString(output);
  451|    116|}
_ZNK6google8protobuf11MessageLite21AppendPartialToStringEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  453|    116|bool MessageLite::AppendPartialToString(std::string* output) const {
  454|    116|  size_t old_size = output->size();
  455|    116|  size_t byte_size = ByteSizeLong();
  456|    116|  if (byte_size > INT_MAX) {
  ------------------
  |  Branch (456:7): [True: 0, False: 116]
  ------------------
  457|      0|    GOOGLE_LOG(ERROR) << GetTypeName()
  ------------------
  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  ------------------
  458|      0|               << " exceeded maximum protobuf size of 2GB: " << byte_size;
  459|      0|    return false;
  460|      0|  }
  461|       |
  462|    116|  STLStringResizeUninitialized(output, old_size + byte_size);
  463|    116|  uint8* start =
  464|    116|      reinterpret_cast<uint8*>(io::mutable_string_data(output) + old_size);
  465|    116|  SerializeToArrayImpl(*this, start, byte_size);
  466|    116|  return true;
  467|    116|}
_ZNK6google8protobuf11MessageLite17SerializeAsStringEv:
  497|    116|std::string MessageLite::SerializeAsString() const {
  498|       |  // If the compiler implements the (Named) Return Value Optimization,
  499|       |  // the local variable 'output' will not actually reside on the stack
  500|       |  // of this function, but will be overlaid with the object that the
  501|       |  // caller supplied for the return value to be constructed in.
  502|    116|  std::string output;
  503|    116|  if (!AppendToString(&output)) output.clear();
  ------------------
  |  Branch (503:7): [True: 0, False: 116]
  ------------------
  504|    116|  return output;
  505|    116|}
_ZN6google8protobuf8internal13OnShutdownRunEPFvPKvES3_:
  564|      3|void OnShutdownRun(void (*f)(const void*), const void* arg) {
  565|      3|  auto shutdown_data = ShutdownData::get();
  566|      3|  MutexLock lock(&shutdown_data->mutex);
  567|      3|  shutdown_data->functions.push_back(std::make_pair(f, arg));
  568|      3|}
_ZN6google8protobuf20SerializeToArrayImplERKNS0_11MessageLiteEPhi:
  340|    116|                                   int size) {
  341|    116|  constexpr bool debug = false;
  342|    116|  if (debug) {
  ------------------
  |  Branch (342:7): [Folded, False: 116]
  ------------------
  343|       |    // Force serialization to a stream with a block size of 1, which forces
  344|       |    // all writes to the stream to cross buffers triggering all fallback paths
  345|       |    // in the unittests when serializing to string / array.
  346|      0|    io::ArrayOutputStream stream(target, size, 1);
  347|      0|    uint8* ptr;
  348|      0|    io::EpsCopyOutputStream out(
  349|      0|        &stream, io::CodedOutputStream::IsDefaultSerializationDeterministic(),
  350|      0|        &ptr);
  351|      0|    ptr = msg._InternalSerialize(ptr, &out);
  352|      0|    out.Trim(ptr);
  353|      0|    GOOGLE_DCHECK(!out.HadError() && stream.ByteCount() == size);
  ------------------
  |  |  181|      0|#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
  |  |  ------------------
  |  |  |  |  154|      0|  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
  |  |  |  |  ------------------
  |  |  |  |  |  |  151|      0|  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  |  147|      0|  ::google::protobuf::internal::LogFinisher() = \
  |  |  |  |  |  |  |  |  148|      0|      ::google::protobuf::internal::LogMessage( \
  |  |  |  |  |  |  |  |  149|      0|          ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
  |  |  |  |  |  |  ------------------
  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  |  Branch (151:5): [True: 0, False: 0]
  |  |  |  |  |  |  ------------------
  |  |  |  |  ------------------
  |  |  ------------------
  |  |  |  Branch (181:41): [Folded, False: 0]
  |  |  ------------------
  ------------------
  354|      0|    return target + size;
  355|    116|  } else {
  356|    116|    io::EpsCopyOutputStream out(
  357|    116|        target, size,
  358|    116|        io::CodedOutputStream::IsDefaultSerializationDeterministic());
  359|    116|    auto res = msg._InternalSerialize(target, &out);
  360|    116|    GOOGLE_DCHECK(target + size == res);
  ------------------
  |  |  181|    116|#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: 116]
  |  |  ------------------
  ------------------
  361|    116|    return res;
  362|    116|  }
  363|    116|}
_ZN6google8protobuf8internal12ShutdownData3getEv:
  546|      3|  static ShutdownData* get() {
  547|      3|    static auto* data = new ShutdownData;
  548|      3|    return data;
  549|      3|  }

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

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