// Generated by the protocol buffer compiler.  DO NOT EDIT!
// NO CHECKED-IN PROTOBUF GENCODE
// source: sentencepiece_model.proto
// Protobuf C++ Version: 7.35.1

#ifndef sentencepiece_5fmodel_2eproto_2epb_2eh
#define sentencepiece_5fmodel_2eproto_2epb_2eh

#include <limits>
#include <string>
#include <type_traits>
#include <utility>

// clang-format off
#include "google/protobuf/runtime_version.h"
#if PROTOBUF_VERSION != 7035001
#error "Protobuf C++ gencode is built with an incompatible version of"
#error "Protobuf C++ headers/runtime. See"
#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp"
#endif
#include "google/protobuf/io/coded_stream.h"
#include "google/protobuf/arena.h"
#include "google/protobuf/arenastring.h"
#include "google/protobuf/generated_message_tctable_decl.h"
#include "google/protobuf/generated_message_util.h"
#include "google/protobuf/metadata_lite.h"
#include "google/protobuf/message_lite.h"
#include "google/protobuf/repeated_field.h"  // IWYU pragma: export
#include "google/protobuf/extension_set.h"  // IWYU pragma: export
#include "google/protobuf/generated_enum_util.h"
// @@protoc_insertion_point(includes)

// Must be included last.
#include "google/protobuf/port_def.inc"

#define PROTOBUF_INTERNAL_EXPORT_sentencepiece_5fmodel_2eproto

namespace google {
namespace protobuf {
namespace internal {
template <typename T>
::absl::string_view GetAnyMessageName();
}  // namespace internal
}  // namespace protobuf
}  // namespace google

// Internal implementation detail -- do not use these members.
struct TableStruct_sentencepiece_5fmodel_2eproto {
  static const ::uint32_t offsets[];
};
namespace sentencepiece {
enum ModelProto_SentencePiece_Type : int;
extern const uint32_t ModelProto_SentencePiece_Type_internal_data_[];
enum TrainerSpec_ModelType : int;
extern const uint32_t TrainerSpec_ModelType_internal_data_[];
class ModelProto;
struct ModelProtoGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ModelProtoGlobalsTypeInternal ModelProto_globals_;
extern const ::google::protobuf::internal::ClassDataLite ModelProto_class_data_;
#else
extern const ModelProtoGlobalsTypeInternal ModelProto_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class ModelProto_SentencePiece;
struct ModelProto_SentencePieceGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern ModelProto_SentencePieceGlobalsTypeInternal ModelProto_SentencePiece_globals_;
extern const ::google::protobuf::internal::ClassDataLite ModelProto_SentencePiece_class_data_;
#else
extern const ModelProto_SentencePieceGlobalsTypeInternal ModelProto_SentencePiece_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class NormalizerSpec;
struct NormalizerSpecGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern NormalizerSpecGlobalsTypeInternal NormalizerSpec_globals_;
extern const ::google::protobuf::internal::ClassDataLite NormalizerSpec_class_data_;
#else
extern const NormalizerSpecGlobalsTypeInternal NormalizerSpec_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class SelfTestData;
struct SelfTestDataGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern SelfTestDataGlobalsTypeInternal SelfTestData_globals_;
extern const ::google::protobuf::internal::ClassDataLite SelfTestData_class_data_;
#else
extern const SelfTestDataGlobalsTypeInternal SelfTestData_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class SelfTestData_Sample;
struct SelfTestData_SampleGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern SelfTestData_SampleGlobalsTypeInternal SelfTestData_Sample_globals_;
extern const ::google::protobuf::internal::ClassDataLite SelfTestData_Sample_class_data_;
#else
extern const SelfTestData_SampleGlobalsTypeInternal SelfTestData_Sample_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
class TrainerSpec;
struct TrainerSpecGlobalsTypeInternal;
#ifndef PROTOBUF_MESSAGE_GLOBALS
extern TrainerSpecGlobalsTypeInternal TrainerSpec_globals_;
extern const ::google::protobuf::internal::ClassDataLite TrainerSpec_class_data_;
#else
extern const TrainerSpecGlobalsTypeInternal TrainerSpec_globals_;
#endif  // PROTOBUF_MESSAGE_GLOBALS
}  // namespace sentencepiece
namespace google {
namespace protobuf {
template <>
internal::EnumTraitsT<::sentencepiece::ModelProto_SentencePiece_Type_internal_data_>
    internal::EnumTraitsImpl::value<::sentencepiece::ModelProto_SentencePiece_Type>;
template <>
internal::EnumTraitsT<::sentencepiece::TrainerSpec_ModelType_internal_data_>
    internal::EnumTraitsImpl::value<::sentencepiece::TrainerSpec_ModelType>;
}  // namespace protobuf
}  // namespace google

namespace sentencepiece {
enum TrainerSpec_ModelType : int {
  TrainerSpec_ModelType_UNIGRAM = 1,
  TrainerSpec_ModelType_BPE = 2,
  TrainerSpec_ModelType_WORD = 3,
  TrainerSpec_ModelType_CHAR = 4,
};

extern const uint32_t TrainerSpec_ModelType_internal_data_[];
inline constexpr TrainerSpec_ModelType TrainerSpec_ModelType_ModelType_MIN =
    static_cast<TrainerSpec_ModelType>(1);
inline constexpr TrainerSpec_ModelType TrainerSpec_ModelType_ModelType_MAX =
    static_cast<TrainerSpec_ModelType>(4);
[[nodiscard]] inline bool TrainerSpec_ModelType_IsValid(int value) {
  return 1 <= value && value <= 4;
}
inline constexpr int TrainerSpec_ModelType_ModelType_ARRAYSIZE = 4 + 1;
[[nodiscard]] const ::std::string& TrainerSpec_ModelType_Name(TrainerSpec_ModelType value);
template <typename T>
[[nodiscard]] const ::std::string& TrainerSpec_ModelType_Name(T value) {
  static_assert(::std::is_same<T, TrainerSpec_ModelType>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to ModelType_Name().");
  return TrainerSpec_ModelType_Name(static_cast<TrainerSpec_ModelType>(value));
}
[[nodiscard]] bool TrainerSpec_ModelType_Parse(
    ::absl::string_view name, TrainerSpec_ModelType* PROTOBUF_NONNULL value);
enum ModelProto_SentencePiece_Type : int {
  ModelProto_SentencePiece_Type_NORMAL = 1,
  ModelProto_SentencePiece_Type_UNKNOWN = 2,
  ModelProto_SentencePiece_Type_CONTROL = 3,
  ModelProto_SentencePiece_Type_USER_DEFINED = 4,
  ModelProto_SentencePiece_Type_BYTE = 6,
  ModelProto_SentencePiece_Type_UNUSED = 5,
};

extern const uint32_t ModelProto_SentencePiece_Type_internal_data_[];
inline constexpr ModelProto_SentencePiece_Type ModelProto_SentencePiece_Type_Type_MIN =
    static_cast<ModelProto_SentencePiece_Type>(1);
inline constexpr ModelProto_SentencePiece_Type ModelProto_SentencePiece_Type_Type_MAX =
    static_cast<ModelProto_SentencePiece_Type>(6);
[[nodiscard]] inline bool ModelProto_SentencePiece_Type_IsValid(int value) {
  return 1 <= value && value <= 6;
}
inline constexpr int ModelProto_SentencePiece_Type_Type_ARRAYSIZE = 6 + 1;
[[nodiscard]] const ::std::string& ModelProto_SentencePiece_Type_Name(ModelProto_SentencePiece_Type value);
template <typename T>
[[nodiscard]] const ::std::string& ModelProto_SentencePiece_Type_Name(T value) {
  static_assert(::std::is_same<T, ModelProto_SentencePiece_Type>::value ||
                    ::std::is_integral<T>::value,
                "Incorrect type passed to Type_Name().");
  return ModelProto_SentencePiece_Type_Name(static_cast<ModelProto_SentencePiece_Type>(value));
}
[[nodiscard]] bool ModelProto_SentencePiece_Type_Parse(
    ::absl::string_view name, ModelProto_SentencePiece_Type* PROTOBUF_NONNULL value);
using ::google::protobuf::internal::generated_enum::AbslParseFlag;
using ::google::protobuf::internal::generated_enum::AbslUnparseFlag;

// ===================================================================


// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED TrainerSpec final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:sentencepiece.TrainerSpec) */ {
 public:
  inline TrainerSpec() : TrainerSpec(nullptr) {}
  ~TrainerSpec() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(TrainerSpec* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(TrainerSpec));
  }
#endif

  template <typename = void>
  explicit constexpr TrainerSpec(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline TrainerSpec(const TrainerSpec& from) : TrainerSpec(nullptr, from) {}
  inline TrainerSpec(TrainerSpec&& from) noexcept : TrainerSpec(nullptr, ::std::move(from)) {}
  inline TrainerSpec& operator=(const TrainerSpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline TrainerSpec& operator=(TrainerSpec&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const TrainerSpec& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<TrainerSpec>(&TrainerSpec_globals_);
  }
  static constexpr int kIndexInFileMessages = 0;
  friend void swap(TrainerSpec& a, TrainerSpec& b) { a.Swap(&b); }
  inline void Swap(TrainerSpec* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(TrainerSpec* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] TrainerSpec* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<TrainerSpec>(arena);
  }
  void CopyFrom(const TrainerSpec& from);
  void MergeFrom(const TrainerSpec& from) { TrainerSpec::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(TrainerSpec* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "sentencepiece.TrainerSpec"; }

  explicit TrainerSpec(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  TrainerSpec(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TrainerSpec& from);
  TrainerSpec(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TrainerSpec&& from) noexcept
      : TrainerSpec(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  // nested types ----------------------------------------------------
  using ModelType = TrainerSpec_ModelType;
  static constexpr ModelType UNIGRAM = TrainerSpec_ModelType_UNIGRAM;
  static constexpr ModelType BPE = TrainerSpec_ModelType_BPE;
  static constexpr ModelType WORD = TrainerSpec_ModelType_WORD;
  static constexpr ModelType CHAR = TrainerSpec_ModelType_CHAR;
  [[nodiscard]] static inline bool ModelType_IsValid(int value) {
    return TrainerSpec_ModelType_IsValid(value);
  }
  static constexpr ModelType ModelType_MIN = TrainerSpec_ModelType_ModelType_MIN;
  static constexpr ModelType ModelType_MAX = TrainerSpec_ModelType_ModelType_MAX;
  static constexpr int ModelType_ARRAYSIZE = TrainerSpec_ModelType_ModelType_ARRAYSIZE;
  template <typename T>
  [[nodiscard]] static inline const ::std::string& ModelType_Name(T value) {
    return TrainerSpec_ModelType_Name(value);
  }
  [[nodiscard]] static inline bool ModelType_Parse(
      ::absl::string_view name, ModelType* PROTOBUF_NONNULL value) {
    return TrainerSpec_ModelType_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kInputFieldNumber = 1,
    kAcceptLanguageFieldNumber = 5,
    kControlSymbolsFieldNumber = 30,
    kUserDefinedSymbolsFieldNumber = 31,
    kModelPrefixFieldNumber = 2,
    kInputFormatFieldNumber = 7,
    kUnkSurfaceFieldNumber = 44,
    kUnkPieceFieldNumber = 45,
    kSelfTestSampleSizeFieldNumber = 6,
    kMiningSentenceSizeFieldNumber = 12,
    kInputSentenceSizeFieldNumber = 11,
    kTrainingSentenceSizeFieldNumber = 13,
    kTreatWhitespaceAsSuffixFieldNumber = 24,
    kSplitDigitsFieldNumber = 25,
    kAllowWhitespaceOnlyPiecesFieldNumber = 26,
    kModelTypeFieldNumber = 3,
    kVocabSizeFieldNumber = 4,
    kCharacterCoverageFieldNumber = 10,
    kSeedSentencepieceSizeFieldNumber = 14,
    kShrinkingFactorFieldNumber = 15,
    kNumThreadsFieldNumber = 16,
    kNumSubIterationsFieldNumber = 17,
    kMaxSentenceLengthFieldNumber = 18,
    kMaxSentencepieceLengthFieldNumber = 20,
    kShuffleInputSentenceFieldNumber = 19,
    kSplitByUnicodeScriptFieldNumber = 21,
    kSplitByWhitespaceFieldNumber = 22,
    kSplitByNumberFieldNumber = 23,
    kPadIdFieldNumber = 43,
    kRequiredCharsFieldNumber = 36,
    kBosPieceFieldNumber = 46,
    kEosPieceFieldNumber = 47,
    kPadPieceFieldNumber = 48,
    kPretokenizationDelimiterFieldNumber = 53,
    kSeedSentencepiecesFileFieldNumber = 54,
    kUnkIdFieldNumber = 40,
    kUseAllVocabFieldNumber = 34,
    kByteFallbackFieldNumber = 35,
    kTrainExtremelyLargeCorpusFieldNumber = 49,
    kEnableDifferentialPrivacyFieldNumber = 50,
    kDifferentialPrivacyClippingThresholdFieldNumber = 52,
    kDifferentialPrivacyNoiseLevelFieldNumber = 51,
    kEosIdFieldNumber = 42,
    kVocabularyOutputPieceScoreFieldNumber = 32,
    kHardVocabLimitFieldNumber = 33,
    kBosIdFieldNumber = 41,
  };
  // repeated string input = 1;
  [[nodiscard]] int input_size()
      const;
  private:
  int _internal_input_size() const;

  public:
  void clear_input() ;
  [[nodiscard]] const ::std::string& input(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_input(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_input(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_input();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_input(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      input() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_input();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_input() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_input();

  public:
  // repeated string accept_language = 5;
  [[nodiscard]] int accept_language_size()
      const;
  private:
  int _internal_accept_language_size() const;

  public:
  void clear_accept_language() ;
  [[nodiscard]] const ::std::string& accept_language(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_accept_language(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_accept_language(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_accept_language();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_accept_language(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      accept_language() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_accept_language();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_accept_language() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_accept_language();

  public:
  // repeated string control_symbols = 30;
  [[nodiscard]] int control_symbols_size()
      const;
  private:
  int _internal_control_symbols_size() const;

  public:
  void clear_control_symbols() ;
  [[nodiscard]] const ::std::string& control_symbols(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_control_symbols(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_control_symbols(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_control_symbols();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_control_symbols(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      control_symbols() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_control_symbols();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_control_symbols() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_control_symbols();

  public:
  // repeated string user_defined_symbols = 31;
  [[nodiscard]] int user_defined_symbols_size()
      const;
  private:
  int _internal_user_defined_symbols_size() const;

  public:
  void clear_user_defined_symbols() ;
  [[nodiscard]] const ::std::string& user_defined_symbols(int index) const;
  ::std::string* PROTOBUF_NONNULL mutable_user_defined_symbols(int index);
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_user_defined_symbols(int index, Arg_&& value, Args_... args);
  ::std::string* PROTOBUF_NONNULL add_user_defined_symbols();
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void add_user_defined_symbols(Arg_&& value, Args_... args);
  [[nodiscard]] const
      ::google::protobuf::RepeatedPtrField<::std::string>&
      user_defined_symbols() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::std::string>*
      PROTOBUF_NONNULL
      mutable_user_defined_symbols();

  private:
  const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_user_defined_symbols() const;
  ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_user_defined_symbols();

  public:
  // optional string model_prefix = 2;
  [[nodiscard]] bool has_model_prefix()
      const;
  void clear_model_prefix() ;
  [[nodiscard]] const ::std::string& model_prefix() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_model_prefix(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_model_prefix();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_model_prefix();
  void set_allocated_model_prefix(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_model_prefix() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_model_prefix(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_model_prefix();

  public:
  // optional string input_format = 7;
  [[nodiscard]] bool has_input_format()
      const;
  void clear_input_format() ;
  [[nodiscard]] const ::std::string& input_format() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_input_format(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_input_format();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_input_format();
  void set_allocated_input_format(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_input_format() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_input_format(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_input_format();

  public:
  // optional string unk_surface = 44 [default = " \342\201\207 "];
  [[nodiscard]] bool has_unk_surface()
      const;
  void clear_unk_surface() ;
  [[nodiscard]] const ::std::string& unk_surface() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_unk_surface(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_unk_surface();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_unk_surface();
  void set_allocated_unk_surface(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_unk_surface() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_unk_surface(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_unk_surface();

  public:
  // optional string unk_piece = 45 [default = "<unk>"];
  [[nodiscard]] bool has_unk_piece()
      const;
  void clear_unk_piece() ;
  [[nodiscard]] const ::std::string& unk_piece() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_unk_piece(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_unk_piece();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_unk_piece();
  void set_allocated_unk_piece(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_unk_piece() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_unk_piece(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_unk_piece();

  public:
  // optional int32 self_test_sample_size = 6 [default = 0];
  [[nodiscard]] bool has_self_test_sample_size()
      const;
  void clear_self_test_sample_size() ;
  [[nodiscard]] ::int32_t self_test_sample_size() const;
  void set_self_test_sample_size(::int32_t value);

  private:
  ::int32_t _internal_self_test_sample_size() const;
  void _internal_set_self_test_sample_size(::int32_t value);

  public:
  // optional int32 mining_sentence_size = 12 [deprecated = true];
  [[nodiscard]] [[deprecated]]  bool has_mining_sentence_size()
      const;
  [[deprecated]]  void clear_mining_sentence_size() ;
  [[nodiscard]] [[deprecated]] ::int32_t mining_sentence_size() const;
  [[deprecated]] void set_mining_sentence_size(::int32_t value);

  private:
  ::int32_t _internal_mining_sentence_size() const;
  void _internal_set_mining_sentence_size(::int32_t value);

  public:
  // optional uint64 input_sentence_size = 11 [default = 0];
  [[nodiscard]] bool has_input_sentence_size()
      const;
  void clear_input_sentence_size() ;
  [[nodiscard]] ::uint64_t input_sentence_size() const;
  void set_input_sentence_size(::uint64_t value);

  private:
  ::uint64_t _internal_input_sentence_size() const;
  void _internal_set_input_sentence_size(::uint64_t value);

  public:
  // optional int32 training_sentence_size = 13 [deprecated = true];
  [[nodiscard]] [[deprecated]]  bool has_training_sentence_size()
      const;
  [[deprecated]]  void clear_training_sentence_size() ;
  [[nodiscard]] [[deprecated]] ::int32_t training_sentence_size() const;
  [[deprecated]] void set_training_sentence_size(::int32_t value);

  private:
  ::int32_t _internal_training_sentence_size() const;
  void _internal_set_training_sentence_size(::int32_t value);

  public:
  // optional bool treat_whitespace_as_suffix = 24 [default = false];
  [[nodiscard]] bool has_treat_whitespace_as_suffix()
      const;
  void clear_treat_whitespace_as_suffix() ;
  [[nodiscard]] bool treat_whitespace_as_suffix() const;
  void set_treat_whitespace_as_suffix(bool value);

  private:
  bool _internal_treat_whitespace_as_suffix() const;
  void _internal_set_treat_whitespace_as_suffix(bool value);

  public:
  // optional bool split_digits = 25 [default = false];
  [[nodiscard]] bool has_split_digits()
      const;
  void clear_split_digits() ;
  [[nodiscard]] bool split_digits() const;
  void set_split_digits(bool value);

  private:
  bool _internal_split_digits() const;
  void _internal_set_split_digits(bool value);

  public:
  // optional bool allow_whitespace_only_pieces = 26 [default = false];
  [[nodiscard]] bool has_allow_whitespace_only_pieces()
      const;
  void clear_allow_whitespace_only_pieces() ;
  [[nodiscard]] bool allow_whitespace_only_pieces() const;
  void set_allow_whitespace_only_pieces(bool value);

  private:
  bool _internal_allow_whitespace_only_pieces() const;
  void _internal_set_allow_whitespace_only_pieces(bool value);

  public:
  // optional .sentencepiece.TrainerSpec.ModelType model_type = 3 [default = UNIGRAM];
  [[nodiscard]] bool has_model_type()
      const;
  void clear_model_type() ;
  [[nodiscard]] ::sentencepiece::TrainerSpec_ModelType model_type() const;
  void set_model_type(::sentencepiece::TrainerSpec_ModelType value);

  private:
  ::sentencepiece::TrainerSpec_ModelType _internal_model_type() const;
  void _internal_set_model_type(::sentencepiece::TrainerSpec_ModelType value);

  public:
  // optional int32 vocab_size = 4 [default = 8000];
  [[nodiscard]] bool has_vocab_size()
      const;
  void clear_vocab_size() ;
  [[nodiscard]] ::int32_t vocab_size() const;
  void set_vocab_size(::int32_t value);

  private:
  ::int32_t _internal_vocab_size() const;
  void _internal_set_vocab_size(::int32_t value);

  public:
  // optional float character_coverage = 10 [default = 0.9995];
  [[nodiscard]] bool has_character_coverage()
      const;
  void clear_character_coverage() ;
  [[nodiscard]] float character_coverage() const;
  void set_character_coverage(float value);

  private:
  float _internal_character_coverage() const;
  void _internal_set_character_coverage(float value);

  public:
  // optional int32 seed_sentencepiece_size = 14 [default = 1000000];
  [[nodiscard]] bool has_seed_sentencepiece_size()
      const;
  void clear_seed_sentencepiece_size() ;
  [[nodiscard]] ::int32_t seed_sentencepiece_size() const;
  void set_seed_sentencepiece_size(::int32_t value);

  private:
  ::int32_t _internal_seed_sentencepiece_size() const;
  void _internal_set_seed_sentencepiece_size(::int32_t value);

  public:
  // optional float shrinking_factor = 15 [default = 0.75];
  [[nodiscard]] bool has_shrinking_factor()
      const;
  void clear_shrinking_factor() ;
  [[nodiscard]] float shrinking_factor() const;
  void set_shrinking_factor(float value);

  private:
  float _internal_shrinking_factor() const;
  void _internal_set_shrinking_factor(float value);

  public:
  // optional int32 num_threads = 16 [default = 16];
  [[nodiscard]] bool has_num_threads()
      const;
  void clear_num_threads() ;
  [[nodiscard]] ::int32_t num_threads() const;
  void set_num_threads(::int32_t value);

  private:
  ::int32_t _internal_num_threads() const;
  void _internal_set_num_threads(::int32_t value);

  public:
  // optional int32 num_sub_iterations = 17 [default = 2];
  [[nodiscard]] bool has_num_sub_iterations()
      const;
  void clear_num_sub_iterations() ;
  [[nodiscard]] ::int32_t num_sub_iterations() const;
  void set_num_sub_iterations(::int32_t value);

  private:
  ::int32_t _internal_num_sub_iterations() const;
  void _internal_set_num_sub_iterations(::int32_t value);

  public:
  // optional int32 max_sentence_length = 18 [default = 4192];
  [[nodiscard]] bool has_max_sentence_length()
      const;
  void clear_max_sentence_length() ;
  [[nodiscard]] ::int32_t max_sentence_length() const;
  void set_max_sentence_length(::int32_t value);

  private:
  ::int32_t _internal_max_sentence_length() const;
  void _internal_set_max_sentence_length(::int32_t value);

  public:
  // optional int32 max_sentencepiece_length = 20 [default = 16];
  [[nodiscard]] bool has_max_sentencepiece_length()
      const;
  void clear_max_sentencepiece_length() ;
  [[nodiscard]] ::int32_t max_sentencepiece_length() const;
  void set_max_sentencepiece_length(::int32_t value);

  private:
  ::int32_t _internal_max_sentencepiece_length() const;
  void _internal_set_max_sentencepiece_length(::int32_t value);

  public:
  // optional bool shuffle_input_sentence = 19 [default = true];
  [[nodiscard]] bool has_shuffle_input_sentence()
      const;
  void clear_shuffle_input_sentence() ;
  [[nodiscard]] bool shuffle_input_sentence() const;
  void set_shuffle_input_sentence(bool value);

  private:
  bool _internal_shuffle_input_sentence() const;
  void _internal_set_shuffle_input_sentence(bool value);

  public:
  // optional bool split_by_unicode_script = 21 [default = true];
  [[nodiscard]] bool has_split_by_unicode_script()
      const;
  void clear_split_by_unicode_script() ;
  [[nodiscard]] bool split_by_unicode_script() const;
  void set_split_by_unicode_script(bool value);

  private:
  bool _internal_split_by_unicode_script() const;
  void _internal_set_split_by_unicode_script(bool value);

  public:
  // optional bool split_by_whitespace = 22 [default = true];
  [[nodiscard]] bool has_split_by_whitespace()
      const;
  void clear_split_by_whitespace() ;
  [[nodiscard]] bool split_by_whitespace() const;
  void set_split_by_whitespace(bool value);

  private:
  bool _internal_split_by_whitespace() const;
  void _internal_set_split_by_whitespace(bool value);

  public:
  // optional bool split_by_number = 23 [default = true];
  [[nodiscard]] bool has_split_by_number()
      const;
  void clear_split_by_number() ;
  [[nodiscard]] bool split_by_number() const;
  void set_split_by_number(bool value);

  private:
  bool _internal_split_by_number() const;
  void _internal_set_split_by_number(bool value);

  public:
  // optional int32 pad_id = 43 [default = -1];
  [[nodiscard]] bool has_pad_id()
      const;
  void clear_pad_id() ;
  [[nodiscard]] ::int32_t pad_id() const;
  void set_pad_id(::int32_t value);

  private:
  ::int32_t _internal_pad_id() const;
  void _internal_set_pad_id(::int32_t value);

  public:
  // optional string required_chars = 36;
  [[nodiscard]] bool has_required_chars()
      const;
  void clear_required_chars() ;
  [[nodiscard]] const ::std::string& required_chars() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_required_chars(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_required_chars();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_required_chars();
  void set_allocated_required_chars(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_required_chars() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_required_chars(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_required_chars();

  public:
  // optional string bos_piece = 46 [default = "<s>"];
  [[nodiscard]] bool has_bos_piece()
      const;
  void clear_bos_piece() ;
  [[nodiscard]] const ::std::string& bos_piece() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_bos_piece(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_bos_piece();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_bos_piece();
  void set_allocated_bos_piece(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_bos_piece() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_bos_piece(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_bos_piece();

  public:
  // optional string eos_piece = 47 [default = "</s>"];
  [[nodiscard]] bool has_eos_piece()
      const;
  void clear_eos_piece() ;
  [[nodiscard]] const ::std::string& eos_piece() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_eos_piece(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_eos_piece();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_eos_piece();
  void set_allocated_eos_piece(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_eos_piece() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_eos_piece(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_eos_piece();

  public:
  // optional string pad_piece = 48 [default = "<pad>"];
  [[nodiscard]] bool has_pad_piece()
      const;
  void clear_pad_piece() ;
  [[nodiscard]] const ::std::string& pad_piece() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_pad_piece(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_pad_piece();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_pad_piece();
  void set_allocated_pad_piece(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_pad_piece() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_pad_piece(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_pad_piece();

  public:
  // optional string pretokenization_delimiter = 53 [default = ""];
  [[nodiscard]] bool has_pretokenization_delimiter()
      const;
  void clear_pretokenization_delimiter() ;
  [[nodiscard]] const ::std::string& pretokenization_delimiter() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_pretokenization_delimiter(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_pretokenization_delimiter();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_pretokenization_delimiter();
  void set_allocated_pretokenization_delimiter(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_pretokenization_delimiter() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_pretokenization_delimiter(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_pretokenization_delimiter();

  public:
  // optional string seed_sentencepieces_file = 54 [default = ""];
  [[nodiscard]] bool has_seed_sentencepieces_file()
      const;
  void clear_seed_sentencepieces_file() ;
  [[nodiscard]] const ::std::string& seed_sentencepieces_file() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_seed_sentencepieces_file(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_seed_sentencepieces_file();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_seed_sentencepieces_file();
  void set_allocated_seed_sentencepieces_file(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_seed_sentencepieces_file() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_seed_sentencepieces_file(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_seed_sentencepieces_file();

  public:
  // optional int32 unk_id = 40 [default = 0];
  [[nodiscard]] bool has_unk_id()
      const;
  void clear_unk_id() ;
  [[nodiscard]] ::int32_t unk_id() const;
  void set_unk_id(::int32_t value);

  private:
  ::int32_t _internal_unk_id() const;
  void _internal_set_unk_id(::int32_t value);

  public:
  // optional bool use_all_vocab = 34 [default = false];
  [[nodiscard]] bool has_use_all_vocab()
      const;
  void clear_use_all_vocab() ;
  [[nodiscard]] bool use_all_vocab() const;
  void set_use_all_vocab(bool value);

  private:
  bool _internal_use_all_vocab() const;
  void _internal_set_use_all_vocab(bool value);

  public:
  // optional bool byte_fallback = 35 [default = false];
  [[nodiscard]] bool has_byte_fallback()
      const;
  void clear_byte_fallback() ;
  [[nodiscard]] bool byte_fallback() const;
  void set_byte_fallback(bool value);

  private:
  bool _internal_byte_fallback() const;
  void _internal_set_byte_fallback(bool value);

  public:
  // optional bool train_extremely_large_corpus = 49 [default = false];
  [[nodiscard]] bool has_train_extremely_large_corpus()
      const;
  void clear_train_extremely_large_corpus() ;
  [[nodiscard]] bool train_extremely_large_corpus() const;
  void set_train_extremely_large_corpus(bool value);

  private:
  bool _internal_train_extremely_large_corpus() const;
  void _internal_set_train_extremely_large_corpus(bool value);

  public:
  // optional bool enable_differential_privacy = 50 [default = false];
  [[nodiscard]] bool has_enable_differential_privacy()
      const;
  void clear_enable_differential_privacy() ;
  [[nodiscard]] bool enable_differential_privacy() const;
  void set_enable_differential_privacy(bool value);

  private:
  bool _internal_enable_differential_privacy() const;
  void _internal_set_enable_differential_privacy(bool value);

  public:
  // optional uint64 differential_privacy_clipping_threshold = 52 [default = 0];
  [[nodiscard]] bool has_differential_privacy_clipping_threshold()
      const;
  void clear_differential_privacy_clipping_threshold() ;
  [[nodiscard]] ::uint64_t differential_privacy_clipping_threshold() const;
  void set_differential_privacy_clipping_threshold(::uint64_t value);

  private:
  ::uint64_t _internal_differential_privacy_clipping_threshold() const;
  void _internal_set_differential_privacy_clipping_threshold(::uint64_t value);

  public:
  // optional float differential_privacy_noise_level = 51 [default = 0];
  [[nodiscard]] bool has_differential_privacy_noise_level()
      const;
  void clear_differential_privacy_noise_level() ;
  [[nodiscard]] float differential_privacy_noise_level() const;
  void set_differential_privacy_noise_level(float value);

  private:
  float _internal_differential_privacy_noise_level() const;
  void _internal_set_differential_privacy_noise_level(float value);

  public:
  // optional int32 eos_id = 42 [default = 2];
  [[nodiscard]] bool has_eos_id()
      const;
  void clear_eos_id() ;
  [[nodiscard]] ::int32_t eos_id() const;
  void set_eos_id(::int32_t value);

  private:
  ::int32_t _internal_eos_id() const;
  void _internal_set_eos_id(::int32_t value);

  public:
  // optional bool vocabulary_output_piece_score = 32 [default = true];
  [[nodiscard]] bool has_vocabulary_output_piece_score()
      const;
  void clear_vocabulary_output_piece_score() ;
  [[nodiscard]] bool vocabulary_output_piece_score() const;
  void set_vocabulary_output_piece_score(bool value);

  private:
  bool _internal_vocabulary_output_piece_score() const;
  void _internal_set_vocabulary_output_piece_score(bool value);

  public:
  // optional bool hard_vocab_limit = 33 [default = true];
  [[nodiscard]] bool has_hard_vocab_limit()
      const;
  void clear_hard_vocab_limit() ;
  [[nodiscard]] bool hard_vocab_limit() const;
  void set_hard_vocab_limit(bool value);

  private:
  bool _internal_hard_vocab_limit() const;
  void _internal_set_hard_vocab_limit(bool value);

  public:
  // optional int32 bos_id = 41 [default = 1];
  [[nodiscard]] bool has_bos_id()
      const;
  void clear_bos_id() ;
  [[nodiscard]] ::int32_t bos_id() const;
  void set_bos_id(::int32_t value);

  private:
  ::int32_t _internal_bos_id() const;
  void _internal_set_bos_id(::int32_t value);

  public:
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            typename = typename _proto_TypeTraits::Singular>
  PROTOBUF_FUTURE_ADD_NODISCARD inline bool HasExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) const {
    return _impl_._extensions_.Has(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            typename = typename _proto_TypeTraits::Repeated>
  PROTOBUF_FUTURE_ADD_NODISCARD inline int ExtensionSize(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) const {
    return _impl_._extensions_.ExtensionSize(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<!_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Singular::ConstType
      GetExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   TrainerSpec, _proto_TypeTraits, _field_type, _is_packed>& id)
          const {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Singular::ConstType
      GetExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   TrainerSpec, _proto_TypeTraits, _field_type, _is_packed>& id)
          const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Get(GetArena(), id.number(), _impl_._extensions_,
                                  id.default_value());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Mutable(GetArena(), id.number(), _field_type,
                                      &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(GetArena(), id.number(), _field_type, value,
                           &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(GetArena(), id.number(), _field_type,
                                    value, &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(
        GetArena(), id.number(), _field_type, value, &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  [[nodiscard]] inline typename _proto_TypeTraits::Singular::MutableType
  ReleaseExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   TrainerSpec, _proto_TypeTraits, _field_type, _is_packed>& id) {
    return _proto_TypeTraits::Release(GetArena(), id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) {
    return _proto_TypeTraits::UnsafeArenaRelease(
        GetArena(), id.number(), _field_type, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<!_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Repeated::ConstType
      GetExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                           _field_type, _is_packed>& id,
          int index) const {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Repeated::ConstType
      GetExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                           _field_type, _is_packed>& id,
          int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      int index) ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(GetArena(), id.number(), _field_type,
                               &_impl_._extensions_);
    return to_add;
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(GetArena(), id.number(), _field_type, _is_packed,
                           value, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_FUTURE_ADD_NODISCARD inline const typename _proto_TypeTraits::
      Repeated::RepeatedFieldType&
      GetRepeatedExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                           _field_type, _is_packed>& id)
          const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType* PROTOBUF_NONNULL
  MutableRepeatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<TrainerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::MutableRepeated(
        GetArena(), id.number(), _field_type, _is_packed, &_impl_._extensions_);
  }
  // @@protoc_insertion_point(class_scope:sentencepiece.TrainerSpec)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<5, 46,
                          1, 0,
                          9>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const TrainerSpec& from_msg);
    ::google::protobuf::internal::ExtensionSet _extensions_;
    ::google::protobuf::internal::HasBits<2> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField<::std::string> input_;
    ::google::protobuf::RepeatedPtrField<::std::string> accept_language_;
    ::google::protobuf::RepeatedPtrField<::std::string> control_symbols_;
    ::google::protobuf::RepeatedPtrField<::std::string> user_defined_symbols_;
    ::google::protobuf::internal::ArenaStringPtr model_prefix_;
    ::google::protobuf::internal::ArenaStringPtr input_format_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_unk_surface_;
    ::google::protobuf::internal::ArenaStringPtr unk_surface_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_unk_piece_;
    ::google::protobuf::internal::ArenaStringPtr unk_piece_;
    ::int32_t self_test_sample_size_;
    ::int32_t mining_sentence_size_;
    ::uint64_t input_sentence_size_;
    ::int32_t training_sentence_size_;
    bool treat_whitespace_as_suffix_;
    bool split_digits_;
    bool allow_whitespace_only_pieces_;
    int model_type_;
    ::int32_t vocab_size_;
    float character_coverage_;
    ::int32_t seed_sentencepiece_size_;
    float shrinking_factor_;
    ::int32_t num_threads_;
    ::int32_t num_sub_iterations_;
    ::int32_t max_sentence_length_;
    ::int32_t max_sentencepiece_length_;
    bool shuffle_input_sentence_;
    bool split_by_unicode_script_;
    bool split_by_whitespace_;
    bool split_by_number_;
    ::int32_t pad_id_;
    ::google::protobuf::internal::ArenaStringPtr required_chars_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_bos_piece_;
    ::google::protobuf::internal::ArenaStringPtr bos_piece_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_eos_piece_;
    ::google::protobuf::internal::ArenaStringPtr eos_piece_;
    static const ::google::protobuf::internal::LazyString _i_give_permission_to_break_this_code_default_pad_piece_;
    ::google::protobuf::internal::ArenaStringPtr pad_piece_;
    ::google::protobuf::internal::ArenaStringPtr pretokenization_delimiter_;
    ::google::protobuf::internal::ArenaStringPtr seed_sentencepieces_file_;
    ::int32_t unk_id_;
    bool use_all_vocab_;
    bool byte_fallback_;
    bool train_extremely_large_corpus_;
    bool enable_differential_privacy_;
    ::uint64_t differential_privacy_clipping_threshold_;
    float differential_privacy_noise_level_;
    ::int32_t eos_id_;
    bool vocabulary_output_piece_score_;
    bool hard_vocab_limit_;
    ::int32_t bos_id_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sentencepiece_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED SelfTestData_Sample final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:sentencepiece.SelfTestData.Sample) */ {
 public:
  inline SelfTestData_Sample() : SelfTestData_Sample(nullptr) {}
  ~SelfTestData_Sample() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SelfTestData_Sample* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SelfTestData_Sample));
  }
#endif

  template <typename = void>
  explicit constexpr SelfTestData_Sample(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline SelfTestData_Sample(const SelfTestData_Sample& from) : SelfTestData_Sample(nullptr, from) {}
  inline SelfTestData_Sample(SelfTestData_Sample&& from) noexcept : SelfTestData_Sample(nullptr, ::std::move(from)) {}
  inline SelfTestData_Sample& operator=(const SelfTestData_Sample& from) {
    CopyFrom(from);
    return *this;
  }
  inline SelfTestData_Sample& operator=(SelfTestData_Sample&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const SelfTestData_Sample& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<SelfTestData_Sample>(&SelfTestData_Sample_globals_);
  }
  static constexpr int kIndexInFileMessages = 2;
  friend void swap(SelfTestData_Sample& a, SelfTestData_Sample& b) { a.Swap(&b); }
  inline void Swap(SelfTestData_Sample* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SelfTestData_Sample* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] SelfTestData_Sample* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<SelfTestData_Sample>(arena);
  }
  void CopyFrom(const SelfTestData_Sample& from);
  void MergeFrom(const SelfTestData_Sample& from) { SelfTestData_Sample::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return true;
  }
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(SelfTestData_Sample* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "sentencepiece.SelfTestData.Sample"; }

  explicit SelfTestData_Sample(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SelfTestData_Sample(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SelfTestData_Sample& from);
  SelfTestData_Sample(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SelfTestData_Sample&& from) noexcept
      : SelfTestData_Sample(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kInputFieldNumber = 1,
    kExpectedFieldNumber = 2,
  };
  // optional string input = 1;
  [[nodiscard]] bool has_input()
      const;
  void clear_input() ;
  [[nodiscard]] const ::std::string& input() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_input(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_input();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_input();
  void set_allocated_input(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_input() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_input(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_input();

  public:
  // optional string expected = 2;
  [[nodiscard]] bool has_expected()
      const;
  void clear_expected() ;
  [[nodiscard]] const ::std::string& expected() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_expected(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_expected();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_expected();
  void set_allocated_expected(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_expected() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_expected(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_expected();

  public:
  // @@protoc_insertion_point(class_scope:sentencepiece.SelfTestData.Sample)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<1, 2,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const SelfTestData_Sample& from_msg);
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr input_;
    ::google::protobuf::internal::ArenaStringPtr expected_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sentencepiece_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED NormalizerSpec final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:sentencepiece.NormalizerSpec) */ {
 public:
  inline NormalizerSpec() : NormalizerSpec(nullptr) {}
  ~NormalizerSpec() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(NormalizerSpec* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(NormalizerSpec));
  }
#endif

  template <typename = void>
  explicit constexpr NormalizerSpec(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline NormalizerSpec(const NormalizerSpec& from) : NormalizerSpec(nullptr, from) {}
  inline NormalizerSpec(NormalizerSpec&& from) noexcept : NormalizerSpec(nullptr, ::std::move(from)) {}
  inline NormalizerSpec& operator=(const NormalizerSpec& from) {
    CopyFrom(from);
    return *this;
  }
  inline NormalizerSpec& operator=(NormalizerSpec&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const NormalizerSpec& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<NormalizerSpec>(&NormalizerSpec_globals_);
  }
  static constexpr int kIndexInFileMessages = 1;
  friend void swap(NormalizerSpec& a, NormalizerSpec& b) { a.Swap(&b); }
  inline void Swap(NormalizerSpec* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(NormalizerSpec* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] NormalizerSpec* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<NormalizerSpec>(arena);
  }
  void CopyFrom(const NormalizerSpec& from);
  void MergeFrom(const NormalizerSpec& from) { NormalizerSpec::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(NormalizerSpec* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "sentencepiece.NormalizerSpec"; }

  explicit NormalizerSpec(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  NormalizerSpec(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const NormalizerSpec& from);
  NormalizerSpec(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, NormalizerSpec&& from) noexcept
      : NormalizerSpec(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------
  enum : int {
    kNameFieldNumber = 1,
    kPrecompiledCharsmapFieldNumber = 2,
    kNormalizationRuleTsvFieldNumber = 6,
    kAddDummyPrefixFieldNumber = 3,
    kRemoveExtraWhitespacesFieldNumber = 4,
    kEscapeWhitespacesFieldNumber = 5,
  };
  // optional string name = 1;
  [[nodiscard]] bool has_name()
      const;
  void clear_name() ;
  [[nodiscard]] const ::std::string& name() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_name(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_name();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_name();
  void set_allocated_name(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_name() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_name(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_name();

  public:
  // optional bytes precompiled_charsmap = 2;
  [[nodiscard]] bool has_precompiled_charsmap()
      const;
  void clear_precompiled_charsmap() ;
  [[nodiscard]] const ::std::string& precompiled_charsmap() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_precompiled_charsmap(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_precompiled_charsmap();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_precompiled_charsmap();
  void set_allocated_precompiled_charsmap(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_precompiled_charsmap() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_precompiled_charsmap(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_precompiled_charsmap();

  public:
  // optional string normalization_rule_tsv = 6;
  [[nodiscard]] bool has_normalization_rule_tsv()
      const;
  void clear_normalization_rule_tsv() ;
  [[nodiscard]] const ::std::string& normalization_rule_tsv() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_normalization_rule_tsv(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_normalization_rule_tsv();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_normalization_rule_tsv();
  void set_allocated_normalization_rule_tsv(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_normalization_rule_tsv() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_normalization_rule_tsv(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_normalization_rule_tsv();

  public:
  // optional bool add_dummy_prefix = 3 [default = true];
  [[nodiscard]] bool has_add_dummy_prefix()
      const;
  void clear_add_dummy_prefix() ;
  [[nodiscard]] bool add_dummy_prefix() const;
  void set_add_dummy_prefix(bool value);

  private:
  bool _internal_add_dummy_prefix() const;
  void _internal_set_add_dummy_prefix(bool value);

  public:
  // optional bool remove_extra_whitespaces = 4 [default = true];
  [[nodiscard]] bool has_remove_extra_whitespaces()
      const;
  void clear_remove_extra_whitespaces() ;
  [[nodiscard]] bool remove_extra_whitespaces() const;
  void set_remove_extra_whitespaces(bool value);

  private:
  bool _internal_remove_extra_whitespaces() const;
  void _internal_set_remove_extra_whitespaces(bool value);

  public:
  // optional bool escape_whitespaces = 5 [default = true];
  [[nodiscard]] bool has_escape_whitespaces()
      const;
  void clear_escape_whitespaces() ;
  [[nodiscard]] bool escape_whitespaces() const;
  void set_escape_whitespaces(bool value);

  private:
  bool _internal_escape_whitespaces() const;
  void _internal_set_escape_whitespaces(bool value);

  public:
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            typename = typename _proto_TypeTraits::Singular>
  PROTOBUF_FUTURE_ADD_NODISCARD inline bool HasExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) const {
    return _impl_._extensions_.Has(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            typename = typename _proto_TypeTraits::Repeated>
  PROTOBUF_FUTURE_ADD_NODISCARD inline int ExtensionSize(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) const {
    return _impl_._extensions_.ExtensionSize(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<!_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Singular::ConstType
      GetExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   NormalizerSpec, _proto_TypeTraits, _field_type, _is_packed>& id)
          const {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Singular::ConstType
      GetExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   NormalizerSpec, _proto_TypeTraits, _field_type, _is_packed>& id)
          const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Get(GetArena(), id.number(), _impl_._extensions_,
                                  id.default_value());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Mutable(GetArena(), id.number(), _field_type,
                                      &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(GetArena(), id.number(), _field_type, value,
                           &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(GetArena(), id.number(), _field_type,
                                    value, &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(
        GetArena(), id.number(), _field_type, value, &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  [[nodiscard]] inline typename _proto_TypeTraits::Singular::MutableType
  ReleaseExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   NormalizerSpec, _proto_TypeTraits, _field_type, _is_packed>& id) {
    return _proto_TypeTraits::Release(GetArena(), id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) {
    return _proto_TypeTraits::UnsafeArenaRelease(
        GetArena(), id.number(), _field_type, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<!_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Repeated::ConstType
      GetExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                           _field_type, _is_packed>& id,
          int index) const {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Repeated::ConstType
      GetExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                           _field_type, _is_packed>& id,
          int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      int index) ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(GetArena(), id.number(), _field_type,
                               &_impl_._extensions_);
    return to_add;
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(GetArena(), id.number(), _field_type, _is_packed,
                           value, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_FUTURE_ADD_NODISCARD inline const typename _proto_TypeTraits::
      Repeated::RepeatedFieldType&
      GetRepeatedExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                           _field_type, _is_packed>& id)
          const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType* PROTOBUF_NONNULL
  MutableRepeatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<NormalizerSpec, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::MutableRepeated(
        GetArena(), id.number(), _field_type, _is_packed, &_impl_._extensions_);
  }
  // @@protoc_insertion_point(class_scope:sentencepiece.NormalizerSpec)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 6,
                          0, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const NormalizerSpec& from_msg);
    ::google::protobuf::internal::ExtensionSet _extensions_;
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr name_;
    ::google::protobuf::internal::ArenaStringPtr precompiled_charsmap_;
    ::google::protobuf::internal::ArenaStringPtr normalization_rule_tsv_;
    bool add_dummy_prefix_;
    bool remove_extra_whitespaces_;
    bool escape_whitespaces_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sentencepiece_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ModelProto_SentencePiece final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:sentencepiece.ModelProto.SentencePiece) */ {
 public:
  inline ModelProto_SentencePiece() : ModelProto_SentencePiece(nullptr) {}
  ~ModelProto_SentencePiece() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ModelProto_SentencePiece* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ModelProto_SentencePiece));
  }
#endif

  template <typename = void>
  explicit constexpr ModelProto_SentencePiece(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline ModelProto_SentencePiece(const ModelProto_SentencePiece& from) : ModelProto_SentencePiece(nullptr, from) {}
  inline ModelProto_SentencePiece(ModelProto_SentencePiece&& from) noexcept : ModelProto_SentencePiece(nullptr, ::std::move(from)) {}
  inline ModelProto_SentencePiece& operator=(const ModelProto_SentencePiece& from) {
    CopyFrom(from);
    return *this;
  }
  inline ModelProto_SentencePiece& operator=(ModelProto_SentencePiece&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const ModelProto_SentencePiece& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ModelProto_SentencePiece>(&ModelProto_SentencePiece_globals_);
  }
  static constexpr int kIndexInFileMessages = 4;
  friend void swap(ModelProto_SentencePiece& a, ModelProto_SentencePiece& b) { a.Swap(&b); }
  inline void Swap(ModelProto_SentencePiece* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ModelProto_SentencePiece* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] ModelProto_SentencePiece* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<ModelProto_SentencePiece>(arena);
  }
  void CopyFrom(const ModelProto_SentencePiece& from);
  void MergeFrom(const ModelProto_SentencePiece& from) { ModelProto_SentencePiece::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ModelProto_SentencePiece* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "sentencepiece.ModelProto.SentencePiece"; }

  explicit ModelProto_SentencePiece(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ModelProto_SentencePiece(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ModelProto_SentencePiece& from);
  ModelProto_SentencePiece(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ModelProto_SentencePiece&& from) noexcept
      : ModelProto_SentencePiece(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  // nested types ----------------------------------------------------
  using Type = ModelProto_SentencePiece_Type;
  static constexpr Type NORMAL = ModelProto_SentencePiece_Type_NORMAL;
  static constexpr Type UNKNOWN = ModelProto_SentencePiece_Type_UNKNOWN;
  static constexpr Type CONTROL = ModelProto_SentencePiece_Type_CONTROL;
  static constexpr Type USER_DEFINED = ModelProto_SentencePiece_Type_USER_DEFINED;
  static constexpr Type BYTE = ModelProto_SentencePiece_Type_BYTE;
  static constexpr Type UNUSED = ModelProto_SentencePiece_Type_UNUSED;
  [[nodiscard]] static inline bool Type_IsValid(int value) {
    return ModelProto_SentencePiece_Type_IsValid(value);
  }
  static constexpr Type Type_MIN = ModelProto_SentencePiece_Type_Type_MIN;
  static constexpr Type Type_MAX = ModelProto_SentencePiece_Type_Type_MAX;
  static constexpr int Type_ARRAYSIZE = ModelProto_SentencePiece_Type_Type_ARRAYSIZE;
  template <typename T>
  [[nodiscard]] static inline const ::std::string& Type_Name(T value) {
    return ModelProto_SentencePiece_Type_Name(value);
  }
  [[nodiscard]] static inline bool Type_Parse(
      ::absl::string_view name, Type* PROTOBUF_NONNULL value) {
    return ModelProto_SentencePiece_Type_Parse(name, value);
  }

  // accessors -------------------------------------------------------
  enum : int {
    kPieceFieldNumber = 1,
    kScoreFieldNumber = 2,
    kTypeFieldNumber = 3,
  };
  // optional string piece = 1;
  [[nodiscard]] bool has_piece()
      const;
  void clear_piece() ;
  [[nodiscard]] const ::std::string& piece() const;
  template <typename Arg_ = const ::std::string&, typename... Args_>
  void set_piece(Arg_&& arg, Args_... args);
  ::std::string* PROTOBUF_NONNULL mutable_piece();
  [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_piece();
  void set_allocated_piece(::std::string* PROTOBUF_NULLABLE value);

  private:
  const ::std::string& _internal_piece() const;
  PROTOBUF_ALWAYS_INLINE void _internal_set_piece(const ::std::string& value);
  ::std::string* PROTOBUF_NONNULL _internal_mutable_piece();

  public:
  // optional float score = 2;
  [[nodiscard]] bool has_score()
      const;
  void clear_score() ;
  [[nodiscard]] float score() const;
  void set_score(float value);

  private:
  float _internal_score() const;
  void _internal_set_score(float value);

  public:
  // optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
  [[nodiscard]] bool has_type()
      const;
  void clear_type() ;
  [[nodiscard]] ::sentencepiece::ModelProto_SentencePiece_Type type() const;
  void set_type(::sentencepiece::ModelProto_SentencePiece_Type value);

  private:
  ::sentencepiece::ModelProto_SentencePiece_Type _internal_type() const;
  void _internal_set_type(::sentencepiece::ModelProto_SentencePiece_Type value);

  public:
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            typename = typename _proto_TypeTraits::Singular>
  PROTOBUF_FUTURE_ADD_NODISCARD inline bool HasExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) const {
    return _impl_._extensions_.Has(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            typename = typename _proto_TypeTraits::Repeated>
  PROTOBUF_FUTURE_ADD_NODISCARD inline int ExtensionSize(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) const {
    return _impl_._extensions_.ExtensionSize(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<!_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Singular::ConstType
      GetExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   ModelProto_SentencePiece, _proto_TypeTraits, _field_type, _is_packed>& id)
          const {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Singular::ConstType
      GetExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   ModelProto_SentencePiece, _proto_TypeTraits, _field_type, _is_packed>& id)
          const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Get(GetArena(), id.number(), _impl_._extensions_,
                                  id.default_value());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Mutable(GetArena(), id.number(), _field_type,
                                      &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(GetArena(), id.number(), _field_type, value,
                           &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(GetArena(), id.number(), _field_type,
                                    value, &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(
        GetArena(), id.number(), _field_type, value, &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  [[nodiscard]] inline typename _proto_TypeTraits::Singular::MutableType
  ReleaseExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   ModelProto_SentencePiece, _proto_TypeTraits, _field_type, _is_packed>& id) {
    return _proto_TypeTraits::Release(GetArena(), id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) {
    return _proto_TypeTraits::UnsafeArenaRelease(
        GetArena(), id.number(), _field_type, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<!_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Repeated::ConstType
      GetExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                           _field_type, _is_packed>& id,
          int index) const {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Repeated::ConstType
      GetExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                           _field_type, _is_packed>& id,
          int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      int index) ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(GetArena(), id.number(), _field_type,
                               &_impl_._extensions_);
    return to_add;
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(GetArena(), id.number(), _field_type, _is_packed,
                           value, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_FUTURE_ADD_NODISCARD inline const typename _proto_TypeTraits::
      Repeated::RepeatedFieldType&
      GetRepeatedExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                           _field_type, _is_packed>& id)
          const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType* PROTOBUF_NONNULL
  MutableRepeatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto_SentencePiece, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::MutableRepeated(
        GetArena(), id.number(), _field_type, _is_packed, &_impl_._extensions_);
  }
  // @@protoc_insertion_point(class_scope:sentencepiece.ModelProto.SentencePiece)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<2, 3,
                          1, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ModelProto_SentencePiece& from_msg);
    ::google::protobuf::internal::ExtensionSet _extensions_;
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::internal::ArenaStringPtr piece_;
    float score_;
    int type_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sentencepiece_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED SelfTestData final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:sentencepiece.SelfTestData) */ {
 public:
  inline SelfTestData() : SelfTestData(nullptr) {}
  ~SelfTestData() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(SelfTestData* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(SelfTestData));
  }
#endif

  template <typename = void>
  explicit constexpr SelfTestData(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline SelfTestData(const SelfTestData& from) : SelfTestData(nullptr, from) {}
  inline SelfTestData(SelfTestData&& from) noexcept : SelfTestData(nullptr, ::std::move(from)) {}
  inline SelfTestData& operator=(const SelfTestData& from) {
    CopyFrom(from);
    return *this;
  }
  inline SelfTestData& operator=(SelfTestData&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const SelfTestData& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<SelfTestData>(&SelfTestData_globals_);
  }
  static constexpr int kIndexInFileMessages = 3;
  friend void swap(SelfTestData& a, SelfTestData& b) { a.Swap(&b); }
  inline void Swap(SelfTestData* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(SelfTestData* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] SelfTestData* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<SelfTestData>(arena);
  }
  void CopyFrom(const SelfTestData& from);
  void MergeFrom(const SelfTestData& from) { SelfTestData::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(SelfTestData* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "sentencepiece.SelfTestData"; }

  explicit SelfTestData(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  SelfTestData(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SelfTestData& from);
  SelfTestData(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SelfTestData&& from) noexcept
      : SelfTestData(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  // nested types ----------------------------------------------------
  using Sample = SelfTestData_Sample;

  // accessors -------------------------------------------------------
  enum : int {
    kSamplesFieldNumber = 1,
  };
  // repeated .sentencepiece.SelfTestData.Sample samples = 1;
  [[nodiscard]] int samples_size()
      const;
  private:
  int _internal_samples_size() const;

  public:
  void clear_samples() ;
  [[nodiscard]] const ::sentencepiece::SelfTestData_Sample& samples(int index) const;
  [[nodiscard]] ::sentencepiece::SelfTestData_Sample* PROTOBUF_NONNULL mutable_samples(int index);
  ::sentencepiece::SelfTestData_Sample* PROTOBUF_NONNULL add_samples();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::sentencepiece::SelfTestData_Sample>&
  samples() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::sentencepiece::SelfTestData_Sample>* PROTOBUF_NONNULL
  mutable_samples();

  private:
  const ::google::protobuf::RepeatedPtrField<::sentencepiece::SelfTestData_Sample>& _internal_samples() const;
  ::google::protobuf::RepeatedPtrField<::sentencepiece::SelfTestData_Sample>* PROTOBUF_NONNULL _internal_mutable_samples();

  public:
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            typename = typename _proto_TypeTraits::Singular>
  PROTOBUF_FUTURE_ADD_NODISCARD inline bool HasExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) const {
    return _impl_._extensions_.Has(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            typename = typename _proto_TypeTraits::Repeated>
  PROTOBUF_FUTURE_ADD_NODISCARD inline int ExtensionSize(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) const {
    return _impl_._extensions_.ExtensionSize(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<!_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Singular::ConstType
      GetExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   SelfTestData, _proto_TypeTraits, _field_type, _is_packed>& id)
          const {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Singular::ConstType
      GetExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   SelfTestData, _proto_TypeTraits, _field_type, _is_packed>& id)
          const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Get(GetArena(), id.number(), _impl_._extensions_,
                                  id.default_value());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Mutable(GetArena(), id.number(), _field_type,
                                      &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(GetArena(), id.number(), _field_type, value,
                           &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(GetArena(), id.number(), _field_type,
                                    value, &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(
        GetArena(), id.number(), _field_type, value, &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  [[nodiscard]] inline typename _proto_TypeTraits::Singular::MutableType
  ReleaseExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   SelfTestData, _proto_TypeTraits, _field_type, _is_packed>& id) {
    return _proto_TypeTraits::Release(GetArena(), id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) {
    return _proto_TypeTraits::UnsafeArenaRelease(
        GetArena(), id.number(), _field_type, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<!_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Repeated::ConstType
      GetExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                           _field_type, _is_packed>& id,
          int index) const {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Repeated::ConstType
      GetExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                           _field_type, _is_packed>& id,
          int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      int index) ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(GetArena(), id.number(), _field_type,
                               &_impl_._extensions_);
    return to_add;
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(GetArena(), id.number(), _field_type, _is_packed,
                           value, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_FUTURE_ADD_NODISCARD inline const typename _proto_TypeTraits::
      Repeated::RepeatedFieldType&
      GetRepeatedExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                           _field_type, _is_packed>& id)
          const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType* PROTOBUF_NONNULL
  MutableRepeatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<SelfTestData, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::MutableRepeated(
        GetArena(), id.number(), _field_type, _is_packed, &_impl_._extensions_);
  }
  // @@protoc_insertion_point(class_scope:sentencepiece.SelfTestData)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<0, 1,
                          1, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const SelfTestData& from_msg);
    ::google::protobuf::internal::ExtensionSet _extensions_;
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::sentencepiece::SelfTestData_Sample > samples_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sentencepiece_5fmodel_2eproto;
};
// -------------------------------------------------------------------

class  PROTOBUF_FUTURE_ADD_EARLY_WARN_UNUSED ModelProto final : public ::google::protobuf::MessageLite
/* @@protoc_insertion_point(class_definition:sentencepiece.ModelProto) */ {
 public:
  inline ModelProto() : ModelProto(nullptr) {}
  ~ModelProto() PROTOBUF_FINAL;

#if defined(PROTOBUF_CUSTOM_VTABLE)
  void operator delete(ModelProto* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) {
    SharedDtor(*msg);
    ::google::protobuf::internal::SizedDelete(msg, sizeof(ModelProto));
  }
#endif

  template <typename = void>
  explicit constexpr ModelProto(::google::protobuf::internal::ConstantInitialized,
                           const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL
                               class_data);

  inline ModelProto(const ModelProto& from) : ModelProto(nullptr, from) {}
  inline ModelProto(ModelProto&& from) noexcept : ModelProto(nullptr, ::std::move(from)) {}
  inline ModelProto& operator=(const ModelProto& from) {
    CopyFrom(from);
    return *this;
  }
  inline ModelProto& operator=(ModelProto&& from) noexcept {
    if (this == &from) return *this;
    if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) {
      InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  [[nodiscard]] inline const ::std::string& unknown_fields() const
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.unknown_fields<::std::string>(::google::protobuf::internal::GetEmptyString);
  }
  [[nodiscard]] inline ::std::string* PROTOBUF_NONNULL
  mutable_unknown_fields() ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _internal_metadata_.mutable_unknown_fields<::std::string>();
  }

  [[nodiscard]] static const ModelProto& default_instance() {
    return *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<ModelProto>(&ModelProto_globals_);
  }
  static constexpr int kIndexInFileMessages = 5;
  friend void swap(ModelProto& a, ModelProto& b) { a.Swap(&b); }
  inline void Swap(ModelProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) {
      InternalSwap(other);
    } else {
      ::google::protobuf::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ModelProto* PROTOBUF_NONNULL other) {
    if (other == this) return;
    ABSL_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  [[nodiscard]] ModelProto* PROTOBUF_NONNULL
  New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const {
    return ::google::protobuf::MessageLite::DefaultConstruct<ModelProto>(arena);
  }
  void CopyFrom(const ModelProto& from);
  void MergeFrom(const ModelProto& from) { ModelProto::MergeImpl(*this, from); }

  private:
  static void MergeImpl(::google::protobuf::MessageLite& to_msg,
                        const ::google::protobuf::MessageLite& from_msg);

  public:
  [[nodiscard]] bool IsInitialized() const {
    return IsInitializedImpl(*this);
  }

  private:
  static bool IsInitializedImpl(const MessageLite& msg);

  public:
  ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL;
  #if defined(PROTOBUF_CUSTOM_VTABLE)
  private:
  [[nodiscard]] static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg);
  [[nodiscard]] static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream);

  public:
  [[nodiscard]] ::size_t ByteSizeLong() const { return ByteSizeLong(*this); }
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const {
    return _InternalSerialize(*this, target, stream);
  }
  #else   // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] ::size_t ByteSizeLong() const final;
  [[nodiscard]] ::uint8_t* PROTOBUF_NONNULL _InternalSerialize(
      ::uint8_t* PROTOBUF_NONNULL target,
      ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final;
  #endif  // PROTOBUF_CUSTOM_VTABLE
  [[nodiscard]] int GetCachedSize() const {
    return _impl_._cached_size_.Get();
  }

  private:
  void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static void SharedDtor(MessageLite& self);
  void InternalSwap(ModelProto* PROTOBUF_NONNULL other);
 private:
  template <typename T>
  friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)();
  static ::absl::string_view FullMessageName() { return "sentencepiece.ModelProto"; }

  explicit ModelProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  ModelProto(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ModelProto& from);
  ModelProto(
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ModelProto&& from) noexcept
      : ModelProto(arena) {
    *this = ::std::move(from);
  }
  const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL;
  static void* PROTOBUF_NONNULL PlacementNew_(
      const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem,
      ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
  static constexpr auto InternalNewImpl_();

 public:
  static constexpr auto InternalGenerateClassData_(
      const MessageLite& prototype,
      const ::google::protobuf::internal::TcParseTableBase* PROTOBUF_NULLABLE tc_table = nullptr);

  // nested types ----------------------------------------------------
  using SentencePiece = ModelProto_SentencePiece;

  // accessors -------------------------------------------------------
  enum : int {
    kPiecesFieldNumber = 1,
    kTrainerSpecFieldNumber = 2,
    kNormalizerSpecFieldNumber = 3,
    kSelfTestDataFieldNumber = 4,
    kDenormalizerSpecFieldNumber = 5,
  };
  // repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
  [[nodiscard]] int pieces_size()
      const;
  private:
  int _internal_pieces_size() const;

  public:
  void clear_pieces() ;
  [[nodiscard]] const ::sentencepiece::ModelProto_SentencePiece& pieces(int index) const;
  [[nodiscard]] ::sentencepiece::ModelProto_SentencePiece* PROTOBUF_NONNULL mutable_pieces(int index);
  ::sentencepiece::ModelProto_SentencePiece* PROTOBUF_NONNULL add_pieces();
  [[nodiscard]] const ::google::protobuf::RepeatedPtrField<::sentencepiece::ModelProto_SentencePiece>&
  pieces() const;
  [[nodiscard]] ::google::protobuf::RepeatedPtrField<::sentencepiece::ModelProto_SentencePiece>* PROTOBUF_NONNULL
  mutable_pieces();

  private:
  const ::google::protobuf::RepeatedPtrField<::sentencepiece::ModelProto_SentencePiece>& _internal_pieces() const;
  ::google::protobuf::RepeatedPtrField<::sentencepiece::ModelProto_SentencePiece>* PROTOBUF_NONNULL _internal_mutable_pieces();

  public:
  // optional .sentencepiece.TrainerSpec trainer_spec = 2;
  [[nodiscard]] bool has_trainer_spec()
      const;
  void clear_trainer_spec() ;
  [[nodiscard]] const ::sentencepiece::TrainerSpec& trainer_spec() const;
  [[nodiscard]] ::sentencepiece::TrainerSpec* PROTOBUF_NULLABLE release_trainer_spec();
  ::sentencepiece::TrainerSpec* PROTOBUF_NONNULL mutable_trainer_spec();
  void set_allocated_trainer_spec(::sentencepiece::TrainerSpec* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_trainer_spec(::sentencepiece::TrainerSpec* PROTOBUF_NULLABLE value);
  ::sentencepiece::TrainerSpec* PROTOBUF_NULLABLE unsafe_arena_release_trainer_spec();

  private:
  const ::sentencepiece::TrainerSpec& _internal_trainer_spec() const;
  ::sentencepiece::TrainerSpec* PROTOBUF_NONNULL _internal_mutable_trainer_spec();

  public:
  // optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
  [[nodiscard]] bool has_normalizer_spec()
      const;
  void clear_normalizer_spec() ;
  [[nodiscard]] const ::sentencepiece::NormalizerSpec& normalizer_spec() const;
  [[nodiscard]] ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE release_normalizer_spec();
  ::sentencepiece::NormalizerSpec* PROTOBUF_NONNULL mutable_normalizer_spec();
  void set_allocated_normalizer_spec(::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_normalizer_spec(::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE value);
  ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE unsafe_arena_release_normalizer_spec();

  private:
  const ::sentencepiece::NormalizerSpec& _internal_normalizer_spec() const;
  ::sentencepiece::NormalizerSpec* PROTOBUF_NONNULL _internal_mutable_normalizer_spec();

  public:
  // optional .sentencepiece.SelfTestData self_test_data = 4;
  [[nodiscard]] bool has_self_test_data()
      const;
  void clear_self_test_data() ;
  [[nodiscard]] const ::sentencepiece::SelfTestData& self_test_data() const;
  [[nodiscard]] ::sentencepiece::SelfTestData* PROTOBUF_NULLABLE release_self_test_data();
  ::sentencepiece::SelfTestData* PROTOBUF_NONNULL mutable_self_test_data();
  void set_allocated_self_test_data(::sentencepiece::SelfTestData* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_self_test_data(::sentencepiece::SelfTestData* PROTOBUF_NULLABLE value);
  ::sentencepiece::SelfTestData* PROTOBUF_NULLABLE unsafe_arena_release_self_test_data();

  private:
  const ::sentencepiece::SelfTestData& _internal_self_test_data() const;
  ::sentencepiece::SelfTestData* PROTOBUF_NONNULL _internal_mutable_self_test_data();

  public:
  // optional .sentencepiece.NormalizerSpec denormalizer_spec = 5;
  [[nodiscard]] bool has_denormalizer_spec()
      const;
  void clear_denormalizer_spec() ;
  [[nodiscard]] const ::sentencepiece::NormalizerSpec& denormalizer_spec() const;
  [[nodiscard]] ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE release_denormalizer_spec();
  ::sentencepiece::NormalizerSpec* PROTOBUF_NONNULL mutable_denormalizer_spec();
  void set_allocated_denormalizer_spec(::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE value);
  void unsafe_arena_set_allocated_denormalizer_spec(::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE value);
  ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE unsafe_arena_release_denormalizer_spec();

  private:
  const ::sentencepiece::NormalizerSpec& _internal_denormalizer_spec() const;
  ::sentencepiece::NormalizerSpec* PROTOBUF_NONNULL _internal_mutable_denormalizer_spec();

  public:
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            typename = typename _proto_TypeTraits::Singular>
  PROTOBUF_FUTURE_ADD_NODISCARD inline bool HasExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) const {
    return _impl_._extensions_.Has(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void ClearExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) {
    _impl_._extensions_.ClearExtension(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            typename = typename _proto_TypeTraits::Repeated>
  PROTOBUF_FUTURE_ADD_NODISCARD inline int ExtensionSize(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) const {
    return _impl_._extensions_.ExtensionSize(id.number());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<!_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Singular::ConstType
      GetExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   ModelProto, _proto_TypeTraits, _field_type, _is_packed>& id)
          const {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, id.default_value());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Singular::ConstType
      GetExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   ModelProto, _proto_TypeTraits, _field_type, _is_packed>& id)
          const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Get(GetArena(), id.number(), _impl_._extensions_,
                                  id.default_value());
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Mutable(GetArena(), id.number(), _field_type,
                                      &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::ConstType value) {
    _proto_TypeTraits::Set(GetArena(), id.number(), _field_type, value,
                           &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetAllocatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::SetAllocated(GetArena(), id.number(), _field_type,
                                    value, &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void UnsafeArenaSetAllocatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Singular::MutableType value) {
    _proto_TypeTraits::UnsafeArenaSetAllocated(
        GetArena(), id.number(), _field_type, value, &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  [[nodiscard]] inline typename _proto_TypeTraits::Singular::MutableType
  ReleaseExtension(const ::google::protobuf::internal::ExtensionIdentifier<
                   ModelProto, _proto_TypeTraits, _field_type, _is_packed>& id) {
    return _proto_TypeTraits::Release(GetArena(), id.number(), _field_type,
                                      &_impl_._extensions_);
  }
  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Singular::MutableType
  UnsafeArenaReleaseExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id) {
    return _proto_TypeTraits::UnsafeArenaRelease(
        GetArena(), id.number(), _field_type, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<!_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Repeated::ConstType
      GetExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                           _field_type, _is_packed>& id,
          int index) const {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed,
            ::std::enable_if_t<_proto_TypeTraits::kLifetimeBound, int> = 0>
  PROTOBUF_FUTURE_ADD_NODISCARD inline
      typename _proto_TypeTraits::Repeated::ConstType
      GetExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                           _field_type, _is_packed>& id,
          int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Get(id.number(), _impl_._extensions_, index);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      int index) ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::Mutable(id.number(), index, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void SetExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      int index, typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Set(id.number(), index, value, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    typename _proto_TypeTraits::Repeated::MutableType to_add =
        _proto_TypeTraits::Add(GetArena(), id.number(), _field_type,
                               &_impl_._extensions_);
    return to_add;
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline void AddExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id,
      typename _proto_TypeTraits::Repeated::ConstType value) {
    _proto_TypeTraits::Add(GetArena(), id.number(), _field_type, _is_packed,
                           value, &_impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  PROTOBUF_FUTURE_ADD_NODISCARD inline const typename _proto_TypeTraits::
      Repeated::RepeatedFieldType&
      GetRepeatedExtension(
          const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                           _field_type, _is_packed>& id)
          const ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::GetRepeated(id.number(), _impl_._extensions_);
  }

  template <typename _proto_TypeTraits, ::google::protobuf::internal::FieldType _field_type,
            bool _is_packed>
  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType* PROTOBUF_NONNULL
  MutableRepeatedExtension(
      const ::google::protobuf::internal::ExtensionIdentifier<ModelProto, _proto_TypeTraits,
                                       _field_type, _is_packed>& id)
      ABSL_ATTRIBUTE_LIFETIME_BOUND {
    return _proto_TypeTraits::MutableRepeated(
        GetArena(), id.number(), _field_type, _is_packed, &_impl_._extensions_);
  }
  // @@protoc_insertion_point(class_scope:sentencepiece.ModelProto)
 private:
  class _Internal;
  using ParseTableT_ =
      ::google::protobuf::internal::TcParseTable<3, 5,
                          5, 0,
                          2>;
  static constexpr ParseTableT_ InternalGenerateParseTable_(
      const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL class_data);
  friend class ::google::protobuf::internal::TcParser;
  #ifndef PROTOBUF_MESSAGE_GLOBALS
  static const ParseTableT_ _table_;
  #endif

  friend class ::google::protobuf::MessageLite;
  friend class ::google::protobuf::Arena;
  friend ::google::protobuf::internal::PrivateAccess;
  template <typename T>
  friend class ::google::protobuf::Arena::InternalHelper;
  using InternalArenaConstructable_ = void;
  using DestructorSkippable_ = void;
  struct Impl_ {
    inline explicit constexpr Impl_(::google::protobuf::internal::InternalVisibility visibility,
                                    ::google::protobuf::internal::ConstantInitialized) noexcept;
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena);
    inline explicit Impl_(
        ::google::protobuf::internal::InternalVisibility visibility,
        ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from,
        const ModelProto& from_msg);
    ::google::protobuf::internal::ExtensionSet _extensions_;
    ::google::protobuf::internal::HasBits<1> _has_bits_;
    ::google::protobuf::internal::CachedSize _cached_size_;
    ::google::protobuf::RepeatedPtrField< ::sentencepiece::ModelProto_SentencePiece > pieces_;
    ::sentencepiece::TrainerSpec* PROTOBUF_NULLABLE trainer_spec_;
    ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE normalizer_spec_;
    ::sentencepiece::SelfTestData* PROTOBUF_NULLABLE self_test_data_;
    ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE denormalizer_spec_;
    PROTOBUF_TSAN_DECLARE_MEMBER
  };
  union { Impl_ _impl_; };
  friend struct ::TableStruct_sentencepiece_5fmodel_2eproto;
};

// ===================================================================




// ===================================================================


#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// TrainerSpec

// repeated string input = 1;
inline int TrainerSpec::_internal_input_size() const {
  return _internal_input().size();
}
inline int TrainerSpec::input_size() const {
  return _internal_input_size();
}
inline void TrainerSpec::clear_input() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::add_input()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_input()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add_mutable:sentencepiece.TrainerSpec.input)
  return _s;
}
inline const ::std::string& TrainerSpec::input(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.input)
  return _internal_input().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_input(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.input)
  return _internal_mutable_input()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void TrainerSpec::set_input(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_input()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.input)
}
template <typename Arg_, typename... Args_>
inline void TrainerSpec::add_input(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_input(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.input)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& TrainerSpec::input()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.input)
  return _internal_input();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
TrainerSpec::mutable_input() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:sentencepiece.TrainerSpec.input)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_input();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
TrainerSpec::_internal_input() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.input_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
TrainerSpec::_internal_mutable_input() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.input_;
}

// optional string input_format = 7;
inline bool TrainerSpec::has_input_format() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void TrainerSpec::clear_input_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_format_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline const ::std::string& TrainerSpec::input_format() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.input_format)
  return _internal_input_format();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TrainerSpec::set_input_format(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  _impl_.input_format_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.input_format)
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_input_format()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  ::std::string* _s = _internal_mutable_input_format();
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.input_format)
  return _s;
}
inline const ::std::string& TrainerSpec::_internal_input_format() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.input_format_.Get();
}
inline void TrainerSpec::_internal_set_input_format(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_format_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::_internal_mutable_input_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.input_format_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TrainerSpec::release_input_format() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.input_format)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000020U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  auto* released = _impl_.input_format_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.input_format_.Set("", GetArena());
  }
  return released;
}
inline void TrainerSpec::set_allocated_input_format(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
  }
  _impl_.input_format_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.input_format_.IsDefault()) {
    _impl_.input_format_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.input_format)
}

// optional string model_prefix = 2;
inline bool TrainerSpec::has_model_prefix() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void TrainerSpec::clear_model_prefix() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.model_prefix_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::std::string& TrainerSpec::model_prefix() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.model_prefix)
  return _internal_model_prefix();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TrainerSpec::set_model_prefix(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  _impl_.model_prefix_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.model_prefix)
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_model_prefix()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::std::string* _s = _internal_mutable_model_prefix();
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.model_prefix)
  return _s;
}
inline const ::std::string& TrainerSpec::_internal_model_prefix() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.model_prefix_.Get();
}
inline void TrainerSpec::_internal_set_model_prefix(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.model_prefix_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::_internal_mutable_model_prefix() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.model_prefix_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TrainerSpec::release_model_prefix() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.model_prefix)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000010U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  auto* released = _impl_.model_prefix_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.model_prefix_.Set("", GetArena());
  }
  return released;
}
inline void TrainerSpec::set_allocated_model_prefix(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  _impl_.model_prefix_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.model_prefix_.IsDefault()) {
    _impl_.model_prefix_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.model_prefix)
}

// optional .sentencepiece.TrainerSpec.ModelType model_type = 3 [default = UNIGRAM];
inline bool TrainerSpec::has_model_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00008000U);
  return value;
}
inline void TrainerSpec::clear_model_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.model_type_ = 1;
  ClearHasBit(_impl_._has_bits_[0], 0x00008000U);
}
inline ::sentencepiece::TrainerSpec_ModelType TrainerSpec::model_type() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.model_type)
  return _internal_model_type();
}
inline void TrainerSpec::set_model_type(::sentencepiece::TrainerSpec_ModelType value) {
  _internal_set_model_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00008000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.model_type)
}
inline ::sentencepiece::TrainerSpec_ModelType TrainerSpec::_internal_model_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::sentencepiece::TrainerSpec_ModelType>(_impl_.model_type_);
}
inline void TrainerSpec::_internal_set_model_type(::sentencepiece::TrainerSpec_ModelType value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::sentencepiece::TrainerSpec_ModelType_internal_data_));
                                          _impl_.model_type_ = value;
}

// optional int32 vocab_size = 4 [default = 8000];
inline bool TrainerSpec::has_vocab_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00010000U);
  return value;
}
inline void TrainerSpec::clear_vocab_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.vocab_size_ = 8000;
  ClearHasBit(_impl_._has_bits_[0], 0x00010000U);
}
inline ::int32_t TrainerSpec::vocab_size() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.vocab_size)
  return _internal_vocab_size();
}
inline void TrainerSpec::set_vocab_size(::int32_t value) {
  _internal_set_vocab_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00010000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.vocab_size)
}
inline ::int32_t TrainerSpec::_internal_vocab_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.vocab_size_;
}
inline void TrainerSpec::_internal_set_vocab_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.vocab_size_ = value;
}

// repeated string accept_language = 5;
inline int TrainerSpec::_internal_accept_language_size() const {
  return _internal_accept_language().size();
}
inline int TrainerSpec::accept_language_size() const {
  return _internal_accept_language_size();
}
inline void TrainerSpec::clear_accept_language() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.accept_language_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::add_accept_language()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_accept_language()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add_mutable:sentencepiece.TrainerSpec.accept_language)
  return _s;
}
inline const ::std::string& TrainerSpec::accept_language(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.accept_language)
  return _internal_accept_language().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_accept_language(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.accept_language)
  return _internal_mutable_accept_language()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void TrainerSpec::set_accept_language(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_accept_language()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.accept_language)
}
template <typename Arg_, typename... Args_>
inline void TrainerSpec::add_accept_language(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_accept_language(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.accept_language)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& TrainerSpec::accept_language()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.accept_language)
  return _internal_accept_language();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
TrainerSpec::mutable_accept_language() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_mutable_list:sentencepiece.TrainerSpec.accept_language)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_accept_language();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
TrainerSpec::_internal_accept_language() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.accept_language_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
TrainerSpec::_internal_mutable_accept_language() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.accept_language_;
}

// optional int32 self_test_sample_size = 6 [default = 0];
inline bool TrainerSpec::has_self_test_sample_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000100U);
  return value;
}
inline void TrainerSpec::clear_self_test_sample_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.self_test_sample_size_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000100U);
}
inline ::int32_t TrainerSpec::self_test_sample_size() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.self_test_sample_size)
  return _internal_self_test_sample_size();
}
inline void TrainerSpec::set_self_test_sample_size(::int32_t value) {
  _internal_set_self_test_sample_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000100U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.self_test_sample_size)
}
inline ::int32_t TrainerSpec::_internal_self_test_sample_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.self_test_sample_size_;
}
inline void TrainerSpec::_internal_set_self_test_sample_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.self_test_sample_size_ = value;
}

// optional bool enable_differential_privacy = 50 [default = false];
inline bool TrainerSpec::has_enable_differential_privacy() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000080U);
  return value;
}
inline void TrainerSpec::clear_enable_differential_privacy() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_differential_privacy_ = false;
  ClearHasBit(_impl_._has_bits_[1], 0x00000080U);
}
inline bool TrainerSpec::enable_differential_privacy() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.enable_differential_privacy)
  return _internal_enable_differential_privacy();
}
inline void TrainerSpec::set_enable_differential_privacy(bool value) {
  _internal_set_enable_differential_privacy(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000080U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.enable_differential_privacy)
}
inline bool TrainerSpec::_internal_enable_differential_privacy() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.enable_differential_privacy_;
}
inline void TrainerSpec::_internal_set_enable_differential_privacy(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.enable_differential_privacy_ = value;
}

// optional float differential_privacy_noise_level = 51 [default = 0];
inline bool TrainerSpec::has_differential_privacy_noise_level() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000200U);
  return value;
}
inline void TrainerSpec::clear_differential_privacy_noise_level() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.differential_privacy_noise_level_ = 0;
  ClearHasBit(_impl_._has_bits_[1], 0x00000200U);
}
inline float TrainerSpec::differential_privacy_noise_level() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.differential_privacy_noise_level)
  return _internal_differential_privacy_noise_level();
}
inline void TrainerSpec::set_differential_privacy_noise_level(float value) {
  _internal_set_differential_privacy_noise_level(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000200U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.differential_privacy_noise_level)
}
inline float TrainerSpec::_internal_differential_privacy_noise_level() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.differential_privacy_noise_level_;
}
inline void TrainerSpec::_internal_set_differential_privacy_noise_level(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.differential_privacy_noise_level_ = value;
}

// optional uint64 differential_privacy_clipping_threshold = 52 [default = 0];
inline bool TrainerSpec::has_differential_privacy_clipping_threshold() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000100U);
  return value;
}
inline void TrainerSpec::clear_differential_privacy_clipping_threshold() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.differential_privacy_clipping_threshold_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[1], 0x00000100U);
}
inline ::uint64_t TrainerSpec::differential_privacy_clipping_threshold() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.differential_privacy_clipping_threshold)
  return _internal_differential_privacy_clipping_threshold();
}
inline void TrainerSpec::set_differential_privacy_clipping_threshold(::uint64_t value) {
  _internal_set_differential_privacy_clipping_threshold(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000100U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.differential_privacy_clipping_threshold)
}
inline ::uint64_t TrainerSpec::_internal_differential_privacy_clipping_threshold() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.differential_privacy_clipping_threshold_;
}
inline void TrainerSpec::_internal_set_differential_privacy_clipping_threshold(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.differential_privacy_clipping_threshold_ = value;
}

// optional float character_coverage = 10 [default = 0.9995];
inline bool TrainerSpec::has_character_coverage() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00020000U);
  return value;
}
inline void TrainerSpec::clear_character_coverage() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.character_coverage_ = 0.9995f;
  ClearHasBit(_impl_._has_bits_[0], 0x00020000U);
}
inline float TrainerSpec::character_coverage() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.character_coverage)
  return _internal_character_coverage();
}
inline void TrainerSpec::set_character_coverage(float value) {
  _internal_set_character_coverage(value);
  SetHasBit(_impl_._has_bits_[0], 0x00020000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.character_coverage)
}
inline float TrainerSpec::_internal_character_coverage() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.character_coverage_;
}
inline void TrainerSpec::_internal_set_character_coverage(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.character_coverage_ = value;
}

// optional uint64 input_sentence_size = 11 [default = 0];
inline bool TrainerSpec::has_input_sentence_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000400U);
  return value;
}
inline void TrainerSpec::clear_input_sentence_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_sentence_size_ = ::uint64_t{0u};
  ClearHasBit(_impl_._has_bits_[0], 0x00000400U);
}
inline ::uint64_t TrainerSpec::input_sentence_size() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.input_sentence_size)
  return _internal_input_sentence_size();
}
inline void TrainerSpec::set_input_sentence_size(::uint64_t value) {
  _internal_set_input_sentence_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000400U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.input_sentence_size)
}
inline ::uint64_t TrainerSpec::_internal_input_sentence_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.input_sentence_size_;
}
inline void TrainerSpec::_internal_set_input_sentence_size(::uint64_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_sentence_size_ = value;
}

// optional bool shuffle_input_sentence = 19 [default = true];
inline bool TrainerSpec::has_shuffle_input_sentence() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x01000000U);
  return value;
}
inline void TrainerSpec::clear_shuffle_input_sentence() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shuffle_input_sentence_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x01000000U);
}
inline bool TrainerSpec::shuffle_input_sentence() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.shuffle_input_sentence)
  return _internal_shuffle_input_sentence();
}
inline void TrainerSpec::set_shuffle_input_sentence(bool value) {
  _internal_set_shuffle_input_sentence(value);
  SetHasBit(_impl_._has_bits_[0], 0x01000000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.shuffle_input_sentence)
}
inline bool TrainerSpec::_internal_shuffle_input_sentence() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shuffle_input_sentence_;
}
inline void TrainerSpec::_internal_set_shuffle_input_sentence(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shuffle_input_sentence_ = value;
}

// optional int32 mining_sentence_size = 12 [deprecated = true];
inline bool TrainerSpec::has_mining_sentence_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000200U);
  return value;
}
inline void TrainerSpec::clear_mining_sentence_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mining_sentence_size_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000200U);
}
inline ::int32_t TrainerSpec::mining_sentence_size() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.mining_sentence_size)
  return _internal_mining_sentence_size();
}
inline void TrainerSpec::set_mining_sentence_size(::int32_t value) {
  _internal_set_mining_sentence_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000200U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.mining_sentence_size)
}
inline ::int32_t TrainerSpec::_internal_mining_sentence_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.mining_sentence_size_;
}
inline void TrainerSpec::_internal_set_mining_sentence_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.mining_sentence_size_ = value;
}

// optional int32 training_sentence_size = 13 [deprecated = true];
inline bool TrainerSpec::has_training_sentence_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000800U);
  return value;
}
inline void TrainerSpec::clear_training_sentence_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.training_sentence_size_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000800U);
}
inline ::int32_t TrainerSpec::training_sentence_size() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.training_sentence_size)
  return _internal_training_sentence_size();
}
inline void TrainerSpec::set_training_sentence_size(::int32_t value) {
  _internal_set_training_sentence_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000800U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.training_sentence_size)
}
inline ::int32_t TrainerSpec::_internal_training_sentence_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.training_sentence_size_;
}
inline void TrainerSpec::_internal_set_training_sentence_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.training_sentence_size_ = value;
}

// optional int32 seed_sentencepiece_size = 14 [default = 1000000];
inline bool TrainerSpec::has_seed_sentencepiece_size() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00040000U);
  return value;
}
inline void TrainerSpec::clear_seed_sentencepiece_size() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seed_sentencepiece_size_ = 1000000;
  ClearHasBit(_impl_._has_bits_[0], 0x00040000U);
}
inline ::int32_t TrainerSpec::seed_sentencepiece_size() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.seed_sentencepiece_size)
  return _internal_seed_sentencepiece_size();
}
inline void TrainerSpec::set_seed_sentencepiece_size(::int32_t value) {
  _internal_set_seed_sentencepiece_size(value);
  SetHasBit(_impl_._has_bits_[0], 0x00040000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.seed_sentencepiece_size)
}
inline ::int32_t TrainerSpec::_internal_seed_sentencepiece_size() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.seed_sentencepiece_size_;
}
inline void TrainerSpec::_internal_set_seed_sentencepiece_size(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seed_sentencepiece_size_ = value;
}

// optional float shrinking_factor = 15 [default = 0.75];
inline bool TrainerSpec::has_shrinking_factor() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00080000U);
  return value;
}
inline void TrainerSpec::clear_shrinking_factor() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shrinking_factor_ = 0.75f;
  ClearHasBit(_impl_._has_bits_[0], 0x00080000U);
}
inline float TrainerSpec::shrinking_factor() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.shrinking_factor)
  return _internal_shrinking_factor();
}
inline void TrainerSpec::set_shrinking_factor(float value) {
  _internal_set_shrinking_factor(value);
  SetHasBit(_impl_._has_bits_[0], 0x00080000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.shrinking_factor)
}
inline float TrainerSpec::_internal_shrinking_factor() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.shrinking_factor_;
}
inline void TrainerSpec::_internal_set_shrinking_factor(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.shrinking_factor_ = value;
}

// optional int32 max_sentence_length = 18 [default = 4192];
inline bool TrainerSpec::has_max_sentence_length() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00400000U);
  return value;
}
inline void TrainerSpec::clear_max_sentence_length() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_sentence_length_ = 4192;
  ClearHasBit(_impl_._has_bits_[0], 0x00400000U);
}
inline ::int32_t TrainerSpec::max_sentence_length() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.max_sentence_length)
  return _internal_max_sentence_length();
}
inline void TrainerSpec::set_max_sentence_length(::int32_t value) {
  _internal_set_max_sentence_length(value);
  SetHasBit(_impl_._has_bits_[0], 0x00400000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.max_sentence_length)
}
inline ::int32_t TrainerSpec::_internal_max_sentence_length() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_sentence_length_;
}
inline void TrainerSpec::_internal_set_max_sentence_length(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_sentence_length_ = value;
}

// optional int32 num_threads = 16 [default = 16];
inline bool TrainerSpec::has_num_threads() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00100000U);
  return value;
}
inline void TrainerSpec::clear_num_threads() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_threads_ = 16;
  ClearHasBit(_impl_._has_bits_[0], 0x00100000U);
}
inline ::int32_t TrainerSpec::num_threads() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.num_threads)
  return _internal_num_threads();
}
inline void TrainerSpec::set_num_threads(::int32_t value) {
  _internal_set_num_threads(value);
  SetHasBit(_impl_._has_bits_[0], 0x00100000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.num_threads)
}
inline ::int32_t TrainerSpec::_internal_num_threads() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_threads_;
}
inline void TrainerSpec::_internal_set_num_threads(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_threads_ = value;
}

// optional int32 num_sub_iterations = 17 [default = 2];
inline bool TrainerSpec::has_num_sub_iterations() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00200000U);
  return value;
}
inline void TrainerSpec::clear_num_sub_iterations() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_sub_iterations_ = 2;
  ClearHasBit(_impl_._has_bits_[0], 0x00200000U);
}
inline ::int32_t TrainerSpec::num_sub_iterations() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.num_sub_iterations)
  return _internal_num_sub_iterations();
}
inline void TrainerSpec::set_num_sub_iterations(::int32_t value) {
  _internal_set_num_sub_iterations(value);
  SetHasBit(_impl_._has_bits_[0], 0x00200000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.num_sub_iterations)
}
inline ::int32_t TrainerSpec::_internal_num_sub_iterations() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.num_sub_iterations_;
}
inline void TrainerSpec::_internal_set_num_sub_iterations(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.num_sub_iterations_ = value;
}

// optional int32 max_sentencepiece_length = 20 [default = 16];
inline bool TrainerSpec::has_max_sentencepiece_length() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00800000U);
  return value;
}
inline void TrainerSpec::clear_max_sentencepiece_length() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_sentencepiece_length_ = 16;
  ClearHasBit(_impl_._has_bits_[0], 0x00800000U);
}
inline ::int32_t TrainerSpec::max_sentencepiece_length() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.max_sentencepiece_length)
  return _internal_max_sentencepiece_length();
}
inline void TrainerSpec::set_max_sentencepiece_length(::int32_t value) {
  _internal_set_max_sentencepiece_length(value);
  SetHasBit(_impl_._has_bits_[0], 0x00800000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.max_sentencepiece_length)
}
inline ::int32_t TrainerSpec::_internal_max_sentencepiece_length() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.max_sentencepiece_length_;
}
inline void TrainerSpec::_internal_set_max_sentencepiece_length(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.max_sentencepiece_length_ = value;
}

// optional bool split_by_unicode_script = 21 [default = true];
inline bool TrainerSpec::has_split_by_unicode_script() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x02000000U);
  return value;
}
inline void TrainerSpec::clear_split_by_unicode_script() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.split_by_unicode_script_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x02000000U);
}
inline bool TrainerSpec::split_by_unicode_script() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.split_by_unicode_script)
  return _internal_split_by_unicode_script();
}
inline void TrainerSpec::set_split_by_unicode_script(bool value) {
  _internal_set_split_by_unicode_script(value);
  SetHasBit(_impl_._has_bits_[0], 0x02000000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.split_by_unicode_script)
}
inline bool TrainerSpec::_internal_split_by_unicode_script() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.split_by_unicode_script_;
}
inline void TrainerSpec::_internal_set_split_by_unicode_script(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.split_by_unicode_script_ = value;
}

// optional bool split_by_number = 23 [default = true];
inline bool TrainerSpec::has_split_by_number() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x08000000U);
  return value;
}
inline void TrainerSpec::clear_split_by_number() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.split_by_number_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x08000000U);
}
inline bool TrainerSpec::split_by_number() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.split_by_number)
  return _internal_split_by_number();
}
inline void TrainerSpec::set_split_by_number(bool value) {
  _internal_set_split_by_number(value);
  SetHasBit(_impl_._has_bits_[0], 0x08000000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.split_by_number)
}
inline bool TrainerSpec::_internal_split_by_number() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.split_by_number_;
}
inline void TrainerSpec::_internal_set_split_by_number(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.split_by_number_ = value;
}

// optional bool split_by_whitespace = 22 [default = true];
inline bool TrainerSpec::has_split_by_whitespace() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x04000000U);
  return value;
}
inline void TrainerSpec::clear_split_by_whitespace() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.split_by_whitespace_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x04000000U);
}
inline bool TrainerSpec::split_by_whitespace() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.split_by_whitespace)
  return _internal_split_by_whitespace();
}
inline void TrainerSpec::set_split_by_whitespace(bool value) {
  _internal_set_split_by_whitespace(value);
  SetHasBit(_impl_._has_bits_[0], 0x04000000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.split_by_whitespace)
}
inline bool TrainerSpec::_internal_split_by_whitespace() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.split_by_whitespace_;
}
inline void TrainerSpec::_internal_set_split_by_whitespace(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.split_by_whitespace_ = value;
}

// optional bool treat_whitespace_as_suffix = 24 [default = false];
inline bool TrainerSpec::has_treat_whitespace_as_suffix() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00001000U);
  return value;
}
inline void TrainerSpec::clear_treat_whitespace_as_suffix() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.treat_whitespace_as_suffix_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00001000U);
}
inline bool TrainerSpec::treat_whitespace_as_suffix() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.treat_whitespace_as_suffix)
  return _internal_treat_whitespace_as_suffix();
}
inline void TrainerSpec::set_treat_whitespace_as_suffix(bool value) {
  _internal_set_treat_whitespace_as_suffix(value);
  SetHasBit(_impl_._has_bits_[0], 0x00001000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.treat_whitespace_as_suffix)
}
inline bool TrainerSpec::_internal_treat_whitespace_as_suffix() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.treat_whitespace_as_suffix_;
}
inline void TrainerSpec::_internal_set_treat_whitespace_as_suffix(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.treat_whitespace_as_suffix_ = value;
}

// optional bool allow_whitespace_only_pieces = 26 [default = false];
inline bool TrainerSpec::has_allow_whitespace_only_pieces() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00004000U);
  return value;
}
inline void TrainerSpec::clear_allow_whitespace_only_pieces() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_whitespace_only_pieces_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00004000U);
}
inline bool TrainerSpec::allow_whitespace_only_pieces() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.allow_whitespace_only_pieces)
  return _internal_allow_whitespace_only_pieces();
}
inline void TrainerSpec::set_allow_whitespace_only_pieces(bool value) {
  _internal_set_allow_whitespace_only_pieces(value);
  SetHasBit(_impl_._has_bits_[0], 0x00004000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.allow_whitespace_only_pieces)
}
inline bool TrainerSpec::_internal_allow_whitespace_only_pieces() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.allow_whitespace_only_pieces_;
}
inline void TrainerSpec::_internal_set_allow_whitespace_only_pieces(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.allow_whitespace_only_pieces_ = value;
}

// optional bool split_digits = 25 [default = false];
inline bool TrainerSpec::has_split_digits() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00002000U);
  return value;
}
inline void TrainerSpec::clear_split_digits() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.split_digits_ = false;
  ClearHasBit(_impl_._has_bits_[0], 0x00002000U);
}
inline bool TrainerSpec::split_digits() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.split_digits)
  return _internal_split_digits();
}
inline void TrainerSpec::set_split_digits(bool value) {
  _internal_set_split_digits(value);
  SetHasBit(_impl_._has_bits_[0], 0x00002000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.split_digits)
}
inline bool TrainerSpec::_internal_split_digits() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.split_digits_;
}
inline void TrainerSpec::_internal_set_split_digits(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.split_digits_ = value;
}

// optional string pretokenization_delimiter = 53 [default = ""];
inline bool TrainerSpec::has_pretokenization_delimiter() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000002U);
  return value;
}
inline void TrainerSpec::clear_pretokenization_delimiter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pretokenization_delimiter_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[1], 0x00000002U);
}
inline const ::std::string& TrainerSpec::pretokenization_delimiter() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.pretokenization_delimiter)
  return _internal_pretokenization_delimiter();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TrainerSpec::set_pretokenization_delimiter(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000002U);
  _impl_.pretokenization_delimiter_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.pretokenization_delimiter)
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_pretokenization_delimiter()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000002U);
  ::std::string* _s = _internal_mutable_pretokenization_delimiter();
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.pretokenization_delimiter)
  return _s;
}
inline const ::std::string& TrainerSpec::_internal_pretokenization_delimiter() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.pretokenization_delimiter_.Get();
}
inline void TrainerSpec::_internal_set_pretokenization_delimiter(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pretokenization_delimiter_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::_internal_mutable_pretokenization_delimiter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.pretokenization_delimiter_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TrainerSpec::release_pretokenization_delimiter() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.pretokenization_delimiter)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000002U);
  auto* released = _impl_.pretokenization_delimiter_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.pretokenization_delimiter_.Set("", GetArena());
  }
  return released;
}
inline void TrainerSpec::set_allocated_pretokenization_delimiter(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000002U);
  }
  _impl_.pretokenization_delimiter_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.pretokenization_delimiter_.IsDefault()) {
    _impl_.pretokenization_delimiter_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.pretokenization_delimiter)
}

// repeated string control_symbols = 30;
inline int TrainerSpec::_internal_control_symbols_size() const {
  return _internal_control_symbols().size();
}
inline int TrainerSpec::control_symbols_size() const {
  return _internal_control_symbols_size();
}
inline void TrainerSpec::clear_control_symbols() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.control_symbols_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::add_control_symbols()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_control_symbols()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add_mutable:sentencepiece.TrainerSpec.control_symbols)
  return _s;
}
inline const ::std::string& TrainerSpec::control_symbols(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.control_symbols)
  return _internal_control_symbols().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_control_symbols(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.control_symbols)
  return _internal_mutable_control_symbols()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void TrainerSpec::set_control_symbols(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_control_symbols()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.control_symbols)
}
template <typename Arg_, typename... Args_>
inline void TrainerSpec::add_control_symbols(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_control_symbols(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.control_symbols)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& TrainerSpec::control_symbols()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.control_symbols)
  return _internal_control_symbols();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
TrainerSpec::mutable_control_symbols() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_mutable_list:sentencepiece.TrainerSpec.control_symbols)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_control_symbols();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
TrainerSpec::_internal_control_symbols() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.control_symbols_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
TrainerSpec::_internal_mutable_control_symbols() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.control_symbols_;
}

// repeated string user_defined_symbols = 31;
inline int TrainerSpec::_internal_user_defined_symbols_size() const {
  return _internal_user_defined_symbols().size();
}
inline int TrainerSpec::user_defined_symbols_size() const {
  return _internal_user_defined_symbols_size();
}
inline void TrainerSpec::clear_user_defined_symbols() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.user_defined_symbols_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::add_user_defined_symbols()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::std::string* _s =
      _internal_mutable_user_defined_symbols()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_add_mutable:sentencepiece.TrainerSpec.user_defined_symbols)
  return _s;
}
inline const ::std::string& TrainerSpec::user_defined_symbols(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.user_defined_symbols)
  return _internal_user_defined_symbols().Get(index);
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_user_defined_symbols(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.user_defined_symbols)
  return _internal_mutable_user_defined_symbols()->Mutable(index);
}
template <typename Arg_, typename... Args_>
inline void TrainerSpec::set_user_defined_symbols(int index, Arg_&& value, Args_... args) {
  ::google::protobuf::internal::AssignToString(
      *_internal_mutable_user_defined_symbols()->Mutable(index),
      ::std::forward<Arg_>(value), args... );
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.user_defined_symbols)
}
template <typename Arg_, typename... Args_>
inline void TrainerSpec::add_user_defined_symbols(Arg_&& value, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::google::protobuf::internal::AddToRepeatedPtrField(
      ::google::protobuf::MessageLite::internal_visibility(), GetArena(),
      *_internal_mutable_user_defined_symbols(), ::std::forward<Arg_>(value),
      args... );
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.user_defined_symbols)
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>& TrainerSpec::user_defined_symbols()
    const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.user_defined_symbols)
  return _internal_user_defined_symbols();
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
TrainerSpec::mutable_user_defined_symbols() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_mutable_list:sentencepiece.TrainerSpec.user_defined_symbols)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_user_defined_symbols();
}
inline const ::google::protobuf::RepeatedPtrField<::std::string>&
TrainerSpec::_internal_user_defined_symbols() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.user_defined_symbols_;
}
inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL
TrainerSpec::_internal_mutable_user_defined_symbols() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.user_defined_symbols_;
}

// optional string required_chars = 36;
inline bool TrainerSpec::has_required_chars() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x20000000U);
  return value;
}
inline void TrainerSpec::clear_required_chars() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.required_chars_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
}
inline const ::std::string& TrainerSpec::required_chars() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.required_chars)
  return _internal_required_chars();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TrainerSpec::set_required_chars(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  _impl_.required_chars_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.required_chars)
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_required_chars()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  ::std::string* _s = _internal_mutable_required_chars();
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.required_chars)
  return _s;
}
inline const ::std::string& TrainerSpec::_internal_required_chars() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.required_chars_.Get();
}
inline void TrainerSpec::_internal_set_required_chars(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.required_chars_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::_internal_mutable_required_chars() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.required_chars_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TrainerSpec::release_required_chars() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.required_chars)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x20000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
  auto* released = _impl_.required_chars_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.required_chars_.Set("", GetArena());
  }
  return released;
}
inline void TrainerSpec::set_allocated_required_chars(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x20000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x20000000U);
  }
  _impl_.required_chars_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.required_chars_.IsDefault()) {
    _impl_.required_chars_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.required_chars)
}

// optional bool byte_fallback = 35 [default = false];
inline bool TrainerSpec::has_byte_fallback() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000020U);
  return value;
}
inline void TrainerSpec::clear_byte_fallback() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.byte_fallback_ = false;
  ClearHasBit(_impl_._has_bits_[1], 0x00000020U);
}
inline bool TrainerSpec::byte_fallback() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.byte_fallback)
  return _internal_byte_fallback();
}
inline void TrainerSpec::set_byte_fallback(bool value) {
  _internal_set_byte_fallback(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000020U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.byte_fallback)
}
inline bool TrainerSpec::_internal_byte_fallback() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.byte_fallback_;
}
inline void TrainerSpec::_internal_set_byte_fallback(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.byte_fallback_ = value;
}

// optional bool vocabulary_output_piece_score = 32 [default = true];
inline bool TrainerSpec::has_vocabulary_output_piece_score() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000800U);
  return value;
}
inline void TrainerSpec::clear_vocabulary_output_piece_score() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.vocabulary_output_piece_score_ = true;
  ClearHasBit(_impl_._has_bits_[1], 0x00000800U);
}
inline bool TrainerSpec::vocabulary_output_piece_score() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.vocabulary_output_piece_score)
  return _internal_vocabulary_output_piece_score();
}
inline void TrainerSpec::set_vocabulary_output_piece_score(bool value) {
  _internal_set_vocabulary_output_piece_score(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000800U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.vocabulary_output_piece_score)
}
inline bool TrainerSpec::_internal_vocabulary_output_piece_score() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.vocabulary_output_piece_score_;
}
inline void TrainerSpec::_internal_set_vocabulary_output_piece_score(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.vocabulary_output_piece_score_ = value;
}

// optional bool hard_vocab_limit = 33 [default = true];
inline bool TrainerSpec::has_hard_vocab_limit() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00001000U);
  return value;
}
inline void TrainerSpec::clear_hard_vocab_limit() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hard_vocab_limit_ = true;
  ClearHasBit(_impl_._has_bits_[1], 0x00001000U);
}
inline bool TrainerSpec::hard_vocab_limit() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.hard_vocab_limit)
  return _internal_hard_vocab_limit();
}
inline void TrainerSpec::set_hard_vocab_limit(bool value) {
  _internal_set_hard_vocab_limit(value);
  SetHasBit(_impl_._has_bits_[1], 0x00001000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.hard_vocab_limit)
}
inline bool TrainerSpec::_internal_hard_vocab_limit() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.hard_vocab_limit_;
}
inline void TrainerSpec::_internal_set_hard_vocab_limit(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.hard_vocab_limit_ = value;
}

// optional bool use_all_vocab = 34 [default = false];
inline bool TrainerSpec::has_use_all_vocab() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000010U);
  return value;
}
inline void TrainerSpec::clear_use_all_vocab() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_all_vocab_ = false;
  ClearHasBit(_impl_._has_bits_[1], 0x00000010U);
}
inline bool TrainerSpec::use_all_vocab() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.use_all_vocab)
  return _internal_use_all_vocab();
}
inline void TrainerSpec::set_use_all_vocab(bool value) {
  _internal_set_use_all_vocab(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000010U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.use_all_vocab)
}
inline bool TrainerSpec::_internal_use_all_vocab() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.use_all_vocab_;
}
inline void TrainerSpec::_internal_set_use_all_vocab(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.use_all_vocab_ = value;
}

// optional int32 unk_id = 40 [default = 0];
inline bool TrainerSpec::has_unk_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000008U);
  return value;
}
inline void TrainerSpec::clear_unk_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.unk_id_ = 0;
  ClearHasBit(_impl_._has_bits_[1], 0x00000008U);
}
inline ::int32_t TrainerSpec::unk_id() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_id)
  return _internal_unk_id();
}
inline void TrainerSpec::set_unk_id(::int32_t value) {
  _internal_set_unk_id(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000008U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.unk_id)
}
inline ::int32_t TrainerSpec::_internal_unk_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.unk_id_;
}
inline void TrainerSpec::_internal_set_unk_id(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.unk_id_ = value;
}

// optional int32 bos_id = 41 [default = 1];
inline bool TrainerSpec::has_bos_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00002000U);
  return value;
}
inline void TrainerSpec::clear_bos_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bos_id_ = 1;
  ClearHasBit(_impl_._has_bits_[1], 0x00002000U);
}
inline ::int32_t TrainerSpec::bos_id() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.bos_id)
  return _internal_bos_id();
}
inline void TrainerSpec::set_bos_id(::int32_t value) {
  _internal_set_bos_id(value);
  SetHasBit(_impl_._has_bits_[1], 0x00002000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.bos_id)
}
inline ::int32_t TrainerSpec::_internal_bos_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.bos_id_;
}
inline void TrainerSpec::_internal_set_bos_id(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bos_id_ = value;
}

// optional int32 eos_id = 42 [default = 2];
inline bool TrainerSpec::has_eos_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000400U);
  return value;
}
inline void TrainerSpec::clear_eos_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.eos_id_ = 2;
  ClearHasBit(_impl_._has_bits_[1], 0x00000400U);
}
inline ::int32_t TrainerSpec::eos_id() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.eos_id)
  return _internal_eos_id();
}
inline void TrainerSpec::set_eos_id(::int32_t value) {
  _internal_set_eos_id(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000400U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.eos_id)
}
inline ::int32_t TrainerSpec::_internal_eos_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.eos_id_;
}
inline void TrainerSpec::_internal_set_eos_id(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.eos_id_ = value;
}

// optional int32 pad_id = 43 [default = -1];
inline bool TrainerSpec::has_pad_id() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x10000000U);
  return value;
}
inline void TrainerSpec::clear_pad_id() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pad_id_ = -1;
  ClearHasBit(_impl_._has_bits_[0], 0x10000000U);
}
inline ::int32_t TrainerSpec::pad_id() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.pad_id)
  return _internal_pad_id();
}
inline void TrainerSpec::set_pad_id(::int32_t value) {
  _internal_set_pad_id(value);
  SetHasBit(_impl_._has_bits_[0], 0x10000000U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.pad_id)
}
inline ::int32_t TrainerSpec::_internal_pad_id() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.pad_id_;
}
inline void TrainerSpec::_internal_set_pad_id(::int32_t value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pad_id_ = value;
}

// optional string unk_piece = 45 [default = "<unk>"];
inline bool TrainerSpec::has_unk_piece() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000080U);
  return value;
}
inline void TrainerSpec::clear_unk_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.unk_piece_.ClearToDefault(::sentencepiece::TrainerSpec::Impl_::_i_give_permission_to_break_this_code_default_unk_piece_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
}
inline const ::std::string& TrainerSpec::unk_piece() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_piece)
  if (_impl_.unk_piece_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_unk_piece_.get();
  }
  return _internal_unk_piece();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TrainerSpec::set_unk_piece(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  _impl_.unk_piece_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.unk_piece)
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_unk_piece()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  ::std::string* _s = _internal_mutable_unk_piece();
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.unk_piece)
  return _s;
}
inline const ::std::string& TrainerSpec::_internal_unk_piece() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.unk_piece_.Get();
}
inline void TrainerSpec::_internal_set_unk_piece(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.unk_piece_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::_internal_mutable_unk_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.unk_piece_.Mutable(::sentencepiece::TrainerSpec::Impl_::_i_give_permission_to_break_this_code_default_unk_piece_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TrainerSpec::release_unk_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.unk_piece)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000080U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  return _impl_.unk_piece_.Release();
}
inline void TrainerSpec::set_allocated_unk_piece(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000080U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000080U);
  }
  _impl_.unk_piece_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.unk_piece)
}

// optional string bos_piece = 46 [default = "<s>"];
inline bool TrainerSpec::has_bos_piece() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x40000000U);
  return value;
}
inline void TrainerSpec::clear_bos_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bos_piece_.ClearToDefault(::sentencepiece::TrainerSpec::Impl_::_i_give_permission_to_break_this_code_default_bos_piece_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
}
inline const ::std::string& TrainerSpec::bos_piece() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.bos_piece)
  if (_impl_.bos_piece_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_bos_piece_.get();
  }
  return _internal_bos_piece();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TrainerSpec::set_bos_piece(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  _impl_.bos_piece_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.bos_piece)
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_bos_piece()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  ::std::string* _s = _internal_mutable_bos_piece();
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.bos_piece)
  return _s;
}
inline const ::std::string& TrainerSpec::_internal_bos_piece() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.bos_piece_.Get();
}
inline void TrainerSpec::_internal_set_bos_piece(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.bos_piece_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::_internal_mutable_bos_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.bos_piece_.Mutable(::sentencepiece::TrainerSpec::Impl_::_i_give_permission_to_break_this_code_default_bos_piece_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TrainerSpec::release_bos_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.bos_piece)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x40000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
  return _impl_.bos_piece_.Release();
}
inline void TrainerSpec::set_allocated_bos_piece(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x40000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x40000000U);
  }
  _impl_.bos_piece_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.bos_piece)
}

// optional string eos_piece = 47 [default = "</s>"];
inline bool TrainerSpec::has_eos_piece() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x80000000U);
  return value;
}
inline void TrainerSpec::clear_eos_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.eos_piece_.ClearToDefault(::sentencepiece::TrainerSpec::Impl_::_i_give_permission_to_break_this_code_default_eos_piece_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
}
inline const ::std::string& TrainerSpec::eos_piece() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.eos_piece)
  if (_impl_.eos_piece_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_eos_piece_.get();
  }
  return _internal_eos_piece();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TrainerSpec::set_eos_piece(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  _impl_.eos_piece_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.eos_piece)
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_eos_piece()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  ::std::string* _s = _internal_mutable_eos_piece();
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.eos_piece)
  return _s;
}
inline const ::std::string& TrainerSpec::_internal_eos_piece() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.eos_piece_.Get();
}
inline void TrainerSpec::_internal_set_eos_piece(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.eos_piece_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::_internal_mutable_eos_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.eos_piece_.Mutable(::sentencepiece::TrainerSpec::Impl_::_i_give_permission_to_break_this_code_default_eos_piece_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TrainerSpec::release_eos_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.eos_piece)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x80000000U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  return _impl_.eos_piece_.Release();
}
inline void TrainerSpec::set_allocated_eos_piece(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x80000000U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x80000000U);
  }
  _impl_.eos_piece_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.eos_piece)
}

// optional string pad_piece = 48 [default = "<pad>"];
inline bool TrainerSpec::has_pad_piece() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000001U);
  return value;
}
inline void TrainerSpec::clear_pad_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pad_piece_.ClearToDefault(::sentencepiece::TrainerSpec::Impl_::_i_give_permission_to_break_this_code_default_pad_piece_, GetArena());
  ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
}
inline const ::std::string& TrainerSpec::pad_piece() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.pad_piece)
  if (_impl_.pad_piece_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_pad_piece_.get();
  }
  return _internal_pad_piece();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TrainerSpec::set_pad_piece(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  _impl_.pad_piece_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.pad_piece)
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_pad_piece()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  ::std::string* _s = _internal_mutable_pad_piece();
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.pad_piece)
  return _s;
}
inline const ::std::string& TrainerSpec::_internal_pad_piece() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.pad_piece_.Get();
}
inline void TrainerSpec::_internal_set_pad_piece(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pad_piece_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::_internal_mutable_pad_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.pad_piece_.Mutable(::sentencepiece::TrainerSpec::Impl_::_i_give_permission_to_break_this_code_default_pad_piece_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TrainerSpec::release_pad_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.pad_piece)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  return _impl_.pad_piece_.Release();
}
inline void TrainerSpec::set_allocated_pad_piece(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000001U);
  }
  _impl_.pad_piece_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.pad_piece)
}

// optional string unk_surface = 44 [default = " \342\201\207 "];
inline bool TrainerSpec::has_unk_surface() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000040U);
  return value;
}
inline void TrainerSpec::clear_unk_surface() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.unk_surface_.ClearToDefault(::sentencepiece::TrainerSpec::Impl_::_i_give_permission_to_break_this_code_default_unk_surface_, GetArena());
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
}
inline const ::std::string& TrainerSpec::unk_surface() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_surface)
  if (_impl_.unk_surface_.IsDefault()) {
    return Impl_::_i_give_permission_to_break_this_code_default_unk_surface_.get();
  }
  return _internal_unk_surface();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TrainerSpec::set_unk_surface(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  _impl_.unk_surface_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.unk_surface)
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_unk_surface()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  ::std::string* _s = _internal_mutable_unk_surface();
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.unk_surface)
  return _s;
}
inline const ::std::string& TrainerSpec::_internal_unk_surface() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.unk_surface_.Get();
}
inline void TrainerSpec::_internal_set_unk_surface(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.unk_surface_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::_internal_mutable_unk_surface() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.unk_surface_.Mutable(::sentencepiece::TrainerSpec::Impl_::_i_give_permission_to_break_this_code_default_unk_surface_, GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TrainerSpec::release_unk_surface() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.unk_surface)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000040U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  return _impl_.unk_surface_.Release();
}
inline void TrainerSpec::set_allocated_unk_surface(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000040U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000040U);
  }
  _impl_.unk_surface_.SetAllocated(value, GetArena());
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.unk_surface)
}

// optional bool train_extremely_large_corpus = 49 [default = false];
inline bool TrainerSpec::has_train_extremely_large_corpus() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000040U);
  return value;
}
inline void TrainerSpec::clear_train_extremely_large_corpus() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.train_extremely_large_corpus_ = false;
  ClearHasBit(_impl_._has_bits_[1], 0x00000040U);
}
inline bool TrainerSpec::train_extremely_large_corpus() const {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.train_extremely_large_corpus)
  return _internal_train_extremely_large_corpus();
}
inline void TrainerSpec::set_train_extremely_large_corpus(bool value) {
  _internal_set_train_extremely_large_corpus(value);
  SetHasBit(_impl_._has_bits_[1], 0x00000040U);
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.train_extremely_large_corpus)
}
inline bool TrainerSpec::_internal_train_extremely_large_corpus() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.train_extremely_large_corpus_;
}
inline void TrainerSpec::_internal_set_train_extremely_large_corpus(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.train_extremely_large_corpus_ = value;
}

// optional string seed_sentencepieces_file = 54 [default = ""];
inline bool TrainerSpec::has_seed_sentencepieces_file() const {
  bool value = CheckHasBit(_impl_._has_bits_[1], 0x00000004U);
  return value;
}
inline void TrainerSpec::clear_seed_sentencepieces_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seed_sentencepieces_file_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[1], 0x00000004U);
}
inline const ::std::string& TrainerSpec::seed_sentencepieces_file() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.seed_sentencepieces_file)
  return _internal_seed_sentencepieces_file();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void TrainerSpec::set_seed_sentencepieces_file(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[1], 0x00000004U);
  _impl_.seed_sentencepieces_file_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.seed_sentencepieces_file)
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::mutable_seed_sentencepieces_file()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[1], 0x00000004U);
  ::std::string* _s = _internal_mutable_seed_sentencepieces_file();
  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.seed_sentencepieces_file)
  return _s;
}
inline const ::std::string& TrainerSpec::_internal_seed_sentencepieces_file() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.seed_sentencepieces_file_.Get();
}
inline void TrainerSpec::_internal_set_seed_sentencepieces_file(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.seed_sentencepieces_file_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL TrainerSpec::_internal_mutable_seed_sentencepieces_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.seed_sentencepieces_file_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE TrainerSpec::release_seed_sentencepieces_file() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.seed_sentencepieces_file)
  if (!CheckHasBit(_impl_._has_bits_[1], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[1], 0x00000004U);
  auto* released = _impl_.seed_sentencepieces_file_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.seed_sentencepieces_file_.Set("", GetArena());
  }
  return released;
}
inline void TrainerSpec::set_allocated_seed_sentencepieces_file(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[1], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[1], 0x00000004U);
  }
  _impl_.seed_sentencepieces_file_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.seed_sentencepieces_file_.IsDefault()) {
    _impl_.seed_sentencepieces_file_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.seed_sentencepieces_file)
}

// -------------------------------------------------------------------

// NormalizerSpec

// optional string name = 1;
inline bool NormalizerSpec::has_name() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void NormalizerSpec::clear_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& NormalizerSpec::name() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.name)
  return _internal_name();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NormalizerSpec::set_name(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.name_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.name)
}
inline ::std::string* PROTOBUF_NONNULL NormalizerSpec::mutable_name()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:sentencepiece.NormalizerSpec.name)
  return _s;
}
inline const ::std::string& NormalizerSpec::_internal_name() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.name_.Get();
}
inline void NormalizerSpec::_internal_set_name(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.name_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NormalizerSpec::_internal_mutable_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.name_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NormalizerSpec::release_name() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.NormalizerSpec.name)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.name_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.name_.Set("", GetArena());
  }
  return released;
}
inline void NormalizerSpec::set_allocated_name(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.name_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) {
    _impl_.name_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.NormalizerSpec.name)
}

// optional bytes precompiled_charsmap = 2;
inline bool NormalizerSpec::has_precompiled_charsmap() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void NormalizerSpec::clear_precompiled_charsmap() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.precompiled_charsmap_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& NormalizerSpec::precompiled_charsmap() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.precompiled_charsmap)
  return _internal_precompiled_charsmap();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NormalizerSpec::set_precompiled_charsmap(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.precompiled_charsmap_.SetBytes(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.precompiled_charsmap)
}
inline ::std::string* PROTOBUF_NONNULL NormalizerSpec::mutable_precompiled_charsmap()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_precompiled_charsmap();
  // @@protoc_insertion_point(field_mutable:sentencepiece.NormalizerSpec.precompiled_charsmap)
  return _s;
}
inline const ::std::string& NormalizerSpec::_internal_precompiled_charsmap() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.precompiled_charsmap_.Get();
}
inline void NormalizerSpec::_internal_set_precompiled_charsmap(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.precompiled_charsmap_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NormalizerSpec::_internal_mutable_precompiled_charsmap() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.precompiled_charsmap_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NormalizerSpec::release_precompiled_charsmap() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.NormalizerSpec.precompiled_charsmap)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.precompiled_charsmap_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.precompiled_charsmap_.Set("", GetArena());
  }
  return released;
}
inline void NormalizerSpec::set_allocated_precompiled_charsmap(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.precompiled_charsmap_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.precompiled_charsmap_.IsDefault()) {
    _impl_.precompiled_charsmap_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.NormalizerSpec.precompiled_charsmap)
}

// optional bool add_dummy_prefix = 3 [default = true];
inline bool NormalizerSpec::has_add_dummy_prefix() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  return value;
}
inline void NormalizerSpec::clear_add_dummy_prefix() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_dummy_prefix_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline bool NormalizerSpec::add_dummy_prefix() const {
  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.add_dummy_prefix)
  return _internal_add_dummy_prefix();
}
inline void NormalizerSpec::set_add_dummy_prefix(bool value) {
  _internal_set_add_dummy_prefix(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.add_dummy_prefix)
}
inline bool NormalizerSpec::_internal_add_dummy_prefix() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.add_dummy_prefix_;
}
inline void NormalizerSpec::_internal_set_add_dummy_prefix(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.add_dummy_prefix_ = value;
}

// optional bool remove_extra_whitespaces = 4 [default = true];
inline bool NormalizerSpec::has_remove_extra_whitespaces() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  return value;
}
inline void NormalizerSpec::clear_remove_extra_whitespaces() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.remove_extra_whitespaces_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline bool NormalizerSpec::remove_extra_whitespaces() const {
  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.remove_extra_whitespaces)
  return _internal_remove_extra_whitespaces();
}
inline void NormalizerSpec::set_remove_extra_whitespaces(bool value) {
  _internal_set_remove_extra_whitespaces(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.remove_extra_whitespaces)
}
inline bool NormalizerSpec::_internal_remove_extra_whitespaces() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.remove_extra_whitespaces_;
}
inline void NormalizerSpec::_internal_set_remove_extra_whitespaces(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.remove_extra_whitespaces_ = value;
}

// optional bool escape_whitespaces = 5 [default = true];
inline bool NormalizerSpec::has_escape_whitespaces() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U);
  return value;
}
inline void NormalizerSpec::clear_escape_whitespaces() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.escape_whitespaces_ = true;
  ClearHasBit(_impl_._has_bits_[0], 0x00000020U);
}
inline bool NormalizerSpec::escape_whitespaces() const {
  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.escape_whitespaces)
  return _internal_escape_whitespaces();
}
inline void NormalizerSpec::set_escape_whitespaces(bool value) {
  _internal_set_escape_whitespaces(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000020U);
  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.escape_whitespaces)
}
inline bool NormalizerSpec::_internal_escape_whitespaces() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.escape_whitespaces_;
}
inline void NormalizerSpec::_internal_set_escape_whitespaces(bool value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.escape_whitespaces_ = value;
}

// optional string normalization_rule_tsv = 6;
inline bool NormalizerSpec::has_normalization_rule_tsv() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void NormalizerSpec::clear_normalization_rule_tsv() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.normalization_rule_tsv_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::std::string& NormalizerSpec::normalization_rule_tsv() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.normalization_rule_tsv)
  return _internal_normalization_rule_tsv();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void NormalizerSpec::set_normalization_rule_tsv(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  _impl_.normalization_rule_tsv_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.normalization_rule_tsv)
}
inline ::std::string* PROTOBUF_NONNULL NormalizerSpec::mutable_normalization_rule_tsv()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::std::string* _s = _internal_mutable_normalization_rule_tsv();
  // @@protoc_insertion_point(field_mutable:sentencepiece.NormalizerSpec.normalization_rule_tsv)
  return _s;
}
inline const ::std::string& NormalizerSpec::_internal_normalization_rule_tsv() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.normalization_rule_tsv_.Get();
}
inline void NormalizerSpec::_internal_set_normalization_rule_tsv(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.normalization_rule_tsv_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL NormalizerSpec::_internal_mutable_normalization_rule_tsv() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.normalization_rule_tsv_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE NormalizerSpec::release_normalization_rule_tsv() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.NormalizerSpec.normalization_rule_tsv)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  auto* released = _impl_.normalization_rule_tsv_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.normalization_rule_tsv_.Set("", GetArena());
  }
  return released;
}
inline void NormalizerSpec::set_allocated_normalization_rule_tsv(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  _impl_.normalization_rule_tsv_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.normalization_rule_tsv_.IsDefault()) {
    _impl_.normalization_rule_tsv_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.NormalizerSpec.normalization_rule_tsv)
}

// -------------------------------------------------------------------

// SelfTestData_Sample

// optional string input = 1;
inline bool SelfTestData_Sample::has_input() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void SelfTestData_Sample::clear_input() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& SelfTestData_Sample::input() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.SelfTestData.Sample.input)
  return _internal_input();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SelfTestData_Sample::set_input(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.input_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.SelfTestData.Sample.input)
}
inline ::std::string* PROTOBUF_NONNULL SelfTestData_Sample::mutable_input()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_input();
  // @@protoc_insertion_point(field_mutable:sentencepiece.SelfTestData.Sample.input)
  return _s;
}
inline const ::std::string& SelfTestData_Sample::_internal_input() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.input_.Get();
}
inline void SelfTestData_Sample::_internal_set_input(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.input_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SelfTestData_Sample::_internal_mutable_input() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.input_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SelfTestData_Sample::release_input() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.SelfTestData.Sample.input)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.input_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.input_.Set("", GetArena());
  }
  return released;
}
inline void SelfTestData_Sample::set_allocated_input(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.input_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.input_.IsDefault()) {
    _impl_.input_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.SelfTestData.Sample.input)
}

// optional string expected = 2;
inline bool SelfTestData_Sample::has_expected() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void SelfTestData_Sample::clear_expected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.expected_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::std::string& SelfTestData_Sample::expected() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.SelfTestData.Sample.expected)
  return _internal_expected();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void SelfTestData_Sample::set_expected(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  _impl_.expected_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.SelfTestData.Sample.expected)
}
inline ::std::string* PROTOBUF_NONNULL SelfTestData_Sample::mutable_expected()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::std::string* _s = _internal_mutable_expected();
  // @@protoc_insertion_point(field_mutable:sentencepiece.SelfTestData.Sample.expected)
  return _s;
}
inline const ::std::string& SelfTestData_Sample::_internal_expected() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.expected_.Get();
}
inline void SelfTestData_Sample::_internal_set_expected(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.expected_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL SelfTestData_Sample::_internal_mutable_expected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.expected_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE SelfTestData_Sample::release_expected() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.SelfTestData.Sample.expected)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  auto* released = _impl_.expected_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.expected_.Set("", GetArena());
  }
  return released;
}
inline void SelfTestData_Sample::set_allocated_expected(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  _impl_.expected_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.expected_.IsDefault()) {
    _impl_.expected_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.SelfTestData.Sample.expected)
}

// -------------------------------------------------------------------

// SelfTestData

// repeated .sentencepiece.SelfTestData.Sample samples = 1;
inline int SelfTestData::_internal_samples_size() const {
  return _internal_samples().size();
}
inline int SelfTestData::samples_size() const {
  return _internal_samples_size();
}
inline void SelfTestData::clear_samples() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.samples_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::sentencepiece::SelfTestData_Sample& SelfTestData::samples(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.SelfTestData.samples)
  return _internal_samples().Get(index);
}
inline ::sentencepiece::SelfTestData_Sample* PROTOBUF_NONNULL SelfTestData::mutable_samples(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:sentencepiece.SelfTestData.samples)
  return _internal_mutable_samples()->Mutable(index);
}
inline ::sentencepiece::SelfTestData_Sample* PROTOBUF_NONNULL SelfTestData::add_samples()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::sentencepiece::SelfTestData_Sample* _add =
      _internal_mutable_samples()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:sentencepiece.SelfTestData.samples)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::sentencepiece::SelfTestData_Sample>& SelfTestData::samples() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:sentencepiece.SelfTestData.samples)
  return _internal_samples();
}
inline ::google::protobuf::RepeatedPtrField<::sentencepiece::SelfTestData_Sample>* PROTOBUF_NONNULL
SelfTestData::mutable_samples() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:sentencepiece.SelfTestData.samples)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_samples();
}
inline const ::google::protobuf::RepeatedPtrField<::sentencepiece::SelfTestData_Sample>&
SelfTestData::_internal_samples() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.samples_;
}
inline ::google::protobuf::RepeatedPtrField<::sentencepiece::SelfTestData_Sample>* PROTOBUF_NONNULL
SelfTestData::_internal_mutable_samples() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.samples_;
}

// -------------------------------------------------------------------

// ModelProto_SentencePiece

// optional string piece = 1;
inline bool ModelProto_SentencePiece::has_piece() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U);
  return value;
}
inline void ModelProto_SentencePiece::clear_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.piece_.ClearToEmpty();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::std::string& ModelProto_SentencePiece::piece() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.piece)
  return _internal_piece();
}
template <typename Arg_, typename... Args_>
PROTOBUF_ALWAYS_INLINE void ModelProto_SentencePiece::set_piece(Arg_&& arg, Args_... args) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  _impl_.piece_.Set(static_cast<Arg_&&>(arg), args..., GetArena());
  // @@protoc_insertion_point(field_set:sentencepiece.ModelProto.SentencePiece.piece)
}
inline ::std::string* PROTOBUF_NONNULL ModelProto_SentencePiece::mutable_piece()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  ::std::string* _s = _internal_mutable_piece();
  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.SentencePiece.piece)
  return _s;
}
inline const ::std::string& ModelProto_SentencePiece::_internal_piece() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.piece_.Get();
}
inline void ModelProto_SentencePiece::_internal_set_piece(const ::std::string& value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.piece_.Set(value, GetArena());
}
inline ::std::string* PROTOBUF_NONNULL ModelProto_SentencePiece::_internal_mutable_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _impl_.piece_.Mutable( GetArena());
}
inline ::std::string* PROTOBUF_NULLABLE ModelProto_SentencePiece::release_piece() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.ModelProto.SentencePiece.piece)
  if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) {
    return nullptr;
  }
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  auto* released = _impl_.piece_.Release();
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) {
    _impl_.piece_.Set("", GetArena());
  }
  return released;
}
inline void ModelProto_SentencePiece::set_allocated_piece(::std::string* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
  }
  _impl_.piece_.SetAllocated(value, GetArena());
  if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.piece_.IsDefault()) {
    _impl_.piece_.Set("", GetArena());
  }
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.ModelProto.SentencePiece.piece)
}

// optional float score = 2;
inline bool ModelProto_SentencePiece::has_score() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  return value;
}
inline void ModelProto_SentencePiece::clear_score() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.score_ = 0;
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline float ModelProto_SentencePiece::score() const {
  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.score)
  return _internal_score();
}
inline void ModelProto_SentencePiece::set_score(float value) {
  _internal_set_score(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  // @@protoc_insertion_point(field_set:sentencepiece.ModelProto.SentencePiece.score)
}
inline float ModelProto_SentencePiece::_internal_score() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.score_;
}
inline void ModelProto_SentencePiece::_internal_set_score(float value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.score_ = value;
}

// optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
inline bool ModelProto_SentencePiece::has_type() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  return value;
}
inline void ModelProto_SentencePiece::clear_type() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.type_ = 1;
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline ::sentencepiece::ModelProto_SentencePiece_Type ModelProto_SentencePiece::type() const {
  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.type)
  return _internal_type();
}
inline void ModelProto_SentencePiece::set_type(::sentencepiece::ModelProto_SentencePiece_Type value) {
  _internal_set_type(value);
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  // @@protoc_insertion_point(field_set:sentencepiece.ModelProto.SentencePiece.type)
}
inline ::sentencepiece::ModelProto_SentencePiece_Type ModelProto_SentencePiece::_internal_type() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return static_cast<::sentencepiece::ModelProto_SentencePiece_Type>(_impl_.type_);
}
inline void ModelProto_SentencePiece::_internal_set_type(::sentencepiece::ModelProto_SentencePiece_Type value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);

                                          assert(::google::protobuf::internal::ValidateEnum(
                                              value, ::sentencepiece::ModelProto_SentencePiece_Type_internal_data_));
                                          _impl_.type_ = value;
}

// -------------------------------------------------------------------

// ModelProto

// repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
inline int ModelProto::_internal_pieces_size() const {
  return _internal_pieces().size();
}
inline int ModelProto::pieces_size() const {
  return _internal_pieces_size();
}
inline void ModelProto::clear_pieces() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  _impl_.pieces_.Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000001U);
}
inline const ::sentencepiece::ModelProto_SentencePiece& ModelProto::pieces(int index) const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.pieces)
  return _internal_pieces().Get(index);
}
inline ::sentencepiece::ModelProto_SentencePiece* PROTOBUF_NONNULL ModelProto::mutable_pieces(int index)
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.pieces)
  return _internal_mutable_pieces()->Mutable(index);
}
inline ::sentencepiece::ModelProto_SentencePiece* PROTOBUF_NONNULL ModelProto::add_pieces()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  ::sentencepiece::ModelProto_SentencePiece* _add =
      _internal_mutable_pieces()->InternalAddWithArena(
          ::google::protobuf::MessageLite::internal_visibility(), GetArena());
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_add:sentencepiece.ModelProto.pieces)
  return _add;
}
inline const ::google::protobuf::RepeatedPtrField<::sentencepiece::ModelProto_SentencePiece>& ModelProto::pieces() const
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_list:sentencepiece.ModelProto.pieces)
  return _internal_pieces();
}
inline ::google::protobuf::RepeatedPtrField<::sentencepiece::ModelProto_SentencePiece>* PROTOBUF_NONNULL
ModelProto::mutable_pieces() ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000001U);
  // @@protoc_insertion_point(field_mutable_list:sentencepiece.ModelProto.pieces)
  ::google::protobuf::internal::TSanWrite(&_impl_);
  return _internal_mutable_pieces();
}
inline const ::google::protobuf::RepeatedPtrField<::sentencepiece::ModelProto_SentencePiece>&
ModelProto::_internal_pieces() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return _impl_.pieces_;
}
inline ::google::protobuf::RepeatedPtrField<::sentencepiece::ModelProto_SentencePiece>* PROTOBUF_NONNULL
ModelProto::_internal_mutable_pieces() {
  ::google::protobuf::internal::TSanRead(&_impl_);
  return &_impl_.pieces_;
}

// optional .sentencepiece.TrainerSpec trainer_spec = 2;
inline bool ModelProto::has_trainer_spec() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U);
  PROTOBUF_ASSUME(!value || _impl_.trainer_spec_ != nullptr);
  return value;
}
inline void ModelProto::clear_trainer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.trainer_spec_ != nullptr) _impl_.trainer_spec_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
}
inline const ::sentencepiece::TrainerSpec& ModelProto::_internal_trainer_spec() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::sentencepiece::TrainerSpec* p = _impl_.trainer_spec_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::sentencepiece::TrainerSpec>(&::sentencepiece::TrainerSpec_globals_);
}
inline const ::sentencepiece::TrainerSpec& ModelProto::trainer_spec() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.trainer_spec)
  return _internal_trainer_spec();
}
inline void ModelProto::unsafe_arena_set_allocated_trainer_spec(
    ::sentencepiece::TrainerSpec* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.trainer_spec_);
  }
  _impl_.trainer_spec_ = reinterpret_cast<::sentencepiece::TrainerSpec*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentencepiece.ModelProto.trainer_spec)
}
inline ::sentencepiece::TrainerSpec* PROTOBUF_NULLABLE ModelProto::release_trainer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::sentencepiece::TrainerSpec* released = _impl_.trainer_spec_;
  _impl_.trainer_spec_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::sentencepiece::TrainerSpec* PROTOBUF_NULLABLE ModelProto::unsafe_arena_release_trainer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.ModelProto.trainer_spec)

  ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::sentencepiece::TrainerSpec* temp = _impl_.trainer_spec_;
  _impl_.trainer_spec_ = nullptr;
  return temp;
}
inline ::sentencepiece::TrainerSpec* PROTOBUF_NONNULL ModelProto::_internal_mutable_trainer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.trainer_spec_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::sentencepiece::TrainerSpec>(GetArena());
    _impl_.trainer_spec_ = reinterpret_cast<::sentencepiece::TrainerSpec*>(p);
  }
  return _impl_.trainer_spec_;
}
inline ::sentencepiece::TrainerSpec* PROTOBUF_NONNULL ModelProto::mutable_trainer_spec()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  ::sentencepiece::TrainerSpec* _msg = _internal_mutable_trainer_spec();
  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.trainer_spec)
  return _msg;
}
inline void ModelProto::set_allocated_trainer_spec(::sentencepiece::TrainerSpec* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.trainer_spec_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000002U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000002U);
  }

  _impl_.trainer_spec_ = reinterpret_cast<::sentencepiece::TrainerSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.ModelProto.trainer_spec)
}

// optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
inline bool ModelProto::has_normalizer_spec() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U);
  PROTOBUF_ASSUME(!value || _impl_.normalizer_spec_ != nullptr);
  return value;
}
inline void ModelProto::clear_normalizer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.normalizer_spec_ != nullptr) _impl_.normalizer_spec_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
}
inline const ::sentencepiece::NormalizerSpec& ModelProto::_internal_normalizer_spec() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::sentencepiece::NormalizerSpec* p = _impl_.normalizer_spec_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::sentencepiece::NormalizerSpec>(&::sentencepiece::NormalizerSpec_globals_);
}
inline const ::sentencepiece::NormalizerSpec& ModelProto::normalizer_spec() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.normalizer_spec)
  return _internal_normalizer_spec();
}
inline void ModelProto::unsafe_arena_set_allocated_normalizer_spec(
    ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.normalizer_spec_);
  }
  _impl_.normalizer_spec_ = reinterpret_cast<::sentencepiece::NormalizerSpec*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentencepiece.ModelProto.normalizer_spec)
}
inline ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE ModelProto::release_normalizer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::sentencepiece::NormalizerSpec* released = _impl_.normalizer_spec_;
  _impl_.normalizer_spec_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE ModelProto::unsafe_arena_release_normalizer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.ModelProto.normalizer_spec)

  ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::sentencepiece::NormalizerSpec* temp = _impl_.normalizer_spec_;
  _impl_.normalizer_spec_ = nullptr;
  return temp;
}
inline ::sentencepiece::NormalizerSpec* PROTOBUF_NONNULL ModelProto::_internal_mutable_normalizer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.normalizer_spec_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::sentencepiece::NormalizerSpec>(GetArena());
    _impl_.normalizer_spec_ = reinterpret_cast<::sentencepiece::NormalizerSpec*>(p);
  }
  return _impl_.normalizer_spec_;
}
inline ::sentencepiece::NormalizerSpec* PROTOBUF_NONNULL ModelProto::mutable_normalizer_spec()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  ::sentencepiece::NormalizerSpec* _msg = _internal_mutable_normalizer_spec();
  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.normalizer_spec)
  return _msg;
}
inline void ModelProto::set_allocated_normalizer_spec(::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.normalizer_spec_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000004U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000004U);
  }

  _impl_.normalizer_spec_ = reinterpret_cast<::sentencepiece::NormalizerSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.ModelProto.normalizer_spec)
}

// optional .sentencepiece.SelfTestData self_test_data = 4;
inline bool ModelProto::has_self_test_data() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U);
  PROTOBUF_ASSUME(!value || _impl_.self_test_data_ != nullptr);
  return value;
}
inline void ModelProto::clear_self_test_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.self_test_data_ != nullptr) _impl_.self_test_data_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
}
inline const ::sentencepiece::SelfTestData& ModelProto::_internal_self_test_data() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::sentencepiece::SelfTestData* p = _impl_.self_test_data_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::sentencepiece::SelfTestData>(&::sentencepiece::SelfTestData_globals_);
}
inline const ::sentencepiece::SelfTestData& ModelProto::self_test_data() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.self_test_data)
  return _internal_self_test_data();
}
inline void ModelProto::unsafe_arena_set_allocated_self_test_data(
    ::sentencepiece::SelfTestData* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.self_test_data_);
  }
  _impl_.self_test_data_ = reinterpret_cast<::sentencepiece::SelfTestData*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentencepiece.ModelProto.self_test_data)
}
inline ::sentencepiece::SelfTestData* PROTOBUF_NULLABLE ModelProto::release_self_test_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::sentencepiece::SelfTestData* released = _impl_.self_test_data_;
  _impl_.self_test_data_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::sentencepiece::SelfTestData* PROTOBUF_NULLABLE ModelProto::unsafe_arena_release_self_test_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.ModelProto.self_test_data)

  ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::sentencepiece::SelfTestData* temp = _impl_.self_test_data_;
  _impl_.self_test_data_ = nullptr;
  return temp;
}
inline ::sentencepiece::SelfTestData* PROTOBUF_NONNULL ModelProto::_internal_mutable_self_test_data() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.self_test_data_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::sentencepiece::SelfTestData>(GetArena());
    _impl_.self_test_data_ = reinterpret_cast<::sentencepiece::SelfTestData*>(p);
  }
  return _impl_.self_test_data_;
}
inline ::sentencepiece::SelfTestData* PROTOBUF_NONNULL ModelProto::mutable_self_test_data()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  ::sentencepiece::SelfTestData* _msg = _internal_mutable_self_test_data();
  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.self_test_data)
  return _msg;
}
inline void ModelProto::set_allocated_self_test_data(::sentencepiece::SelfTestData* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.self_test_data_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000008U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000008U);
  }

  _impl_.self_test_data_ = reinterpret_cast<::sentencepiece::SelfTestData*>(value);
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.ModelProto.self_test_data)
}

// optional .sentencepiece.NormalizerSpec denormalizer_spec = 5;
inline bool ModelProto::has_denormalizer_spec() const {
  bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U);
  PROTOBUF_ASSUME(!value || _impl_.denormalizer_spec_ != nullptr);
  return value;
}
inline void ModelProto::clear_denormalizer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.denormalizer_spec_ != nullptr) _impl_.denormalizer_spec_->Clear();
  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
}
inline const ::sentencepiece::NormalizerSpec& ModelProto::_internal_denormalizer_spec() const {
  ::google::protobuf::internal::TSanRead(&_impl_);
  const ::sentencepiece::NormalizerSpec* p = _impl_.denormalizer_spec_;
  return p != nullptr ? *p : *::google::protobuf::internal::MessageGlobalsBase::ToDefaultInstance<::sentencepiece::NormalizerSpec>(&::sentencepiece::NormalizerSpec_globals_);
}
inline const ::sentencepiece::NormalizerSpec& ModelProto::denormalizer_spec() const ABSL_ATTRIBUTE_LIFETIME_BOUND {
  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.denormalizer_spec)
  return _internal_denormalizer_spec();
}
inline void ModelProto::unsafe_arena_set_allocated_denormalizer_spec(
    ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE value) {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (GetArena() == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.denormalizer_spec_);
  }
  _impl_.denormalizer_spec_ = reinterpret_cast<::sentencepiece::NormalizerSpec*>(value);
  if (value != nullptr) {
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sentencepiece.ModelProto.denormalizer_spec)
}
inline ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE ModelProto::release_denormalizer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::sentencepiece::NormalizerSpec* released = _impl_.denormalizer_spec_;
  _impl_.denormalizer_spec_ = nullptr;
  if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) {
    auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released);
    released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    if (GetArena() == nullptr) {
      delete old;
    }
  } else {
    if (GetArena() != nullptr) {
      released = ::google::protobuf::internal::DuplicateIfNonNull(released);
    }
  }
  return released;
}
inline ::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE ModelProto::unsafe_arena_release_denormalizer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  // @@protoc_insertion_point(field_release:sentencepiece.ModelProto.denormalizer_spec)

  ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::sentencepiece::NormalizerSpec* temp = _impl_.denormalizer_spec_;
  _impl_.denormalizer_spec_ = nullptr;
  return temp;
}
inline ::sentencepiece::NormalizerSpec* PROTOBUF_NONNULL ModelProto::_internal_mutable_denormalizer_spec() {
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (_impl_.denormalizer_spec_ == nullptr) {
    auto* p = ::google::protobuf::MessageLite::DefaultConstruct<::sentencepiece::NormalizerSpec>(GetArena());
    _impl_.denormalizer_spec_ = reinterpret_cast<::sentencepiece::NormalizerSpec*>(p);
  }
  return _impl_.denormalizer_spec_;
}
inline ::sentencepiece::NormalizerSpec* PROTOBUF_NONNULL ModelProto::mutable_denormalizer_spec()
    ABSL_ATTRIBUTE_LIFETIME_BOUND {
  SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  ::sentencepiece::NormalizerSpec* _msg = _internal_mutable_denormalizer_spec();
  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.denormalizer_spec)
  return _msg;
}
inline void ModelProto::set_allocated_denormalizer_spec(::sentencepiece::NormalizerSpec* PROTOBUF_NULLABLE value) {
  ::google::protobuf::Arena* message_arena = GetArena();
  ::google::protobuf::internal::TSanWrite(&_impl_);
  if (message_arena == nullptr) {
    delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.denormalizer_spec_);
  }

  if (value != nullptr) {
    ::google::protobuf::Arena* submessage_arena = value->GetArena();
    if (message_arena != submessage_arena) {
      value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena);
    }
    SetHasBit(_impl_._has_bits_[0], 0x00000010U);
  } else {
    ClearHasBit(_impl_._has_bits_[0], 0x00000010U);
  }

  _impl_.denormalizer_spec_ = reinterpret_cast<::sentencepiece::NormalizerSpec*>(value);
  // @@protoc_insertion_point(field_set_allocated:sentencepiece.ModelProto.denormalizer_spec)
}

#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif  // __GNUC__

// @@protoc_insertion_point(namespace_scope)
}  // namespace sentencepiece


namespace google {
namespace protobuf {

template <>
struct is_proto_enum<::sentencepiece::TrainerSpec_ModelType> : std::true_type {};
template <>
struct internal::LiteEnumFuncs<::sentencepiece::TrainerSpec_ModelType> {
  static constexpr bool kIsDefined = true;
  static constexpr auto kParseFunc = ::sentencepiece::TrainerSpec_ModelType_Parse;
  static constexpr auto kNameFunc = ::sentencepiece::TrainerSpec_ModelType_Name<int>;
};
template <>
struct is_proto_enum<::sentencepiece::ModelProto_SentencePiece_Type> : std::true_type {};
template <>
struct internal::LiteEnumFuncs<::sentencepiece::ModelProto_SentencePiece_Type> {
  static constexpr bool kIsDefined = true;
  static constexpr auto kParseFunc = ::sentencepiece::ModelProto_SentencePiece_Type_Parse;
  static constexpr auto kNameFunc = ::sentencepiece::ModelProto_SentencePiece_Type_Name<int>;
};

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#include "google/protobuf/port_undef.inc"
// clang-format on

#endif  // sentencepiece_5fmodel_2eproto_2epb_2eh
