diff --git "a/cc-multilingual-main/cc_net/third_party/sentencepiece/src/builtin_pb/sentencepiece_model.pb.h" "b/cc-multilingual-main/cc_net/third_party/sentencepiece/src/builtin_pb/sentencepiece_model.pb.h"
new file mode 100644--- /dev/null
+++ "b/cc-multilingual-main/cc_net/third_party/sentencepiece/src/builtin_pb/sentencepiece_model.pb.h"
@@ -0,0 +1,3601 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: sentencepiece_model.proto
+
+#ifndef PROTOBUF_INCLUDED_sentencepiece_5fmodel_2eproto
+#define PROTOBUF_INCLUDED_sentencepiece_5fmodel_2eproto
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3006001
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3006001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/inlined_string_field.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)
+#define PROTOBUF_INTERNAL_EXPORT_protobuf_sentencepiece_5fmodel_2eproto 
+
+namespace protobuf_sentencepiece_5fmodel_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[6];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+}  // namespace protobuf_sentencepiece_5fmodel_2eproto
+namespace sentencepiece {
+class ModelProto;
+class ModelProtoDefaultTypeInternal;
+extern ModelProtoDefaultTypeInternal _ModelProto_default_instance_;
+class ModelProto_SentencePiece;
+class ModelProto_SentencePieceDefaultTypeInternal;
+extern ModelProto_SentencePieceDefaultTypeInternal _ModelProto_SentencePiece_default_instance_;
+class NormalizerSpec;
+class NormalizerSpecDefaultTypeInternal;
+extern NormalizerSpecDefaultTypeInternal _NormalizerSpec_default_instance_;
+class SelfTestData;
+class SelfTestDataDefaultTypeInternal;
+extern SelfTestDataDefaultTypeInternal _SelfTestData_default_instance_;
+class SelfTestData_Sample;
+class SelfTestData_SampleDefaultTypeInternal;
+extern SelfTestData_SampleDefaultTypeInternal _SelfTestData_Sample_default_instance_;
+class TrainerSpec;
+class TrainerSpecDefaultTypeInternal;
+extern TrainerSpecDefaultTypeInternal _TrainerSpec_default_instance_;
+}  // namespace sentencepiece
+namespace google {
+namespace protobuf {
+template<> ::sentencepiece::ModelProto* Arena::CreateMaybeMessage<::sentencepiece::ModelProto>(Arena*);
+template<> ::sentencepiece::ModelProto_SentencePiece* Arena::CreateMaybeMessage<::sentencepiece::ModelProto_SentencePiece>(Arena*);
+template<> ::sentencepiece::NormalizerSpec* Arena::CreateMaybeMessage<::sentencepiece::NormalizerSpec>(Arena*);
+template<> ::sentencepiece::SelfTestData* Arena::CreateMaybeMessage<::sentencepiece::SelfTestData>(Arena*);
+template<> ::sentencepiece::SelfTestData_Sample* Arena::CreateMaybeMessage<::sentencepiece::SelfTestData_Sample>(Arena*);
+template<> ::sentencepiece::TrainerSpec* Arena::CreateMaybeMessage<::sentencepiece::TrainerSpec>(Arena*);
+}  // namespace protobuf
+}  // namespace google
+namespace sentencepiece {
+
+enum TrainerSpec_ModelType {
+  TrainerSpec_ModelType_UNIGRAM = 1,
+  TrainerSpec_ModelType_BPE = 2,
+  TrainerSpec_ModelType_WORD = 3,
+  TrainerSpec_ModelType_CHAR = 4
+};
+bool TrainerSpec_ModelType_IsValid(int value);
+const TrainerSpec_ModelType TrainerSpec_ModelType_ModelType_MIN = TrainerSpec_ModelType_UNIGRAM;
+const TrainerSpec_ModelType TrainerSpec_ModelType_ModelType_MAX = TrainerSpec_ModelType_CHAR;
+const int TrainerSpec_ModelType_ModelType_ARRAYSIZE = TrainerSpec_ModelType_ModelType_MAX + 1;
+
+enum ModelProto_SentencePiece_Type {
+  ModelProto_SentencePiece_Type_NORMAL = 1,
+  ModelProto_SentencePiece_Type_UNKNOWN = 2,
+  ModelProto_SentencePiece_Type_CONTROL = 3,
+  ModelProto_SentencePiece_Type_USER_DEFINED = 4,
+  ModelProto_SentencePiece_Type_UNUSED = 5
+};
+bool ModelProto_SentencePiece_Type_IsValid(int value);
+const ModelProto_SentencePiece_Type ModelProto_SentencePiece_Type_Type_MIN = ModelProto_SentencePiece_Type_NORMAL;
+const ModelProto_SentencePiece_Type ModelProto_SentencePiece_Type_Type_MAX = ModelProto_SentencePiece_Type_UNUSED;
+const int ModelProto_SentencePiece_Type_Type_ARRAYSIZE = ModelProto_SentencePiece_Type_Type_MAX + 1;
+
+// ===================================================================
+
+class TrainerSpec : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sentencepiece.TrainerSpec) */ {
+ public:
+  TrainerSpec();
+  virtual ~TrainerSpec();
+
+  TrainerSpec(const TrainerSpec& from);
+
+  inline TrainerSpec& operator=(const TrainerSpec& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TrainerSpec(TrainerSpec&& from) noexcept
+    : TrainerSpec() {
+    *this = ::std::move(from);
+  }
+
+  inline TrainerSpec& operator=(TrainerSpec&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const TrainerSpec& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TrainerSpec* internal_default_instance() {
+    return reinterpret_cast<const TrainerSpec*>(
+               &_TrainerSpec_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  void Swap(TrainerSpec* other);
+  friend void swap(TrainerSpec& a, TrainerSpec& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TrainerSpec* New() const final {
+    return CreateMaybeMessage<TrainerSpec>(NULL);
+  }
+
+  TrainerSpec* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<TrainerSpec>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
+    final;
+  void CopyFrom(const TrainerSpec& from);
+  void MergeFrom(const TrainerSpec& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(TrainerSpec* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef TrainerSpec_ModelType ModelType;
+  static const ModelType UNIGRAM =
+    TrainerSpec_ModelType_UNIGRAM;
+  static const ModelType BPE =
+    TrainerSpec_ModelType_BPE;
+  static const ModelType WORD =
+    TrainerSpec_ModelType_WORD;
+  static const ModelType CHAR =
+    TrainerSpec_ModelType_CHAR;
+  static inline bool ModelType_IsValid(int value) {
+    return TrainerSpec_ModelType_IsValid(value);
+  }
+  static const ModelType ModelType_MIN =
+    TrainerSpec_ModelType_ModelType_MIN;
+  static const ModelType ModelType_MAX =
+    TrainerSpec_ModelType_ModelType_MAX;
+  static const int ModelType_ARRAYSIZE =
+    TrainerSpec_ModelType_ModelType_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // repeated string input = 1;
+  int input_size() const;
+  void clear_input();
+  static const int kInputFieldNumber = 1;
+  const ::std::string& input(int index) const;
+  ::std::string* mutable_input(int index);
+  void set_input(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_input(int index, ::std::string&& value);
+  #endif
+  void set_input(int index, const char* value);
+  void set_input(int index, const char* value, size_t size);
+  ::std::string* add_input();
+  void add_input(const ::std::string& value);
+  #if LANG_CXX11
+  void add_input(::std::string&& value);
+  #endif
+  void add_input(const char* value);
+  void add_input(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& input() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_input();
+
+  // repeated string accept_language = 5;
+  int accept_language_size() const;
+  void clear_accept_language();
+  static const int kAcceptLanguageFieldNumber = 5;
+  const ::std::string& accept_language(int index) const;
+  ::std::string* mutable_accept_language(int index);
+  void set_accept_language(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_accept_language(int index, ::std::string&& value);
+  #endif
+  void set_accept_language(int index, const char* value);
+  void set_accept_language(int index, const char* value, size_t size);
+  ::std::string* add_accept_language();
+  void add_accept_language(const ::std::string& value);
+  #if LANG_CXX11
+  void add_accept_language(::std::string&& value);
+  #endif
+  void add_accept_language(const char* value);
+  void add_accept_language(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& accept_language() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_accept_language();
+
+  // repeated string control_symbols = 30;
+  int control_symbols_size() const;
+  void clear_control_symbols();
+  static const int kControlSymbolsFieldNumber = 30;
+  const ::std::string& control_symbols(int index) const;
+  ::std::string* mutable_control_symbols(int index);
+  void set_control_symbols(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_control_symbols(int index, ::std::string&& value);
+  #endif
+  void set_control_symbols(int index, const char* value);
+  void set_control_symbols(int index, const char* value, size_t size);
+  ::std::string* add_control_symbols();
+  void add_control_symbols(const ::std::string& value);
+  #if LANG_CXX11
+  void add_control_symbols(::std::string&& value);
+  #endif
+  void add_control_symbols(const char* value);
+  void add_control_symbols(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& control_symbols() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_control_symbols();
+
+  // repeated string user_defined_symbols = 31;
+  int user_defined_symbols_size() const;
+  void clear_user_defined_symbols();
+  static const int kUserDefinedSymbolsFieldNumber = 31;
+  const ::std::string& user_defined_symbols(int index) const;
+  ::std::string* mutable_user_defined_symbols(int index);
+  void set_user_defined_symbols(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_user_defined_symbols(int index, ::std::string&& value);
+  #endif
+  void set_user_defined_symbols(int index, const char* value);
+  void set_user_defined_symbols(int index, const char* value, size_t size);
+  ::std::string* add_user_defined_symbols();
+  void add_user_defined_symbols(const ::std::string& value);
+  #if LANG_CXX11
+  void add_user_defined_symbols(::std::string&& value);
+  #endif
+  void add_user_defined_symbols(const char* value);
+  void add_user_defined_symbols(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& user_defined_symbols() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_user_defined_symbols();
+
+  // optional string model_prefix = 2;
+  bool has_model_prefix() const;
+  void clear_model_prefix();
+  static const int kModelPrefixFieldNumber = 2;
+  const ::std::string& model_prefix() const;
+  void set_model_prefix(const ::std::string& value);
+  #if LANG_CXX11
+  void set_model_prefix(::std::string&& value);
+  #endif
+  void set_model_prefix(const char* value);
+  void set_model_prefix(const char* value, size_t size);
+  ::std::string* mutable_model_prefix();
+  ::std::string* release_model_prefix();
+  void set_allocated_model_prefix(::std::string* model_prefix);
+
+  // optional string input_format = 7;
+  bool has_input_format() const;
+  void clear_input_format();
+  static const int kInputFormatFieldNumber = 7;
+  const ::std::string& input_format() const;
+  void set_input_format(const ::std::string& value);
+  #if LANG_CXX11
+  void set_input_format(::std::string&& value);
+  #endif
+  void set_input_format(const char* value);
+  void set_input_format(const char* value, size_t size);
+  ::std::string* mutable_input_format();
+  ::std::string* release_input_format();
+  void set_allocated_input_format(::std::string* input_format);
+
+  // optional string unk_surface = 44 [default = " \342\201\207 "];
+  bool has_unk_surface() const;
+  void clear_unk_surface();
+  static const int kUnkSurfaceFieldNumber = 44;
+  const ::std::string& unk_surface() const;
+  void set_unk_surface(const ::std::string& value);
+  #if LANG_CXX11
+  void set_unk_surface(::std::string&& value);
+  #endif
+  void set_unk_surface(const char* value);
+  void set_unk_surface(const char* value, size_t size);
+  ::std::string* mutable_unk_surface();
+  ::std::string* release_unk_surface();
+  void set_allocated_unk_surface(::std::string* unk_surface);
+
+  // optional string unk_piece = 45 [default = "<unk>"];
+  bool has_unk_piece() const;
+  void clear_unk_piece();
+  static const int kUnkPieceFieldNumber = 45;
+  const ::std::string& unk_piece() const;
+  void set_unk_piece(const ::std::string& value);
+  #if LANG_CXX11
+  void set_unk_piece(::std::string&& value);
+  #endif
+  void set_unk_piece(const char* value);
+  void set_unk_piece(const char* value, size_t size);
+  ::std::string* mutable_unk_piece();
+  ::std::string* release_unk_piece();
+  void set_allocated_unk_piece(::std::string* unk_piece);
+
+  // optional string bos_piece = 46 [default = "<s>"];
+  bool has_bos_piece() const;
+  void clear_bos_piece();
+  static const int kBosPieceFieldNumber = 46;
+  const ::std::string& bos_piece() const;
+  void set_bos_piece(const ::std::string& value);
+  #if LANG_CXX11
+  void set_bos_piece(::std::string&& value);
+  #endif
+  void set_bos_piece(const char* value);
+  void set_bos_piece(const char* value, size_t size);
+  ::std::string* mutable_bos_piece();
+  ::std::string* release_bos_piece();
+  void set_allocated_bos_piece(::std::string* bos_piece);
+
+  // optional string eos_piece = 47 [default = "</s>"];
+  bool has_eos_piece() const;
+  void clear_eos_piece();
+  static const int kEosPieceFieldNumber = 47;
+  const ::std::string& eos_piece() const;
+  void set_eos_piece(const ::std::string& value);
+  #if LANG_CXX11
+  void set_eos_piece(::std::string&& value);
+  #endif
+  void set_eos_piece(const char* value);
+  void set_eos_piece(const char* value, size_t size);
+  ::std::string* mutable_eos_piece();
+  ::std::string* release_eos_piece();
+  void set_allocated_eos_piece(::std::string* eos_piece);
+
+  // optional string pad_piece = 48 [default = "<pad>"];
+  bool has_pad_piece() const;
+  void clear_pad_piece();
+  static const int kPadPieceFieldNumber = 48;
+  const ::std::string& pad_piece() const;
+  void set_pad_piece(const ::std::string& value);
+  #if LANG_CXX11
+  void set_pad_piece(::std::string&& value);
+  #endif
+  void set_pad_piece(const char* value);
+  void set_pad_piece(const char* value, size_t size);
+  ::std::string* mutable_pad_piece();
+  ::std::string* release_pad_piece();
+  void set_allocated_pad_piece(::std::string* pad_piece);
+
+  // optional int32 self_test_sample_size = 6 [default = 0];
+  bool has_self_test_sample_size() const;
+  void clear_self_test_sample_size();
+  static const int kSelfTestSampleSizeFieldNumber = 6;
+  ::google::protobuf::int32 self_test_sample_size() const;
+  void set_self_test_sample_size(::google::protobuf::int32 value);
+
+  // optional int32 input_sentence_size = 11 [default = 0];
+  bool has_input_sentence_size() const;
+  void clear_input_sentence_size();
+  static const int kInputSentenceSizeFieldNumber = 11;
+  ::google::protobuf::int32 input_sentence_size() const;
+  void set_input_sentence_size(::google::protobuf::int32 value);
+
+  // optional int32 mining_sentence_size = 12 [deprecated = true];
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR bool has_mining_sentence_size() const;
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR void clear_mining_sentence_size();
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR static const int kMiningSentenceSizeFieldNumber = 12;
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR ::google::protobuf::int32 mining_sentence_size() const;
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_mining_sentence_size(::google::protobuf::int32 value);
+
+  // optional int32 training_sentence_size = 13 [deprecated = true];
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR bool has_training_sentence_size() const;
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR void clear_training_sentence_size();
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR static const int kTrainingSentenceSizeFieldNumber = 13;
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR ::google::protobuf::int32 training_sentence_size() const;
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_training_sentence_size(::google::protobuf::int32 value);
+
+  // optional bool treat_whitespace_as_suffix = 24 [default = false];
+  bool has_treat_whitespace_as_suffix() const;
+  void clear_treat_whitespace_as_suffix();
+  static const int kTreatWhitespaceAsSuffixFieldNumber = 24;
+  bool treat_whitespace_as_suffix() const;
+  void set_treat_whitespace_as_suffix(bool value);
+
+  // optional bool use_all_vocab = 34 [default = false];
+  bool has_use_all_vocab() const;
+  void clear_use_all_vocab();
+  static const int kUseAllVocabFieldNumber = 34;
+  bool use_all_vocab() const;
+  void set_use_all_vocab(bool value);
+
+  // optional int32 unk_id = 40 [default = 0];
+  bool has_unk_id() const;
+  void clear_unk_id();
+  static const int kUnkIdFieldNumber = 40;
+  ::google::protobuf::int32 unk_id() const;
+  void set_unk_id(::google::protobuf::int32 value);
+
+  // optional .sentencepiece.TrainerSpec.ModelType model_type = 3 [default = UNIGRAM];
+  bool has_model_type() const;
+  void clear_model_type();
+  static const int kModelTypeFieldNumber = 3;
+  ::sentencepiece::TrainerSpec_ModelType model_type() const;
+  void set_model_type(::sentencepiece::TrainerSpec_ModelType value);
+
+  // optional int32 vocab_size = 4 [default = 8000];
+  bool has_vocab_size() const;
+  void clear_vocab_size();
+  static const int kVocabSizeFieldNumber = 4;
+  ::google::protobuf::int32 vocab_size() const;
+  void set_vocab_size(::google::protobuf::int32 value);
+
+  // optional float character_coverage = 10 [default = 0.9995];
+  bool has_character_coverage() const;
+  void clear_character_coverage();
+  static const int kCharacterCoverageFieldNumber = 10;
+  float character_coverage() const;
+  void set_character_coverage(float value);
+
+  // optional int32 seed_sentencepiece_size = 14 [default = 1000000];
+  bool has_seed_sentencepiece_size() const;
+  void clear_seed_sentencepiece_size();
+  static const int kSeedSentencepieceSizeFieldNumber = 14;
+  ::google::protobuf::int32 seed_sentencepiece_size() const;
+  void set_seed_sentencepiece_size(::google::protobuf::int32 value);
+
+  // optional float shrinking_factor = 15 [default = 0.75];
+  bool has_shrinking_factor() const;
+  void clear_shrinking_factor();
+  static const int kShrinkingFactorFieldNumber = 15;
+  float shrinking_factor() const;
+  void set_shrinking_factor(float value);
+
+  // optional int32 num_threads = 16 [default = 16];
+  bool has_num_threads() const;
+  void clear_num_threads();
+  static const int kNumThreadsFieldNumber = 16;
+  ::google::protobuf::int32 num_threads() const;
+  void set_num_threads(::google::protobuf::int32 value);
+
+  // optional int32 num_sub_iterations = 17 [default = 2];
+  bool has_num_sub_iterations() const;
+  void clear_num_sub_iterations();
+  static const int kNumSubIterationsFieldNumber = 17;
+  ::google::protobuf::int32 num_sub_iterations() const;
+  void set_num_sub_iterations(::google::protobuf::int32 value);
+
+  // optional int32 max_sentence_length = 18 [default = 4192];
+  bool has_max_sentence_length() const;
+  void clear_max_sentence_length();
+  static const int kMaxSentenceLengthFieldNumber = 18;
+  ::google::protobuf::int32 max_sentence_length() const;
+  void set_max_sentence_length(::google::protobuf::int32 value);
+
+  // optional int32 max_sentencepiece_length = 20 [default = 16];
+  bool has_max_sentencepiece_length() const;
+  void clear_max_sentencepiece_length();
+  static const int kMaxSentencepieceLengthFieldNumber = 20;
+  ::google::protobuf::int32 max_sentencepiece_length() const;
+  void set_max_sentencepiece_length(::google::protobuf::int32 value);
+
+  // optional bool shuffle_input_sentence = 19 [default = true];
+  bool has_shuffle_input_sentence() const;
+  void clear_shuffle_input_sentence();
+  static const int kShuffleInputSentenceFieldNumber = 19;
+  bool shuffle_input_sentence() const;
+  void set_shuffle_input_sentence(bool value);
+
+  // optional bool split_by_unicode_script = 21 [default = true];
+  bool has_split_by_unicode_script() const;
+  void clear_split_by_unicode_script();
+  static const int kSplitByUnicodeScriptFieldNumber = 21;
+  bool split_by_unicode_script() const;
+  void set_split_by_unicode_script(bool value);
+
+  // optional bool split_by_number = 23 [default = true];
+  bool has_split_by_number() const;
+  void clear_split_by_number();
+  static const int kSplitByNumberFieldNumber = 23;
+  bool split_by_number() const;
+  void set_split_by_number(bool value);
+
+  // optional bool split_by_whitespace = 22 [default = true];
+  bool has_split_by_whitespace() const;
+  void clear_split_by_whitespace();
+  static const int kSplitByWhitespaceFieldNumber = 22;
+  bool split_by_whitespace() const;
+  void set_split_by_whitespace(bool value);
+
+  // optional bool hard_vocab_limit = 33 [default = true];
+  bool has_hard_vocab_limit() const;
+  void clear_hard_vocab_limit();
+  static const int kHardVocabLimitFieldNumber = 33;
+  bool hard_vocab_limit() const;
+  void set_hard_vocab_limit(bool value);
+
+  // optional int32 bos_id = 41 [default = 1];
+  bool has_bos_id() const;
+  void clear_bos_id();
+  static const int kBosIdFieldNumber = 41;
+  ::google::protobuf::int32 bos_id() const;
+  void set_bos_id(::google::protobuf::int32 value);
+
+  // optional int32 eos_id = 42 [default = 2];
+  bool has_eos_id() const;
+  void clear_eos_id();
+  static const int kEosIdFieldNumber = 42;
+  ::google::protobuf::int32 eos_id() const;
+  void set_eos_id(::google::protobuf::int32 value);
+
+  // optional int32 pad_id = 43 [default = -1];
+  bool has_pad_id() const;
+  void clear_pad_id();
+  static const int kPadIdFieldNumber = 43;
+  ::google::protobuf::int32 pad_id() const;
+  void set_pad_id(::google::protobuf::int32 value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(TrainerSpec)
+  // @@protoc_insertion_point(class_scope:sentencepiece.TrainerSpec)
+ private:
+  void set_has_input_format();
+  void clear_has_input_format();
+  void set_has_model_prefix();
+  void clear_has_model_prefix();
+  void set_has_model_type();
+  void clear_has_model_type();
+  void set_has_vocab_size();
+  void clear_has_vocab_size();
+  void set_has_self_test_sample_size();
+  void clear_has_self_test_sample_size();
+  void set_has_character_coverage();
+  void clear_has_character_coverage();
+  void set_has_input_sentence_size();
+  void clear_has_input_sentence_size();
+  void set_has_shuffle_input_sentence();
+  void clear_has_shuffle_input_sentence();
+  void set_has_mining_sentence_size();
+  void clear_has_mining_sentence_size();
+  void set_has_training_sentence_size();
+  void clear_has_training_sentence_size();
+  void set_has_seed_sentencepiece_size();
+  void clear_has_seed_sentencepiece_size();
+  void set_has_shrinking_factor();
+  void clear_has_shrinking_factor();
+  void set_has_max_sentence_length();
+  void clear_has_max_sentence_length();
+  void set_has_num_threads();
+  void clear_has_num_threads();
+  void set_has_num_sub_iterations();
+  void clear_has_num_sub_iterations();
+  void set_has_max_sentencepiece_length();
+  void clear_has_max_sentencepiece_length();
+  void set_has_split_by_unicode_script();
+  void clear_has_split_by_unicode_script();
+  void set_has_split_by_number();
+  void clear_has_split_by_number();
+  void set_has_split_by_whitespace();
+  void clear_has_split_by_whitespace();
+  void set_has_treat_whitespace_as_suffix();
+  void clear_has_treat_whitespace_as_suffix();
+  void set_has_hard_vocab_limit();
+  void clear_has_hard_vocab_limit();
+  void set_has_use_all_vocab();
+  void clear_has_use_all_vocab();
+  void set_has_unk_id();
+  void clear_has_unk_id();
+  void set_has_bos_id();
+  void clear_has_bos_id();
+  void set_has_eos_id();
+  void clear_has_eos_id();
+  void set_has_pad_id();
+  void clear_has_pad_id();
+  void set_has_unk_piece();
+  void clear_has_unk_piece();
+  void set_has_bos_piece();
+  void clear_has_bos_piece();
+  void set_has_eos_piece();
+  void clear_has_eos_piece();
+  void set_has_pad_piece();
+  void clear_has_pad_piece();
+  void set_has_unk_surface();
+  void clear_has_unk_surface();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable ::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_;
+  public:
+  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_unk_surface_;
+  private:
+  ::google::protobuf::internal::ArenaStringPtr unk_surface_;
+  public:
+  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_unk_piece_;
+  private:
+  ::google::protobuf::internal::ArenaStringPtr unk_piece_;
+  public:
+  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_bos_piece_;
+  private:
+  ::google::protobuf::internal::ArenaStringPtr bos_piece_;
+  public:
+  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_eos_piece_;
+  private:
+  ::google::protobuf::internal::ArenaStringPtr eos_piece_;
+  public:
+  static ::google::protobuf::internal::ExplicitlyConstructed< ::std::string> _i_give_permission_to_break_this_code_default_pad_piece_;
+  private:
+  ::google::protobuf::internal::ArenaStringPtr pad_piece_;
+  ::google::protobuf::int32 self_test_sample_size_;
+  ::google::protobuf::int32 input_sentence_size_;
+  ::google::protobuf::int32 mining_sentence_size_;
+  ::google::protobuf::int32 training_sentence_size_;
+  bool treat_whitespace_as_suffix_;
+  bool use_all_vocab_;
+  ::google::protobuf::int32 unk_id_;
+  int model_type_;
+  ::google::protobuf::int32 vocab_size_;
+  float character_coverage_;
+  ::google::protobuf::int32 seed_sentencepiece_size_;
+  float shrinking_factor_;
+  ::google::protobuf::int32 num_threads_;
+  ::google::protobuf::int32 num_sub_iterations_;
+  ::google::protobuf::int32 max_sentence_length_;
+  ::google::protobuf::int32 max_sentencepiece_length_;
+  bool shuffle_input_sentence_;
+  bool split_by_unicode_script_;
+  bool split_by_number_;
+  bool split_by_whitespace_;
+  bool hard_vocab_limit_;
+  ::google::protobuf::int32 bos_id_;
+  ::google::protobuf::int32 eos_id_;
+  ::google::protobuf::int32 pad_id_;
+  friend struct ::protobuf_sentencepiece_5fmodel_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class NormalizerSpec : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sentencepiece.NormalizerSpec) */ {
+ public:
+  NormalizerSpec();
+  virtual ~NormalizerSpec();
+
+  NormalizerSpec(const NormalizerSpec& from);
+
+  inline NormalizerSpec& operator=(const NormalizerSpec& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  NormalizerSpec(NormalizerSpec&& from) noexcept
+    : NormalizerSpec() {
+    *this = ::std::move(from);
+  }
+
+  inline NormalizerSpec& operator=(NormalizerSpec&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const NormalizerSpec& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const NormalizerSpec* internal_default_instance() {
+    return reinterpret_cast<const NormalizerSpec*>(
+               &_NormalizerSpec_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  void Swap(NormalizerSpec* other);
+  friend void swap(NormalizerSpec& a, NormalizerSpec& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline NormalizerSpec* New() const final {
+    return CreateMaybeMessage<NormalizerSpec>(NULL);
+  }
+
+  NormalizerSpec* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<NormalizerSpec>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
+    final;
+  void CopyFrom(const NormalizerSpec& from);
+  void MergeFrom(const NormalizerSpec& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(NormalizerSpec* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 1;
+  bool has_name() const;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // optional bytes precompiled_charsmap = 2;
+  bool has_precompiled_charsmap() const;
+  void clear_precompiled_charsmap();
+  static const int kPrecompiledCharsmapFieldNumber = 2;
+  const ::std::string& precompiled_charsmap() const;
+  void set_precompiled_charsmap(const ::std::string& value);
+  #if LANG_CXX11
+  void set_precompiled_charsmap(::std::string&& value);
+  #endif
+  void set_precompiled_charsmap(const char* value);
+  void set_precompiled_charsmap(const void* value, size_t size);
+  ::std::string* mutable_precompiled_charsmap();
+  ::std::string* release_precompiled_charsmap();
+  void set_allocated_precompiled_charsmap(::std::string* precompiled_charsmap);
+
+  // optional string normalization_rule_tsv = 6;
+  bool has_normalization_rule_tsv() const;
+  void clear_normalization_rule_tsv();
+  static const int kNormalizationRuleTsvFieldNumber = 6;
+  const ::std::string& normalization_rule_tsv() const;
+  void set_normalization_rule_tsv(const ::std::string& value);
+  #if LANG_CXX11
+  void set_normalization_rule_tsv(::std::string&& value);
+  #endif
+  void set_normalization_rule_tsv(const char* value);
+  void set_normalization_rule_tsv(const char* value, size_t size);
+  ::std::string* mutable_normalization_rule_tsv();
+  ::std::string* release_normalization_rule_tsv();
+  void set_allocated_normalization_rule_tsv(::std::string* normalization_rule_tsv);
+
+  // optional bool add_dummy_prefix = 3 [default = true];
+  bool has_add_dummy_prefix() const;
+  void clear_add_dummy_prefix();
+  static const int kAddDummyPrefixFieldNumber = 3;
+  bool add_dummy_prefix() const;
+  void set_add_dummy_prefix(bool value);
+
+  // optional bool remove_extra_whitespaces = 4 [default = true];
+  bool has_remove_extra_whitespaces() const;
+  void clear_remove_extra_whitespaces();
+  static const int kRemoveExtraWhitespacesFieldNumber = 4;
+  bool remove_extra_whitespaces() const;
+  void set_remove_extra_whitespaces(bool value);
+
+  // optional bool escape_whitespaces = 5 [default = true];
+  bool has_escape_whitespaces() const;
+  void clear_escape_whitespaces();
+  static const int kEscapeWhitespacesFieldNumber = 5;
+  bool escape_whitespaces() const;
+  void set_escape_whitespaces(bool value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(NormalizerSpec)
+  // @@protoc_insertion_point(class_scope:sentencepiece.NormalizerSpec)
+ private:
+  void set_has_name();
+  void clear_has_name();
+  void set_has_precompiled_charsmap();
+  void clear_has_precompiled_charsmap();
+  void set_has_add_dummy_prefix();
+  void clear_has_add_dummy_prefix();
+  void set_has_remove_extra_whitespaces();
+  void clear_has_remove_extra_whitespaces();
+  void set_has_escape_whitespaces();
+  void clear_has_escape_whitespaces();
+  void set_has_normalization_rule_tsv();
+  void clear_has_normalization_rule_tsv();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable ::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_;
+  friend struct ::protobuf_sentencepiece_5fmodel_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SelfTestData_Sample : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sentencepiece.SelfTestData.Sample) */ {
+ public:
+  SelfTestData_Sample();
+  virtual ~SelfTestData_Sample();
+
+  SelfTestData_Sample(const SelfTestData_Sample& from);
+
+  inline SelfTestData_Sample& operator=(const SelfTestData_Sample& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SelfTestData_Sample(SelfTestData_Sample&& from) noexcept
+    : SelfTestData_Sample() {
+    *this = ::std::move(from);
+  }
+
+  inline SelfTestData_Sample& operator=(SelfTestData_Sample&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const SelfTestData_Sample& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SelfTestData_Sample* internal_default_instance() {
+    return reinterpret_cast<const SelfTestData_Sample*>(
+               &_SelfTestData_Sample_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  void Swap(SelfTestData_Sample* other);
+  friend void swap(SelfTestData_Sample& a, SelfTestData_Sample& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SelfTestData_Sample* New() const final {
+    return CreateMaybeMessage<SelfTestData_Sample>(NULL);
+  }
+
+  SelfTestData_Sample* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SelfTestData_Sample>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
+    final;
+  void CopyFrom(const SelfTestData_Sample& from);
+  void MergeFrom(const SelfTestData_Sample& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(SelfTestData_Sample* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string input = 1;
+  bool has_input() const;
+  void clear_input();
+  static const int kInputFieldNumber = 1;
+  const ::std::string& input() const;
+  void set_input(const ::std::string& value);
+  #if LANG_CXX11
+  void set_input(::std::string&& value);
+  #endif
+  void set_input(const char* value);
+  void set_input(const char* value, size_t size);
+  ::std::string* mutable_input();
+  ::std::string* release_input();
+  void set_allocated_input(::std::string* input);
+
+  // optional string expected = 2;
+  bool has_expected() const;
+  void clear_expected();
+  static const int kExpectedFieldNumber = 2;
+  const ::std::string& expected() const;
+  void set_expected(const ::std::string& value);
+  #if LANG_CXX11
+  void set_expected(::std::string&& value);
+  #endif
+  void set_expected(const char* value);
+  void set_expected(const char* value, size_t size);
+  ::std::string* mutable_expected();
+  ::std::string* release_expected();
+  void set_allocated_expected(::std::string* expected);
+
+  // @@protoc_insertion_point(class_scope:sentencepiece.SelfTestData.Sample)
+ private:
+  void set_has_input();
+  void clear_has_input();
+  void set_has_expected();
+  void clear_has_expected();
+
+  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  ::google::protobuf::internal::ArenaStringPtr input_;
+  ::google::protobuf::internal::ArenaStringPtr expected_;
+  friend struct ::protobuf_sentencepiece_5fmodel_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class SelfTestData : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sentencepiece.SelfTestData) */ {
+ public:
+  SelfTestData();
+  virtual ~SelfTestData();
+
+  SelfTestData(const SelfTestData& from);
+
+  inline SelfTestData& operator=(const SelfTestData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SelfTestData(SelfTestData&& from) noexcept
+    : SelfTestData() {
+    *this = ::std::move(from);
+  }
+
+  inline SelfTestData& operator=(SelfTestData&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const SelfTestData& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SelfTestData* internal_default_instance() {
+    return reinterpret_cast<const SelfTestData*>(
+               &_SelfTestData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  void Swap(SelfTestData* other);
+  friend void swap(SelfTestData& a, SelfTestData& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SelfTestData* New() const final {
+    return CreateMaybeMessage<SelfTestData>(NULL);
+  }
+
+  SelfTestData* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<SelfTestData>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
+    final;
+  void CopyFrom(const SelfTestData& from);
+  void MergeFrom(const SelfTestData& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(SelfTestData* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SelfTestData_Sample Sample;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .sentencepiece.SelfTestData.Sample samples = 1;
+  int samples_size() const;
+  void clear_samples();
+  static const int kSamplesFieldNumber = 1;
+  ::sentencepiece::SelfTestData_Sample* mutable_samples(int index);
+  ::google::protobuf::RepeatedPtrField< ::sentencepiece::SelfTestData_Sample >*
+      mutable_samples();
+  const ::sentencepiece::SelfTestData_Sample& samples(int index) const;
+  ::sentencepiece::SelfTestData_Sample* add_samples();
+  const ::google::protobuf::RepeatedPtrField< ::sentencepiece::SelfTestData_Sample >&
+      samples() const;
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(SelfTestData)
+  // @@protoc_insertion_point(class_scope:sentencepiece.SelfTestData)
+ private:
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::sentencepiece::SelfTestData_Sample > samples_;
+  friend struct ::protobuf_sentencepiece_5fmodel_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class ModelProto_SentencePiece : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sentencepiece.ModelProto.SentencePiece) */ {
+ public:
+  ModelProto_SentencePiece();
+  virtual ~ModelProto_SentencePiece();
+
+  ModelProto_SentencePiece(const ModelProto_SentencePiece& from);
+
+  inline ModelProto_SentencePiece& operator=(const ModelProto_SentencePiece& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ModelProto_SentencePiece(ModelProto_SentencePiece&& from) noexcept
+    : ModelProto_SentencePiece() {
+    *this = ::std::move(from);
+  }
+
+  inline ModelProto_SentencePiece& operator=(ModelProto_SentencePiece&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const ModelProto_SentencePiece& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ModelProto_SentencePiece* internal_default_instance() {
+    return reinterpret_cast<const ModelProto_SentencePiece*>(
+               &_ModelProto_SentencePiece_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  void Swap(ModelProto_SentencePiece* other);
+  friend void swap(ModelProto_SentencePiece& a, ModelProto_SentencePiece& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ModelProto_SentencePiece* New() const final {
+    return CreateMaybeMessage<ModelProto_SentencePiece>(NULL);
+  }
+
+  ModelProto_SentencePiece* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<ModelProto_SentencePiece>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
+    final;
+  void CopyFrom(const ModelProto_SentencePiece& from);
+  void MergeFrom(const ModelProto_SentencePiece& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ModelProto_SentencePiece* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ModelProto_SentencePiece_Type Type;
+  static const Type NORMAL =
+    ModelProto_SentencePiece_Type_NORMAL;
+  static const Type UNKNOWN =
+    ModelProto_SentencePiece_Type_UNKNOWN;
+  static const Type CONTROL =
+    ModelProto_SentencePiece_Type_CONTROL;
+  static const Type USER_DEFINED =
+    ModelProto_SentencePiece_Type_USER_DEFINED;
+  static const Type UNUSED =
+    ModelProto_SentencePiece_Type_UNUSED;
+  static inline bool Type_IsValid(int value) {
+    return ModelProto_SentencePiece_Type_IsValid(value);
+  }
+  static const Type Type_MIN =
+    ModelProto_SentencePiece_Type_Type_MIN;
+  static const Type Type_MAX =
+    ModelProto_SentencePiece_Type_Type_MAX;
+  static const int Type_ARRAYSIZE =
+    ModelProto_SentencePiece_Type_Type_ARRAYSIZE;
+
+  // accessors -------------------------------------------------------
+
+  // optional string piece = 1;
+  bool has_piece() const;
+  void clear_piece();
+  static const int kPieceFieldNumber = 1;
+  const ::std::string& piece() const;
+  void set_piece(const ::std::string& value);
+  #if LANG_CXX11
+  void set_piece(::std::string&& value);
+  #endif
+  void set_piece(const char* value);
+  void set_piece(const char* value, size_t size);
+  ::std::string* mutable_piece();
+  ::std::string* release_piece();
+  void set_allocated_piece(::std::string* piece);
+
+  // optional float score = 2;
+  bool has_score() const;
+  void clear_score();
+  static const int kScoreFieldNumber = 2;
+  float score() const;
+  void set_score(float value);
+
+  // optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
+  bool has_type() const;
+  void clear_type();
+  static const int kTypeFieldNumber = 3;
+  ::sentencepiece::ModelProto_SentencePiece_Type type() const;
+  void set_type(::sentencepiece::ModelProto_SentencePiece_Type value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ModelProto_SentencePiece)
+  // @@protoc_insertion_point(class_scope:sentencepiece.ModelProto.SentencePiece)
+ private:
+  void set_has_piece();
+  void clear_has_piece();
+  void set_has_score();
+  void clear_has_score();
+  void set_has_type();
+  void clear_has_type();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  ::google::protobuf::internal::ArenaStringPtr piece_;
+  float score_;
+  int type_;
+  friend struct ::protobuf_sentencepiece_5fmodel_2eproto::TableStruct;
+};
+// -------------------------------------------------------------------
+
+class ModelProto : public ::google::protobuf::MessageLite /* @@protoc_insertion_point(class_definition:sentencepiece.ModelProto) */ {
+ public:
+  ModelProto();
+  virtual ~ModelProto();
+
+  ModelProto(const ModelProto& from);
+
+  inline ModelProto& operator=(const ModelProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ModelProto(ModelProto&& from) noexcept
+    : ModelProto() {
+    *this = ::std::move(from);
+  }
+
+  inline ModelProto& operator=(ModelProto&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const ModelProto& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ModelProto* internal_default_instance() {
+    return reinterpret_cast<const ModelProto*>(
+               &_ModelProto_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  void Swap(ModelProto* other);
+  friend void swap(ModelProto& a, ModelProto& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ModelProto* New() const final {
+    return CreateMaybeMessage<ModelProto>(NULL);
+  }
+
+  ModelProto* New(::google::protobuf::Arena* arena) const final {
+    return CreateMaybeMessage<ModelProto>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from)
+    final;
+  void CopyFrom(const ModelProto& from);
+  void MergeFrom(const ModelProto& from);
+  void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) final;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(ModelProto* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ModelProto_SentencePiece SentencePiece;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
+  int pieces_size() const;
+  void clear_pieces();
+  static const int kPiecesFieldNumber = 1;
+  ::sentencepiece::ModelProto_SentencePiece* mutable_pieces(int index);
+  ::google::protobuf::RepeatedPtrField< ::sentencepiece::ModelProto_SentencePiece >*
+      mutable_pieces();
+  const ::sentencepiece::ModelProto_SentencePiece& pieces(int index) const;
+  ::sentencepiece::ModelProto_SentencePiece* add_pieces();
+  const ::google::protobuf::RepeatedPtrField< ::sentencepiece::ModelProto_SentencePiece >&
+      pieces() const;
+
+  // optional .sentencepiece.TrainerSpec trainer_spec = 2;
+  bool has_trainer_spec() const;
+  void clear_trainer_spec();
+  static const int kTrainerSpecFieldNumber = 2;
+  private:
+  const ::sentencepiece::TrainerSpec& _internal_trainer_spec() const;
+  public:
+  const ::sentencepiece::TrainerSpec& trainer_spec() const;
+  ::sentencepiece::TrainerSpec* release_trainer_spec();
+  ::sentencepiece::TrainerSpec* mutable_trainer_spec();
+  void set_allocated_trainer_spec(::sentencepiece::TrainerSpec* trainer_spec);
+
+  // optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
+  bool has_normalizer_spec() const;
+  void clear_normalizer_spec();
+  static const int kNormalizerSpecFieldNumber = 3;
+  private:
+  const ::sentencepiece::NormalizerSpec& _internal_normalizer_spec() const;
+  public:
+  const ::sentencepiece::NormalizerSpec& normalizer_spec() const;
+  ::sentencepiece::NormalizerSpec* release_normalizer_spec();
+  ::sentencepiece::NormalizerSpec* mutable_normalizer_spec();
+  void set_allocated_normalizer_spec(::sentencepiece::NormalizerSpec* normalizer_spec);
+
+  // optional .sentencepiece.SelfTestData self_test_data = 4;
+  bool has_self_test_data() const;
+  void clear_self_test_data();
+  static const int kSelfTestDataFieldNumber = 4;
+  private:
+  const ::sentencepiece::SelfTestData& _internal_self_test_data() const;
+  public:
+  const ::sentencepiece::SelfTestData& self_test_data() const;
+  ::sentencepiece::SelfTestData* release_self_test_data();
+  ::sentencepiece::SelfTestData* mutable_self_test_data();
+  void set_allocated_self_test_data(::sentencepiece::SelfTestData* self_test_data);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ModelProto)
+  // @@protoc_insertion_point(class_scope:sentencepiece.ModelProto)
+ private:
+  void set_has_trainer_spec();
+  void clear_has_trainer_spec();
+  void set_has_normalizer_spec();
+  void clear_has_normalizer_spec();
+  void set_has_self_test_data();
+  void clear_has_self_test_data();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArenaLite _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable ::google::protobuf::internal::CachedSize _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::sentencepiece::ModelProto_SentencePiece > pieces_;
+  ::sentencepiece::TrainerSpec* trainer_spec_;
+  ::sentencepiece::NormalizerSpec* normalizer_spec_;
+  ::sentencepiece::SelfTestData* self_test_data_;
+  friend struct ::protobuf_sentencepiece_5fmodel_2eproto::TableStruct;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// TrainerSpec
+
+// repeated string input = 1;
+inline int TrainerSpec::input_size() const {
+  return input_.size();
+}
+inline void TrainerSpec::clear_input() {
+  input_.Clear();
+}
+inline const ::std::string& TrainerSpec::input(int index) const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.input)
+  return input_.Get(index);
+}
+inline ::std::string* TrainerSpec::mutable_input(int index) {
+  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.input)
+  return input_.Mutable(index);
+}
+inline void TrainerSpec::set_input(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.input)
+  input_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void TrainerSpec::set_input(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.input)
+  input_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void TrainerSpec::set_input(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  input_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:sentencepiece.TrainerSpec.input)
+}
+inline void TrainerSpec::set_input(int index, const char* value, size_t size) {
+  input_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.TrainerSpec.input)
+}
+inline ::std::string* TrainerSpec::add_input() {
+  // @@protoc_insertion_point(field_add_mutable:sentencepiece.TrainerSpec.input)
+  return input_.Add();
+}
+inline void TrainerSpec::add_input(const ::std::string& value) {
+  input_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.input)
+}
+#if LANG_CXX11
+inline void TrainerSpec::add_input(::std::string&& value) {
+  input_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.input)
+}
+#endif
+inline void TrainerSpec::add_input(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  input_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:sentencepiece.TrainerSpec.input)
+}
+inline void TrainerSpec::add_input(const char* value, size_t size) {
+  input_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:sentencepiece.TrainerSpec.input)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+TrainerSpec::input() const {
+  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.input)
+  return input_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+TrainerSpec::mutable_input() {
+  // @@protoc_insertion_point(field_mutable_list:sentencepiece.TrainerSpec.input)
+  return &input_;
+}
+
+// optional string input_format = 7;
+inline bool TrainerSpec::has_input_format() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void TrainerSpec::set_has_input_format() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void TrainerSpec::clear_has_input_format() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void TrainerSpec::clear_input_format() {
+  input_format_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_input_format();
+}
+inline const ::std::string& TrainerSpec::input_format() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.input_format)
+  return input_format_.GetNoArena();
+}
+inline void TrainerSpec::set_input_format(const ::std::string& value) {
+  set_has_input_format();
+  input_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.input_format)
+}
+#if LANG_CXX11
+inline void TrainerSpec::set_input_format(::std::string&& value) {
+  set_has_input_format();
+  input_format_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.TrainerSpec.input_format)
+}
+#endif
+inline void TrainerSpec::set_input_format(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_input_format();
+  input_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.TrainerSpec.input_format)
+}
+inline void TrainerSpec::set_input_format(const char* value, size_t size) {
+  set_has_input_format();
+  input_format_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.TrainerSpec.input_format)
+}
+inline ::std::string* TrainerSpec::mutable_input_format() {
+  set_has_input_format();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.input_format)
+  return input_format_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* TrainerSpec::release_input_format() {
+  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.input_format)
+  if (!has_input_format()) {
+    return NULL;
+  }
+  clear_has_input_format();
+  return input_format_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void TrainerSpec::set_allocated_input_format(::std::string* input_format) {
+  if (input_format != NULL) {
+    set_has_input_format();
+  } else {
+    clear_has_input_format();
+  }
+  input_format_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), input_format);
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.input_format)
+}
+
+// optional string model_prefix = 2;
+inline bool TrainerSpec::has_model_prefix() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void TrainerSpec::set_has_model_prefix() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void TrainerSpec::clear_has_model_prefix() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void TrainerSpec::clear_model_prefix() {
+  model_prefix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_model_prefix();
+}
+inline const ::std::string& TrainerSpec::model_prefix() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.model_prefix)
+  return model_prefix_.GetNoArena();
+}
+inline void TrainerSpec::set_model_prefix(const ::std::string& value) {
+  set_has_model_prefix();
+  model_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.model_prefix)
+}
+#if LANG_CXX11
+inline void TrainerSpec::set_model_prefix(::std::string&& value) {
+  set_has_model_prefix();
+  model_prefix_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.TrainerSpec.model_prefix)
+}
+#endif
+inline void TrainerSpec::set_model_prefix(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_model_prefix();
+  model_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.TrainerSpec.model_prefix)
+}
+inline void TrainerSpec::set_model_prefix(const char* value, size_t size) {
+  set_has_model_prefix();
+  model_prefix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.TrainerSpec.model_prefix)
+}
+inline ::std::string* TrainerSpec::mutable_model_prefix() {
+  set_has_model_prefix();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.model_prefix)
+  return model_prefix_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* TrainerSpec::release_model_prefix() {
+  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.model_prefix)
+  if (!has_model_prefix()) {
+    return NULL;
+  }
+  clear_has_model_prefix();
+  return model_prefix_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void TrainerSpec::set_allocated_model_prefix(::std::string* model_prefix) {
+  if (model_prefix != NULL) {
+    set_has_model_prefix();
+  } else {
+    clear_has_model_prefix();
+  }
+  model_prefix_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), model_prefix);
+  // @@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 {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void TrainerSpec::set_has_model_type() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void TrainerSpec::clear_has_model_type() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void TrainerSpec::clear_model_type() {
+  model_type_ = 1;
+  clear_has_model_type();
+}
+inline ::sentencepiece::TrainerSpec_ModelType TrainerSpec::model_type() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.model_type)
+  return static_cast< ::sentencepiece::TrainerSpec_ModelType >(model_type_);
+}
+inline void TrainerSpec::set_model_type(::sentencepiece::TrainerSpec_ModelType value) {
+  assert(::sentencepiece::TrainerSpec_ModelType_IsValid(value));
+  set_has_model_type();
+  model_type_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.model_type)
+}
+
+// optional int32 vocab_size = 4 [default = 8000];
+inline bool TrainerSpec::has_vocab_size() const {
+  return (_has_bits_[0] & 0x00008000u) != 0;
+}
+inline void TrainerSpec::set_has_vocab_size() {
+  _has_bits_[0] |= 0x00008000u;
+}
+inline void TrainerSpec::clear_has_vocab_size() {
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline void TrainerSpec::clear_vocab_size() {
+  vocab_size_ = 8000;
+  clear_has_vocab_size();
+}
+inline ::google::protobuf::int32 TrainerSpec::vocab_size() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.vocab_size)
+  return vocab_size_;
+}
+inline void TrainerSpec::set_vocab_size(::google::protobuf::int32 value) {
+  set_has_vocab_size();
+  vocab_size_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.vocab_size)
+}
+
+// repeated string accept_language = 5;
+inline int TrainerSpec::accept_language_size() const {
+  return accept_language_.size();
+}
+inline void TrainerSpec::clear_accept_language() {
+  accept_language_.Clear();
+}
+inline const ::std::string& TrainerSpec::accept_language(int index) const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.accept_language)
+  return accept_language_.Get(index);
+}
+inline ::std::string* TrainerSpec::mutable_accept_language(int index) {
+  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.accept_language)
+  return accept_language_.Mutable(index);
+}
+inline void TrainerSpec::set_accept_language(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.accept_language)
+  accept_language_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void TrainerSpec::set_accept_language(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.accept_language)
+  accept_language_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void TrainerSpec::set_accept_language(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  accept_language_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:sentencepiece.TrainerSpec.accept_language)
+}
+inline void TrainerSpec::set_accept_language(int index, const char* value, size_t size) {
+  accept_language_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.TrainerSpec.accept_language)
+}
+inline ::std::string* TrainerSpec::add_accept_language() {
+  // @@protoc_insertion_point(field_add_mutable:sentencepiece.TrainerSpec.accept_language)
+  return accept_language_.Add();
+}
+inline void TrainerSpec::add_accept_language(const ::std::string& value) {
+  accept_language_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.accept_language)
+}
+#if LANG_CXX11
+inline void TrainerSpec::add_accept_language(::std::string&& value) {
+  accept_language_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.accept_language)
+}
+#endif
+inline void TrainerSpec::add_accept_language(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  accept_language_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:sentencepiece.TrainerSpec.accept_language)
+}
+inline void TrainerSpec::add_accept_language(const char* value, size_t size) {
+  accept_language_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:sentencepiece.TrainerSpec.accept_language)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+TrainerSpec::accept_language() const {
+  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.accept_language)
+  return accept_language_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+TrainerSpec::mutable_accept_language() {
+  // @@protoc_insertion_point(field_mutable_list:sentencepiece.TrainerSpec.accept_language)
+  return &accept_language_;
+}
+
+// optional int32 self_test_sample_size = 6 [default = 0];
+inline bool TrainerSpec::has_self_test_sample_size() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void TrainerSpec::set_has_self_test_sample_size() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void TrainerSpec::clear_has_self_test_sample_size() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void TrainerSpec::clear_self_test_sample_size() {
+  self_test_sample_size_ = 0;
+  clear_has_self_test_sample_size();
+}
+inline ::google::protobuf::int32 TrainerSpec::self_test_sample_size() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.self_test_sample_size)
+  return self_test_sample_size_;
+}
+inline void TrainerSpec::set_self_test_sample_size(::google::protobuf::int32 value) {
+  set_has_self_test_sample_size();
+  self_test_sample_size_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.self_test_sample_size)
+}
+
+// optional float character_coverage = 10 [default = 0.9995];
+inline bool TrainerSpec::has_character_coverage() const {
+  return (_has_bits_[0] & 0x00010000u) != 0;
+}
+inline void TrainerSpec::set_has_character_coverage() {
+  _has_bits_[0] |= 0x00010000u;
+}
+inline void TrainerSpec::clear_has_character_coverage() {
+  _has_bits_[0] &= ~0x00010000u;
+}
+inline void TrainerSpec::clear_character_coverage() {
+  character_coverage_ = 0.9995f;
+  clear_has_character_coverage();
+}
+inline float TrainerSpec::character_coverage() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.character_coverage)
+  return character_coverage_;
+}
+inline void TrainerSpec::set_character_coverage(float value) {
+  set_has_character_coverage();
+  character_coverage_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.character_coverage)
+}
+
+// optional int32 input_sentence_size = 11 [default = 0];
+inline bool TrainerSpec::has_input_sentence_size() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void TrainerSpec::set_has_input_sentence_size() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void TrainerSpec::clear_has_input_sentence_size() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void TrainerSpec::clear_input_sentence_size() {
+  input_sentence_size_ = 0;
+  clear_has_input_sentence_size();
+}
+inline ::google::protobuf::int32 TrainerSpec::input_sentence_size() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.input_sentence_size)
+  return input_sentence_size_;
+}
+inline void TrainerSpec::set_input_sentence_size(::google::protobuf::int32 value) {
+  set_has_input_sentence_size();
+  input_sentence_size_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.input_sentence_size)
+}
+
+// optional bool shuffle_input_sentence = 19 [default = true];
+inline bool TrainerSpec::has_shuffle_input_sentence() const {
+  return (_has_bits_[0] & 0x00800000u) != 0;
+}
+inline void TrainerSpec::set_has_shuffle_input_sentence() {
+  _has_bits_[0] |= 0x00800000u;
+}
+inline void TrainerSpec::clear_has_shuffle_input_sentence() {
+  _has_bits_[0] &= ~0x00800000u;
+}
+inline void TrainerSpec::clear_shuffle_input_sentence() {
+  shuffle_input_sentence_ = true;
+  clear_has_shuffle_input_sentence();
+}
+inline bool TrainerSpec::shuffle_input_sentence() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.shuffle_input_sentence)
+  return shuffle_input_sentence_;
+}
+inline void TrainerSpec::set_shuffle_input_sentence(bool value) {
+  set_has_shuffle_input_sentence();
+  shuffle_input_sentence_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.shuffle_input_sentence)
+}
+
+// optional int32 mining_sentence_size = 12 [deprecated = true];
+inline bool TrainerSpec::has_mining_sentence_size() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void TrainerSpec::set_has_mining_sentence_size() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void TrainerSpec::clear_has_mining_sentence_size() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void TrainerSpec::clear_mining_sentence_size() {
+  mining_sentence_size_ = 0;
+  clear_has_mining_sentence_size();
+}
+inline ::google::protobuf::int32 TrainerSpec::mining_sentence_size() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.mining_sentence_size)
+  return mining_sentence_size_;
+}
+inline void TrainerSpec::set_mining_sentence_size(::google::protobuf::int32 value) {
+  set_has_mining_sentence_size();
+  mining_sentence_size_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.mining_sentence_size)
+}
+
+// optional int32 training_sentence_size = 13 [deprecated = true];
+inline bool TrainerSpec::has_training_sentence_size() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void TrainerSpec::set_has_training_sentence_size() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void TrainerSpec::clear_has_training_sentence_size() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void TrainerSpec::clear_training_sentence_size() {
+  training_sentence_size_ = 0;
+  clear_has_training_sentence_size();
+}
+inline ::google::protobuf::int32 TrainerSpec::training_sentence_size() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.training_sentence_size)
+  return training_sentence_size_;
+}
+inline void TrainerSpec::set_training_sentence_size(::google::protobuf::int32 value) {
+  set_has_training_sentence_size();
+  training_sentence_size_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.training_sentence_size)
+}
+
+// optional int32 seed_sentencepiece_size = 14 [default = 1000000];
+inline bool TrainerSpec::has_seed_sentencepiece_size() const {
+  return (_has_bits_[0] & 0x00020000u) != 0;
+}
+inline void TrainerSpec::set_has_seed_sentencepiece_size() {
+  _has_bits_[0] |= 0x00020000u;
+}
+inline void TrainerSpec::clear_has_seed_sentencepiece_size() {
+  _has_bits_[0] &= ~0x00020000u;
+}
+inline void TrainerSpec::clear_seed_sentencepiece_size() {
+  seed_sentencepiece_size_ = 1000000;
+  clear_has_seed_sentencepiece_size();
+}
+inline ::google::protobuf::int32 TrainerSpec::seed_sentencepiece_size() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.seed_sentencepiece_size)
+  return seed_sentencepiece_size_;
+}
+inline void TrainerSpec::set_seed_sentencepiece_size(::google::protobuf::int32 value) {
+  set_has_seed_sentencepiece_size();
+  seed_sentencepiece_size_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.seed_sentencepiece_size)
+}
+
+// optional float shrinking_factor = 15 [default = 0.75];
+inline bool TrainerSpec::has_shrinking_factor() const {
+  return (_has_bits_[0] & 0x00040000u) != 0;
+}
+inline void TrainerSpec::set_has_shrinking_factor() {
+  _has_bits_[0] |= 0x00040000u;
+}
+inline void TrainerSpec::clear_has_shrinking_factor() {
+  _has_bits_[0] &= ~0x00040000u;
+}
+inline void TrainerSpec::clear_shrinking_factor() {
+  shrinking_factor_ = 0.75f;
+  clear_has_shrinking_factor();
+}
+inline float TrainerSpec::shrinking_factor() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.shrinking_factor)
+  return shrinking_factor_;
+}
+inline void TrainerSpec::set_shrinking_factor(float value) {
+  set_has_shrinking_factor();
+  shrinking_factor_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.shrinking_factor)
+}
+
+// optional int32 max_sentence_length = 18 [default = 4192];
+inline bool TrainerSpec::has_max_sentence_length() const {
+  return (_has_bits_[0] & 0x00200000u) != 0;
+}
+inline void TrainerSpec::set_has_max_sentence_length() {
+  _has_bits_[0] |= 0x00200000u;
+}
+inline void TrainerSpec::clear_has_max_sentence_length() {
+  _has_bits_[0] &= ~0x00200000u;
+}
+inline void TrainerSpec::clear_max_sentence_length() {
+  max_sentence_length_ = 4192;
+  clear_has_max_sentence_length();
+}
+inline ::google::protobuf::int32 TrainerSpec::max_sentence_length() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.max_sentence_length)
+  return max_sentence_length_;
+}
+inline void TrainerSpec::set_max_sentence_length(::google::protobuf::int32 value) {
+  set_has_max_sentence_length();
+  max_sentence_length_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.max_sentence_length)
+}
+
+// optional int32 num_threads = 16 [default = 16];
+inline bool TrainerSpec::has_num_threads() const {
+  return (_has_bits_[0] & 0x00080000u) != 0;
+}
+inline void TrainerSpec::set_has_num_threads() {
+  _has_bits_[0] |= 0x00080000u;
+}
+inline void TrainerSpec::clear_has_num_threads() {
+  _has_bits_[0] &= ~0x00080000u;
+}
+inline void TrainerSpec::clear_num_threads() {
+  num_threads_ = 16;
+  clear_has_num_threads();
+}
+inline ::google::protobuf::int32 TrainerSpec::num_threads() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.num_threads)
+  return num_threads_;
+}
+inline void TrainerSpec::set_num_threads(::google::protobuf::int32 value) {
+  set_has_num_threads();
+  num_threads_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.num_threads)
+}
+
+// optional int32 num_sub_iterations = 17 [default = 2];
+inline bool TrainerSpec::has_num_sub_iterations() const {
+  return (_has_bits_[0] & 0x00100000u) != 0;
+}
+inline void TrainerSpec::set_has_num_sub_iterations() {
+  _has_bits_[0] |= 0x00100000u;
+}
+inline void TrainerSpec::clear_has_num_sub_iterations() {
+  _has_bits_[0] &= ~0x00100000u;
+}
+inline void TrainerSpec::clear_num_sub_iterations() {
+  num_sub_iterations_ = 2;
+  clear_has_num_sub_iterations();
+}
+inline ::google::protobuf::int32 TrainerSpec::num_sub_iterations() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.num_sub_iterations)
+  return num_sub_iterations_;
+}
+inline void TrainerSpec::set_num_sub_iterations(::google::protobuf::int32 value) {
+  set_has_num_sub_iterations();
+  num_sub_iterations_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.num_sub_iterations)
+}
+
+// optional int32 max_sentencepiece_length = 20 [default = 16];
+inline bool TrainerSpec::has_max_sentencepiece_length() const {
+  return (_has_bits_[0] & 0x00400000u) != 0;
+}
+inline void TrainerSpec::set_has_max_sentencepiece_length() {
+  _has_bits_[0] |= 0x00400000u;
+}
+inline void TrainerSpec::clear_has_max_sentencepiece_length() {
+  _has_bits_[0] &= ~0x00400000u;
+}
+inline void TrainerSpec::clear_max_sentencepiece_length() {
+  max_sentencepiece_length_ = 16;
+  clear_has_max_sentencepiece_length();
+}
+inline ::google::protobuf::int32 TrainerSpec::max_sentencepiece_length() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.max_sentencepiece_length)
+  return max_sentencepiece_length_;
+}
+inline void TrainerSpec::set_max_sentencepiece_length(::google::protobuf::int32 value) {
+  set_has_max_sentencepiece_length();
+  max_sentencepiece_length_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.max_sentencepiece_length)
+}
+
+// optional bool split_by_unicode_script = 21 [default = true];
+inline bool TrainerSpec::has_split_by_unicode_script() const {
+  return (_has_bits_[0] & 0x01000000u) != 0;
+}
+inline void TrainerSpec::set_has_split_by_unicode_script() {
+  _has_bits_[0] |= 0x01000000u;
+}
+inline void TrainerSpec::clear_has_split_by_unicode_script() {
+  _has_bits_[0] &= ~0x01000000u;
+}
+inline void TrainerSpec::clear_split_by_unicode_script() {
+  split_by_unicode_script_ = true;
+  clear_has_split_by_unicode_script();
+}
+inline bool TrainerSpec::split_by_unicode_script() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.split_by_unicode_script)
+  return split_by_unicode_script_;
+}
+inline void TrainerSpec::set_split_by_unicode_script(bool value) {
+  set_has_split_by_unicode_script();
+  split_by_unicode_script_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.split_by_unicode_script)
+}
+
+// optional bool split_by_number = 23 [default = true];
+inline bool TrainerSpec::has_split_by_number() const {
+  return (_has_bits_[0] & 0x02000000u) != 0;
+}
+inline void TrainerSpec::set_has_split_by_number() {
+  _has_bits_[0] |= 0x02000000u;
+}
+inline void TrainerSpec::clear_has_split_by_number() {
+  _has_bits_[0] &= ~0x02000000u;
+}
+inline void TrainerSpec::clear_split_by_number() {
+  split_by_number_ = true;
+  clear_has_split_by_number();
+}
+inline bool TrainerSpec::split_by_number() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.split_by_number)
+  return split_by_number_;
+}
+inline void TrainerSpec::set_split_by_number(bool value) {
+  set_has_split_by_number();
+  split_by_number_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.split_by_number)
+}
+
+// optional bool split_by_whitespace = 22 [default = true];
+inline bool TrainerSpec::has_split_by_whitespace() const {
+  return (_has_bits_[0] & 0x04000000u) != 0;
+}
+inline void TrainerSpec::set_has_split_by_whitespace() {
+  _has_bits_[0] |= 0x04000000u;
+}
+inline void TrainerSpec::clear_has_split_by_whitespace() {
+  _has_bits_[0] &= ~0x04000000u;
+}
+inline void TrainerSpec::clear_split_by_whitespace() {
+  split_by_whitespace_ = true;
+  clear_has_split_by_whitespace();
+}
+inline bool TrainerSpec::split_by_whitespace() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.split_by_whitespace)
+  return split_by_whitespace_;
+}
+inline void TrainerSpec::set_split_by_whitespace(bool value) {
+  set_has_split_by_whitespace();
+  split_by_whitespace_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.split_by_whitespace)
+}
+
+// optional bool treat_whitespace_as_suffix = 24 [default = false];
+inline bool TrainerSpec::has_treat_whitespace_as_suffix() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void TrainerSpec::set_has_treat_whitespace_as_suffix() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void TrainerSpec::clear_has_treat_whitespace_as_suffix() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void TrainerSpec::clear_treat_whitespace_as_suffix() {
+  treat_whitespace_as_suffix_ = false;
+  clear_has_treat_whitespace_as_suffix();
+}
+inline bool TrainerSpec::treat_whitespace_as_suffix() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.treat_whitespace_as_suffix)
+  return treat_whitespace_as_suffix_;
+}
+inline void TrainerSpec::set_treat_whitespace_as_suffix(bool value) {
+  set_has_treat_whitespace_as_suffix();
+  treat_whitespace_as_suffix_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.treat_whitespace_as_suffix)
+}
+
+// repeated string control_symbols = 30;
+inline int TrainerSpec::control_symbols_size() const {
+  return control_symbols_.size();
+}
+inline void TrainerSpec::clear_control_symbols() {
+  control_symbols_.Clear();
+}
+inline const ::std::string& TrainerSpec::control_symbols(int index) const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.control_symbols)
+  return control_symbols_.Get(index);
+}
+inline ::std::string* TrainerSpec::mutable_control_symbols(int index) {
+  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.control_symbols)
+  return control_symbols_.Mutable(index);
+}
+inline void TrainerSpec::set_control_symbols(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.control_symbols)
+  control_symbols_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void TrainerSpec::set_control_symbols(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.control_symbols)
+  control_symbols_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void TrainerSpec::set_control_symbols(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  control_symbols_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:sentencepiece.TrainerSpec.control_symbols)
+}
+inline void TrainerSpec::set_control_symbols(int index, const char* value, size_t size) {
+  control_symbols_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.TrainerSpec.control_symbols)
+}
+inline ::std::string* TrainerSpec::add_control_symbols() {
+  // @@protoc_insertion_point(field_add_mutable:sentencepiece.TrainerSpec.control_symbols)
+  return control_symbols_.Add();
+}
+inline void TrainerSpec::add_control_symbols(const ::std::string& value) {
+  control_symbols_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.control_symbols)
+}
+#if LANG_CXX11
+inline void TrainerSpec::add_control_symbols(::std::string&& value) {
+  control_symbols_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.control_symbols)
+}
+#endif
+inline void TrainerSpec::add_control_symbols(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  control_symbols_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:sentencepiece.TrainerSpec.control_symbols)
+}
+inline void TrainerSpec::add_control_symbols(const char* value, size_t size) {
+  control_symbols_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:sentencepiece.TrainerSpec.control_symbols)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+TrainerSpec::control_symbols() const {
+  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.control_symbols)
+  return control_symbols_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+TrainerSpec::mutable_control_symbols() {
+  // @@protoc_insertion_point(field_mutable_list:sentencepiece.TrainerSpec.control_symbols)
+  return &control_symbols_;
+}
+
+// repeated string user_defined_symbols = 31;
+inline int TrainerSpec::user_defined_symbols_size() const {
+  return user_defined_symbols_.size();
+}
+inline void TrainerSpec::clear_user_defined_symbols() {
+  user_defined_symbols_.Clear();
+}
+inline const ::std::string& TrainerSpec::user_defined_symbols(int index) const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.user_defined_symbols)
+  return user_defined_symbols_.Get(index);
+}
+inline ::std::string* TrainerSpec::mutable_user_defined_symbols(int index) {
+  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.user_defined_symbols)
+  return user_defined_symbols_.Mutable(index);
+}
+inline void TrainerSpec::set_user_defined_symbols(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.user_defined_symbols)
+  user_defined_symbols_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void TrainerSpec::set_user_defined_symbols(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.user_defined_symbols)
+  user_defined_symbols_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void TrainerSpec::set_user_defined_symbols(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  user_defined_symbols_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:sentencepiece.TrainerSpec.user_defined_symbols)
+}
+inline void TrainerSpec::set_user_defined_symbols(int index, const char* value, size_t size) {
+  user_defined_symbols_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.TrainerSpec.user_defined_symbols)
+}
+inline ::std::string* TrainerSpec::add_user_defined_symbols() {
+  // @@protoc_insertion_point(field_add_mutable:sentencepiece.TrainerSpec.user_defined_symbols)
+  return user_defined_symbols_.Add();
+}
+inline void TrainerSpec::add_user_defined_symbols(const ::std::string& value) {
+  user_defined_symbols_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.user_defined_symbols)
+}
+#if LANG_CXX11
+inline void TrainerSpec::add_user_defined_symbols(::std::string&& value) {
+  user_defined_symbols_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:sentencepiece.TrainerSpec.user_defined_symbols)
+}
+#endif
+inline void TrainerSpec::add_user_defined_symbols(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  user_defined_symbols_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:sentencepiece.TrainerSpec.user_defined_symbols)
+}
+inline void TrainerSpec::add_user_defined_symbols(const char* value, size_t size) {
+  user_defined_symbols_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:sentencepiece.TrainerSpec.user_defined_symbols)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+TrainerSpec::user_defined_symbols() const {
+  // @@protoc_insertion_point(field_list:sentencepiece.TrainerSpec.user_defined_symbols)
+  return user_defined_symbols_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+TrainerSpec::mutable_user_defined_symbols() {
+  // @@protoc_insertion_point(field_mutable_list:sentencepiece.TrainerSpec.user_defined_symbols)
+  return &user_defined_symbols_;
+}
+
+// optional bool hard_vocab_limit = 33 [default = true];
+inline bool TrainerSpec::has_hard_vocab_limit() const {
+  return (_has_bits_[0] & 0x08000000u) != 0;
+}
+inline void TrainerSpec::set_has_hard_vocab_limit() {
+  _has_bits_[0] |= 0x08000000u;
+}
+inline void TrainerSpec::clear_has_hard_vocab_limit() {
+  _has_bits_[0] &= ~0x08000000u;
+}
+inline void TrainerSpec::clear_hard_vocab_limit() {
+  hard_vocab_limit_ = true;
+  clear_has_hard_vocab_limit();
+}
+inline bool TrainerSpec::hard_vocab_limit() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.hard_vocab_limit)
+  return hard_vocab_limit_;
+}
+inline void TrainerSpec::set_hard_vocab_limit(bool value) {
+  set_has_hard_vocab_limit();
+  hard_vocab_limit_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.hard_vocab_limit)
+}
+
+// optional bool use_all_vocab = 34 [default = false];
+inline bool TrainerSpec::has_use_all_vocab() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void TrainerSpec::set_has_use_all_vocab() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void TrainerSpec::clear_has_use_all_vocab() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void TrainerSpec::clear_use_all_vocab() {
+  use_all_vocab_ = false;
+  clear_has_use_all_vocab();
+}
+inline bool TrainerSpec::use_all_vocab() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.use_all_vocab)
+  return use_all_vocab_;
+}
+inline void TrainerSpec::set_use_all_vocab(bool value) {
+  set_has_use_all_vocab();
+  use_all_vocab_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.use_all_vocab)
+}
+
+// optional int32 unk_id = 40 [default = 0];
+inline bool TrainerSpec::has_unk_id() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void TrainerSpec::set_has_unk_id() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void TrainerSpec::clear_has_unk_id() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void TrainerSpec::clear_unk_id() {
+  unk_id_ = 0;
+  clear_has_unk_id();
+}
+inline ::google::protobuf::int32 TrainerSpec::unk_id() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_id)
+  return unk_id_;
+}
+inline void TrainerSpec::set_unk_id(::google::protobuf::int32 value) {
+  set_has_unk_id();
+  unk_id_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.unk_id)
+}
+
+// optional int32 bos_id = 41 [default = 1];
+inline bool TrainerSpec::has_bos_id() const {
+  return (_has_bits_[0] & 0x10000000u) != 0;
+}
+inline void TrainerSpec::set_has_bos_id() {
+  _has_bits_[0] |= 0x10000000u;
+}
+inline void TrainerSpec::clear_has_bos_id() {
+  _has_bits_[0] &= ~0x10000000u;
+}
+inline void TrainerSpec::clear_bos_id() {
+  bos_id_ = 1;
+  clear_has_bos_id();
+}
+inline ::google::protobuf::int32 TrainerSpec::bos_id() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.bos_id)
+  return bos_id_;
+}
+inline void TrainerSpec::set_bos_id(::google::protobuf::int32 value) {
+  set_has_bos_id();
+  bos_id_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.bos_id)
+}
+
+// optional int32 eos_id = 42 [default = 2];
+inline bool TrainerSpec::has_eos_id() const {
+  return (_has_bits_[0] & 0x20000000u) != 0;
+}
+inline void TrainerSpec::set_has_eos_id() {
+  _has_bits_[0] |= 0x20000000u;
+}
+inline void TrainerSpec::clear_has_eos_id() {
+  _has_bits_[0] &= ~0x20000000u;
+}
+inline void TrainerSpec::clear_eos_id() {
+  eos_id_ = 2;
+  clear_has_eos_id();
+}
+inline ::google::protobuf::int32 TrainerSpec::eos_id() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.eos_id)
+  return eos_id_;
+}
+inline void TrainerSpec::set_eos_id(::google::protobuf::int32 value) {
+  set_has_eos_id();
+  eos_id_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.eos_id)
+}
+
+// optional int32 pad_id = 43 [default = -1];
+inline bool TrainerSpec::has_pad_id() const {
+  return (_has_bits_[0] & 0x40000000u) != 0;
+}
+inline void TrainerSpec::set_has_pad_id() {
+  _has_bits_[0] |= 0x40000000u;
+}
+inline void TrainerSpec::clear_has_pad_id() {
+  _has_bits_[0] &= ~0x40000000u;
+}
+inline void TrainerSpec::clear_pad_id() {
+  pad_id_ = -1;
+  clear_has_pad_id();
+}
+inline ::google::protobuf::int32 TrainerSpec::pad_id() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.pad_id)
+  return pad_id_;
+}
+inline void TrainerSpec::set_pad_id(::google::protobuf::int32 value) {
+  set_has_pad_id();
+  pad_id_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.pad_id)
+}
+
+// optional string unk_piece = 45 [default = "<unk>"];
+inline bool TrainerSpec::has_unk_piece() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void TrainerSpec::set_has_unk_piece() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void TrainerSpec::clear_has_unk_piece() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void TrainerSpec::clear_unk_piece() {
+  unk_piece_.ClearToDefaultNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_piece_.get());
+  clear_has_unk_piece();
+}
+inline const ::std::string& TrainerSpec::unk_piece() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_piece)
+  return unk_piece_.GetNoArena();
+}
+inline void TrainerSpec::set_unk_piece(const ::std::string& value) {
+  set_has_unk_piece();
+  unk_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_piece_.get(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.unk_piece)
+}
+#if LANG_CXX11
+inline void TrainerSpec::set_unk_piece(::std::string&& value) {
+  set_has_unk_piece();
+  unk_piece_.SetNoArena(
+    &::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_piece_.get(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.TrainerSpec.unk_piece)
+}
+#endif
+inline void TrainerSpec::set_unk_piece(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_unk_piece();
+  unk_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_piece_.get(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.TrainerSpec.unk_piece)
+}
+inline void TrainerSpec::set_unk_piece(const char* value, size_t size) {
+  set_has_unk_piece();
+  unk_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_piece_.get(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.TrainerSpec.unk_piece)
+}
+inline ::std::string* TrainerSpec::mutable_unk_piece() {
+  set_has_unk_piece();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.unk_piece)
+  return unk_piece_.MutableNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_piece_.get());
+}
+inline ::std::string* TrainerSpec::release_unk_piece() {
+  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.unk_piece)
+  if (!has_unk_piece()) {
+    return NULL;
+  }
+  clear_has_unk_piece();
+  return unk_piece_.ReleaseNonDefaultNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_piece_.get());
+}
+inline void TrainerSpec::set_allocated_unk_piece(::std::string* unk_piece) {
+  if (unk_piece != NULL) {
+    set_has_unk_piece();
+  } else {
+    clear_has_unk_piece();
+  }
+  unk_piece_.SetAllocatedNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_piece_.get(), unk_piece);
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.unk_piece)
+}
+
+// optional string bos_piece = 46 [default = "<s>"];
+inline bool TrainerSpec::has_bos_piece() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void TrainerSpec::set_has_bos_piece() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void TrainerSpec::clear_has_bos_piece() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void TrainerSpec::clear_bos_piece() {
+  bos_piece_.ClearToDefaultNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_bos_piece_.get());
+  clear_has_bos_piece();
+}
+inline const ::std::string& TrainerSpec::bos_piece() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.bos_piece)
+  return bos_piece_.GetNoArena();
+}
+inline void TrainerSpec::set_bos_piece(const ::std::string& value) {
+  set_has_bos_piece();
+  bos_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_bos_piece_.get(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.bos_piece)
+}
+#if LANG_CXX11
+inline void TrainerSpec::set_bos_piece(::std::string&& value) {
+  set_has_bos_piece();
+  bos_piece_.SetNoArena(
+    &::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_bos_piece_.get(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.TrainerSpec.bos_piece)
+}
+#endif
+inline void TrainerSpec::set_bos_piece(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_bos_piece();
+  bos_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_bos_piece_.get(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.TrainerSpec.bos_piece)
+}
+inline void TrainerSpec::set_bos_piece(const char* value, size_t size) {
+  set_has_bos_piece();
+  bos_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_bos_piece_.get(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.TrainerSpec.bos_piece)
+}
+inline ::std::string* TrainerSpec::mutable_bos_piece() {
+  set_has_bos_piece();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.bos_piece)
+  return bos_piece_.MutableNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_bos_piece_.get());
+}
+inline ::std::string* TrainerSpec::release_bos_piece() {
+  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.bos_piece)
+  if (!has_bos_piece()) {
+    return NULL;
+  }
+  clear_has_bos_piece();
+  return bos_piece_.ReleaseNonDefaultNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_bos_piece_.get());
+}
+inline void TrainerSpec::set_allocated_bos_piece(::std::string* bos_piece) {
+  if (bos_piece != NULL) {
+    set_has_bos_piece();
+  } else {
+    clear_has_bos_piece();
+  }
+  bos_piece_.SetAllocatedNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_bos_piece_.get(), bos_piece);
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.bos_piece)
+}
+
+// optional string eos_piece = 47 [default = "</s>"];
+inline bool TrainerSpec::has_eos_piece() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void TrainerSpec::set_has_eos_piece() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void TrainerSpec::clear_has_eos_piece() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void TrainerSpec::clear_eos_piece() {
+  eos_piece_.ClearToDefaultNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_eos_piece_.get());
+  clear_has_eos_piece();
+}
+inline const ::std::string& TrainerSpec::eos_piece() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.eos_piece)
+  return eos_piece_.GetNoArena();
+}
+inline void TrainerSpec::set_eos_piece(const ::std::string& value) {
+  set_has_eos_piece();
+  eos_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_eos_piece_.get(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.eos_piece)
+}
+#if LANG_CXX11
+inline void TrainerSpec::set_eos_piece(::std::string&& value) {
+  set_has_eos_piece();
+  eos_piece_.SetNoArena(
+    &::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_eos_piece_.get(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.TrainerSpec.eos_piece)
+}
+#endif
+inline void TrainerSpec::set_eos_piece(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_eos_piece();
+  eos_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_eos_piece_.get(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.TrainerSpec.eos_piece)
+}
+inline void TrainerSpec::set_eos_piece(const char* value, size_t size) {
+  set_has_eos_piece();
+  eos_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_eos_piece_.get(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.TrainerSpec.eos_piece)
+}
+inline ::std::string* TrainerSpec::mutable_eos_piece() {
+  set_has_eos_piece();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.eos_piece)
+  return eos_piece_.MutableNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_eos_piece_.get());
+}
+inline ::std::string* TrainerSpec::release_eos_piece() {
+  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.eos_piece)
+  if (!has_eos_piece()) {
+    return NULL;
+  }
+  clear_has_eos_piece();
+  return eos_piece_.ReleaseNonDefaultNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_eos_piece_.get());
+}
+inline void TrainerSpec::set_allocated_eos_piece(::std::string* eos_piece) {
+  if (eos_piece != NULL) {
+    set_has_eos_piece();
+  } else {
+    clear_has_eos_piece();
+  }
+  eos_piece_.SetAllocatedNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_eos_piece_.get(), eos_piece);
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.eos_piece)
+}
+
+// optional string pad_piece = 48 [default = "<pad>"];
+inline bool TrainerSpec::has_pad_piece() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void TrainerSpec::set_has_pad_piece() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void TrainerSpec::clear_has_pad_piece() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void TrainerSpec::clear_pad_piece() {
+  pad_piece_.ClearToDefaultNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_pad_piece_.get());
+  clear_has_pad_piece();
+}
+inline const ::std::string& TrainerSpec::pad_piece() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.pad_piece)
+  return pad_piece_.GetNoArena();
+}
+inline void TrainerSpec::set_pad_piece(const ::std::string& value) {
+  set_has_pad_piece();
+  pad_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_pad_piece_.get(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.pad_piece)
+}
+#if LANG_CXX11
+inline void TrainerSpec::set_pad_piece(::std::string&& value) {
+  set_has_pad_piece();
+  pad_piece_.SetNoArena(
+    &::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_pad_piece_.get(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.TrainerSpec.pad_piece)
+}
+#endif
+inline void TrainerSpec::set_pad_piece(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_pad_piece();
+  pad_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_pad_piece_.get(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.TrainerSpec.pad_piece)
+}
+inline void TrainerSpec::set_pad_piece(const char* value, size_t size) {
+  set_has_pad_piece();
+  pad_piece_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_pad_piece_.get(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.TrainerSpec.pad_piece)
+}
+inline ::std::string* TrainerSpec::mutable_pad_piece() {
+  set_has_pad_piece();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.pad_piece)
+  return pad_piece_.MutableNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_pad_piece_.get());
+}
+inline ::std::string* TrainerSpec::release_pad_piece() {
+  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.pad_piece)
+  if (!has_pad_piece()) {
+    return NULL;
+  }
+  clear_has_pad_piece();
+  return pad_piece_.ReleaseNonDefaultNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_pad_piece_.get());
+}
+inline void TrainerSpec::set_allocated_pad_piece(::std::string* pad_piece) {
+  if (pad_piece != NULL) {
+    set_has_pad_piece();
+  } else {
+    clear_has_pad_piece();
+  }
+  pad_piece_.SetAllocatedNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_pad_piece_.get(), pad_piece);
+  // @@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 {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void TrainerSpec::set_has_unk_surface() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void TrainerSpec::clear_has_unk_surface() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void TrainerSpec::clear_unk_surface() {
+  unk_surface_.ClearToDefaultNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_surface_.get());
+  clear_has_unk_surface();
+}
+inline const ::std::string& TrainerSpec::unk_surface() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.TrainerSpec.unk_surface)
+  return unk_surface_.GetNoArena();
+}
+inline void TrainerSpec::set_unk_surface(const ::std::string& value) {
+  set_has_unk_surface();
+  unk_surface_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_surface_.get(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.TrainerSpec.unk_surface)
+}
+#if LANG_CXX11
+inline void TrainerSpec::set_unk_surface(::std::string&& value) {
+  set_has_unk_surface();
+  unk_surface_.SetNoArena(
+    &::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_surface_.get(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.TrainerSpec.unk_surface)
+}
+#endif
+inline void TrainerSpec::set_unk_surface(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_unk_surface();
+  unk_surface_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_surface_.get(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.TrainerSpec.unk_surface)
+}
+inline void TrainerSpec::set_unk_surface(const char* value, size_t size) {
+  set_has_unk_surface();
+  unk_surface_.SetNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_surface_.get(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.TrainerSpec.unk_surface)
+}
+inline ::std::string* TrainerSpec::mutable_unk_surface() {
+  set_has_unk_surface();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.TrainerSpec.unk_surface)
+  return unk_surface_.MutableNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_surface_.get());
+}
+inline ::std::string* TrainerSpec::release_unk_surface() {
+  // @@protoc_insertion_point(field_release:sentencepiece.TrainerSpec.unk_surface)
+  if (!has_unk_surface()) {
+    return NULL;
+  }
+  clear_has_unk_surface();
+  return unk_surface_.ReleaseNonDefaultNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_surface_.get());
+}
+inline void TrainerSpec::set_allocated_unk_surface(::std::string* unk_surface) {
+  if (unk_surface != NULL) {
+    set_has_unk_surface();
+  } else {
+    clear_has_unk_surface();
+  }
+  unk_surface_.SetAllocatedNoArena(&::sentencepiece::TrainerSpec::_i_give_permission_to_break_this_code_default_unk_surface_.get(), unk_surface);
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.TrainerSpec.unk_surface)
+}
+
+// -------------------------------------------------------------------
+
+// NormalizerSpec
+
+// optional string name = 1;
+inline bool NormalizerSpec::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void NormalizerSpec::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void NormalizerSpec::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void NormalizerSpec::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_name();
+}
+inline const ::std::string& NormalizerSpec::name() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.name)
+  return name_.GetNoArena();
+}
+inline void NormalizerSpec::set_name(const ::std::string& value) {
+  set_has_name();
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.name)
+}
+#if LANG_CXX11
+inline void NormalizerSpec::set_name(::std::string&& value) {
+  set_has_name();
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.NormalizerSpec.name)
+}
+#endif
+inline void NormalizerSpec::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_name();
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.NormalizerSpec.name)
+}
+inline void NormalizerSpec::set_name(const char* value, size_t size) {
+  set_has_name();
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.NormalizerSpec.name)
+}
+inline ::std::string* NormalizerSpec::mutable_name() {
+  set_has_name();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.NormalizerSpec.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* NormalizerSpec::release_name() {
+  // @@protoc_insertion_point(field_release:sentencepiece.NormalizerSpec.name)
+  if (!has_name()) {
+    return NULL;
+  }
+  clear_has_name();
+  return name_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void NormalizerSpec::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.NormalizerSpec.name)
+}
+
+// optional bytes precompiled_charsmap = 2;
+inline bool NormalizerSpec::has_precompiled_charsmap() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void NormalizerSpec::set_has_precompiled_charsmap() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void NormalizerSpec::clear_has_precompiled_charsmap() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void NormalizerSpec::clear_precompiled_charsmap() {
+  precompiled_charsmap_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_precompiled_charsmap();
+}
+inline const ::std::string& NormalizerSpec::precompiled_charsmap() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.precompiled_charsmap)
+  return precompiled_charsmap_.GetNoArena();
+}
+inline void NormalizerSpec::set_precompiled_charsmap(const ::std::string& value) {
+  set_has_precompiled_charsmap();
+  precompiled_charsmap_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.precompiled_charsmap)
+}
+#if LANG_CXX11
+inline void NormalizerSpec::set_precompiled_charsmap(::std::string&& value) {
+  set_has_precompiled_charsmap();
+  precompiled_charsmap_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.NormalizerSpec.precompiled_charsmap)
+}
+#endif
+inline void NormalizerSpec::set_precompiled_charsmap(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_precompiled_charsmap();
+  precompiled_charsmap_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.NormalizerSpec.precompiled_charsmap)
+}
+inline void NormalizerSpec::set_precompiled_charsmap(const void* value, size_t size) {
+  set_has_precompiled_charsmap();
+  precompiled_charsmap_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.NormalizerSpec.precompiled_charsmap)
+}
+inline ::std::string* NormalizerSpec::mutable_precompiled_charsmap() {
+  set_has_precompiled_charsmap();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.NormalizerSpec.precompiled_charsmap)
+  return precompiled_charsmap_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* NormalizerSpec::release_precompiled_charsmap() {
+  // @@protoc_insertion_point(field_release:sentencepiece.NormalizerSpec.precompiled_charsmap)
+  if (!has_precompiled_charsmap()) {
+    return NULL;
+  }
+  clear_has_precompiled_charsmap();
+  return precompiled_charsmap_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void NormalizerSpec::set_allocated_precompiled_charsmap(::std::string* precompiled_charsmap) {
+  if (precompiled_charsmap != NULL) {
+    set_has_precompiled_charsmap();
+  } else {
+    clear_has_precompiled_charsmap();
+  }
+  precompiled_charsmap_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), precompiled_charsmap);
+  // @@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 {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void NormalizerSpec::set_has_add_dummy_prefix() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void NormalizerSpec::clear_has_add_dummy_prefix() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void NormalizerSpec::clear_add_dummy_prefix() {
+  add_dummy_prefix_ = true;
+  clear_has_add_dummy_prefix();
+}
+inline bool NormalizerSpec::add_dummy_prefix() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.add_dummy_prefix)
+  return add_dummy_prefix_;
+}
+inline void NormalizerSpec::set_add_dummy_prefix(bool value) {
+  set_has_add_dummy_prefix();
+  add_dummy_prefix_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.add_dummy_prefix)
+}
+
+// optional bool remove_extra_whitespaces = 4 [default = true];
+inline bool NormalizerSpec::has_remove_extra_whitespaces() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void NormalizerSpec::set_has_remove_extra_whitespaces() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void NormalizerSpec::clear_has_remove_extra_whitespaces() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void NormalizerSpec::clear_remove_extra_whitespaces() {
+  remove_extra_whitespaces_ = true;
+  clear_has_remove_extra_whitespaces();
+}
+inline bool NormalizerSpec::remove_extra_whitespaces() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.remove_extra_whitespaces)
+  return remove_extra_whitespaces_;
+}
+inline void NormalizerSpec::set_remove_extra_whitespaces(bool value) {
+  set_has_remove_extra_whitespaces();
+  remove_extra_whitespaces_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.remove_extra_whitespaces)
+}
+
+// optional bool escape_whitespaces = 5 [default = true];
+inline bool NormalizerSpec::has_escape_whitespaces() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void NormalizerSpec::set_has_escape_whitespaces() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void NormalizerSpec::clear_has_escape_whitespaces() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void NormalizerSpec::clear_escape_whitespaces() {
+  escape_whitespaces_ = true;
+  clear_has_escape_whitespaces();
+}
+inline bool NormalizerSpec::escape_whitespaces() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.escape_whitespaces)
+  return escape_whitespaces_;
+}
+inline void NormalizerSpec::set_escape_whitespaces(bool value) {
+  set_has_escape_whitespaces();
+  escape_whitespaces_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.escape_whitespaces)
+}
+
+// optional string normalization_rule_tsv = 6;
+inline bool NormalizerSpec::has_normalization_rule_tsv() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void NormalizerSpec::set_has_normalization_rule_tsv() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void NormalizerSpec::clear_has_normalization_rule_tsv() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void NormalizerSpec::clear_normalization_rule_tsv() {
+  normalization_rule_tsv_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_normalization_rule_tsv();
+}
+inline const ::std::string& NormalizerSpec::normalization_rule_tsv() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.NormalizerSpec.normalization_rule_tsv)
+  return normalization_rule_tsv_.GetNoArena();
+}
+inline void NormalizerSpec::set_normalization_rule_tsv(const ::std::string& value) {
+  set_has_normalization_rule_tsv();
+  normalization_rule_tsv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.NormalizerSpec.normalization_rule_tsv)
+}
+#if LANG_CXX11
+inline void NormalizerSpec::set_normalization_rule_tsv(::std::string&& value) {
+  set_has_normalization_rule_tsv();
+  normalization_rule_tsv_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.NormalizerSpec.normalization_rule_tsv)
+}
+#endif
+inline void NormalizerSpec::set_normalization_rule_tsv(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_normalization_rule_tsv();
+  normalization_rule_tsv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.NormalizerSpec.normalization_rule_tsv)
+}
+inline void NormalizerSpec::set_normalization_rule_tsv(const char* value, size_t size) {
+  set_has_normalization_rule_tsv();
+  normalization_rule_tsv_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.NormalizerSpec.normalization_rule_tsv)
+}
+inline ::std::string* NormalizerSpec::mutable_normalization_rule_tsv() {
+  set_has_normalization_rule_tsv();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.NormalizerSpec.normalization_rule_tsv)
+  return normalization_rule_tsv_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* NormalizerSpec::release_normalization_rule_tsv() {
+  // @@protoc_insertion_point(field_release:sentencepiece.NormalizerSpec.normalization_rule_tsv)
+  if (!has_normalization_rule_tsv()) {
+    return NULL;
+  }
+  clear_has_normalization_rule_tsv();
+  return normalization_rule_tsv_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void NormalizerSpec::set_allocated_normalization_rule_tsv(::std::string* normalization_rule_tsv) {
+  if (normalization_rule_tsv != NULL) {
+    set_has_normalization_rule_tsv();
+  } else {
+    clear_has_normalization_rule_tsv();
+  }
+  normalization_rule_tsv_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), normalization_rule_tsv);
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.NormalizerSpec.normalization_rule_tsv)
+}
+
+// -------------------------------------------------------------------
+
+// SelfTestData_Sample
+
+// optional string input = 1;
+inline bool SelfTestData_Sample::has_input() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SelfTestData_Sample::set_has_input() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SelfTestData_Sample::clear_has_input() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SelfTestData_Sample::clear_input() {
+  input_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_input();
+}
+inline const ::std::string& SelfTestData_Sample::input() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.SelfTestData.Sample.input)
+  return input_.GetNoArena();
+}
+inline void SelfTestData_Sample::set_input(const ::std::string& value) {
+  set_has_input();
+  input_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.SelfTestData.Sample.input)
+}
+#if LANG_CXX11
+inline void SelfTestData_Sample::set_input(::std::string&& value) {
+  set_has_input();
+  input_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.SelfTestData.Sample.input)
+}
+#endif
+inline void SelfTestData_Sample::set_input(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_input();
+  input_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.SelfTestData.Sample.input)
+}
+inline void SelfTestData_Sample::set_input(const char* value, size_t size) {
+  set_has_input();
+  input_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.SelfTestData.Sample.input)
+}
+inline ::std::string* SelfTestData_Sample::mutable_input() {
+  set_has_input();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.SelfTestData.Sample.input)
+  return input_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* SelfTestData_Sample::release_input() {
+  // @@protoc_insertion_point(field_release:sentencepiece.SelfTestData.Sample.input)
+  if (!has_input()) {
+    return NULL;
+  }
+  clear_has_input();
+  return input_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void SelfTestData_Sample::set_allocated_input(::std::string* input) {
+  if (input != NULL) {
+    set_has_input();
+  } else {
+    clear_has_input();
+  }
+  input_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), input);
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.SelfTestData.Sample.input)
+}
+
+// optional string expected = 2;
+inline bool SelfTestData_Sample::has_expected() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SelfTestData_Sample::set_has_expected() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SelfTestData_Sample::clear_has_expected() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SelfTestData_Sample::clear_expected() {
+  expected_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_expected();
+}
+inline const ::std::string& SelfTestData_Sample::expected() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.SelfTestData.Sample.expected)
+  return expected_.GetNoArena();
+}
+inline void SelfTestData_Sample::set_expected(const ::std::string& value) {
+  set_has_expected();
+  expected_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.SelfTestData.Sample.expected)
+}
+#if LANG_CXX11
+inline void SelfTestData_Sample::set_expected(::std::string&& value) {
+  set_has_expected();
+  expected_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.SelfTestData.Sample.expected)
+}
+#endif
+inline void SelfTestData_Sample::set_expected(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_expected();
+  expected_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.SelfTestData.Sample.expected)
+}
+inline void SelfTestData_Sample::set_expected(const char* value, size_t size) {
+  set_has_expected();
+  expected_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.SelfTestData.Sample.expected)
+}
+inline ::std::string* SelfTestData_Sample::mutable_expected() {
+  set_has_expected();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.SelfTestData.Sample.expected)
+  return expected_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* SelfTestData_Sample::release_expected() {
+  // @@protoc_insertion_point(field_release:sentencepiece.SelfTestData.Sample.expected)
+  if (!has_expected()) {
+    return NULL;
+  }
+  clear_has_expected();
+  return expected_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void SelfTestData_Sample::set_allocated_expected(::std::string* expected) {
+  if (expected != NULL) {
+    set_has_expected();
+  } else {
+    clear_has_expected();
+  }
+  expected_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), expected);
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.SelfTestData.Sample.expected)
+}
+
+// -------------------------------------------------------------------
+
+// SelfTestData
+
+// repeated .sentencepiece.SelfTestData.Sample samples = 1;
+inline int SelfTestData::samples_size() const {
+  return samples_.size();
+}
+inline void SelfTestData::clear_samples() {
+  samples_.Clear();
+}
+inline ::sentencepiece::SelfTestData_Sample* SelfTestData::mutable_samples(int index) {
+  // @@protoc_insertion_point(field_mutable:sentencepiece.SelfTestData.samples)
+  return samples_.Mutable(index);
+}
+inline ::google::protobuf::RepeatedPtrField< ::sentencepiece::SelfTestData_Sample >*
+SelfTestData::mutable_samples() {
+  // @@protoc_insertion_point(field_mutable_list:sentencepiece.SelfTestData.samples)
+  return &samples_;
+}
+inline const ::sentencepiece::SelfTestData_Sample& SelfTestData::samples(int index) const {
+  // @@protoc_insertion_point(field_get:sentencepiece.SelfTestData.samples)
+  return samples_.Get(index);
+}
+inline ::sentencepiece::SelfTestData_Sample* SelfTestData::add_samples() {
+  // @@protoc_insertion_point(field_add:sentencepiece.SelfTestData.samples)
+  return samples_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::sentencepiece::SelfTestData_Sample >&
+SelfTestData::samples() const {
+  // @@protoc_insertion_point(field_list:sentencepiece.SelfTestData.samples)
+  return samples_;
+}
+
+// -------------------------------------------------------------------
+
+// ModelProto_SentencePiece
+
+// optional string piece = 1;
+inline bool ModelProto_SentencePiece::has_piece() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ModelProto_SentencePiece::set_has_piece() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ModelProto_SentencePiece::clear_has_piece() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ModelProto_SentencePiece::clear_piece() {
+  piece_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_piece();
+}
+inline const ::std::string& ModelProto_SentencePiece::piece() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.piece)
+  return piece_.GetNoArena();
+}
+inline void ModelProto_SentencePiece::set_piece(const ::std::string& value) {
+  set_has_piece();
+  piece_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:sentencepiece.ModelProto.SentencePiece.piece)
+}
+#if LANG_CXX11
+inline void ModelProto_SentencePiece::set_piece(::std::string&& value) {
+  set_has_piece();
+  piece_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:sentencepiece.ModelProto.SentencePiece.piece)
+}
+#endif
+inline void ModelProto_SentencePiece::set_piece(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_piece();
+  piece_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:sentencepiece.ModelProto.SentencePiece.piece)
+}
+inline void ModelProto_SentencePiece::set_piece(const char* value, size_t size) {
+  set_has_piece();
+  piece_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:sentencepiece.ModelProto.SentencePiece.piece)
+}
+inline ::std::string* ModelProto_SentencePiece::mutable_piece() {
+  set_has_piece();
+  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.SentencePiece.piece)
+  return piece_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* ModelProto_SentencePiece::release_piece() {
+  // @@protoc_insertion_point(field_release:sentencepiece.ModelProto.SentencePiece.piece)
+  if (!has_piece()) {
+    return NULL;
+  }
+  clear_has_piece();
+  return piece_.ReleaseNonDefaultNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void ModelProto_SentencePiece::set_allocated_piece(::std::string* piece) {
+  if (piece != NULL) {
+    set_has_piece();
+  } else {
+    clear_has_piece();
+  }
+  piece_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), piece);
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.ModelProto.SentencePiece.piece)
+}
+
+// optional float score = 2;
+inline bool ModelProto_SentencePiece::has_score() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ModelProto_SentencePiece::set_has_score() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ModelProto_SentencePiece::clear_has_score() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ModelProto_SentencePiece::clear_score() {
+  score_ = 0;
+  clear_has_score();
+}
+inline float ModelProto_SentencePiece::score() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.score)
+  return score_;
+}
+inline void ModelProto_SentencePiece::set_score(float value) {
+  set_has_score();
+  score_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.ModelProto.SentencePiece.score)
+}
+
+// optional .sentencepiece.ModelProto.SentencePiece.Type type = 3 [default = NORMAL];
+inline bool ModelProto_SentencePiece::has_type() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ModelProto_SentencePiece::set_has_type() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ModelProto_SentencePiece::clear_has_type() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ModelProto_SentencePiece::clear_type() {
+  type_ = 1;
+  clear_has_type();
+}
+inline ::sentencepiece::ModelProto_SentencePiece_Type ModelProto_SentencePiece::type() const {
+  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.SentencePiece.type)
+  return static_cast< ::sentencepiece::ModelProto_SentencePiece_Type >(type_);
+}
+inline void ModelProto_SentencePiece::set_type(::sentencepiece::ModelProto_SentencePiece_Type value) {
+  assert(::sentencepiece::ModelProto_SentencePiece_Type_IsValid(value));
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:sentencepiece.ModelProto.SentencePiece.type)
+}
+
+// -------------------------------------------------------------------
+
+// ModelProto
+
+// repeated .sentencepiece.ModelProto.SentencePiece pieces = 1;
+inline int ModelProto::pieces_size() const {
+  return pieces_.size();
+}
+inline void ModelProto::clear_pieces() {
+  pieces_.Clear();
+}
+inline ::sentencepiece::ModelProto_SentencePiece* ModelProto::mutable_pieces(int index) {
+  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.pieces)
+  return pieces_.Mutable(index);
+}
+inline ::google::protobuf::RepeatedPtrField< ::sentencepiece::ModelProto_SentencePiece >*
+ModelProto::mutable_pieces() {
+  // @@protoc_insertion_point(field_mutable_list:sentencepiece.ModelProto.pieces)
+  return &pieces_;
+}
+inline const ::sentencepiece::ModelProto_SentencePiece& ModelProto::pieces(int index) const {
+  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.pieces)
+  return pieces_.Get(index);
+}
+inline ::sentencepiece::ModelProto_SentencePiece* ModelProto::add_pieces() {
+  // @@protoc_insertion_point(field_add:sentencepiece.ModelProto.pieces)
+  return pieces_.Add();
+}
+inline const ::google::protobuf::RepeatedPtrField< ::sentencepiece::ModelProto_SentencePiece >&
+ModelProto::pieces() const {
+  // @@protoc_insertion_point(field_list:sentencepiece.ModelProto.pieces)
+  return pieces_;
+}
+
+// optional .sentencepiece.TrainerSpec trainer_spec = 2;
+inline bool ModelProto::has_trainer_spec() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ModelProto::set_has_trainer_spec() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ModelProto::clear_has_trainer_spec() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ModelProto::clear_trainer_spec() {
+  if (trainer_spec_ != NULL) trainer_spec_->Clear();
+  clear_has_trainer_spec();
+}
+inline const ::sentencepiece::TrainerSpec& ModelProto::_internal_trainer_spec() const {
+  return *trainer_spec_;
+}
+inline const ::sentencepiece::TrainerSpec& ModelProto::trainer_spec() const {
+  const ::sentencepiece::TrainerSpec* p = trainer_spec_;
+  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.trainer_spec)
+  return p != NULL ? *p : *reinterpret_cast<const ::sentencepiece::TrainerSpec*>(
+      &::sentencepiece::_TrainerSpec_default_instance_);
+}
+inline ::sentencepiece::TrainerSpec* ModelProto::release_trainer_spec() {
+  // @@protoc_insertion_point(field_release:sentencepiece.ModelProto.trainer_spec)
+  clear_has_trainer_spec();
+  ::sentencepiece::TrainerSpec* temp = trainer_spec_;
+  trainer_spec_ = NULL;
+  return temp;
+}
+inline ::sentencepiece::TrainerSpec* ModelProto::mutable_trainer_spec() {
+  set_has_trainer_spec();
+  if (trainer_spec_ == NULL) {
+    auto* p = CreateMaybeMessage<::sentencepiece::TrainerSpec>(GetArenaNoVirtual());
+    trainer_spec_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.trainer_spec)
+  return trainer_spec_;
+}
+inline void ModelProto::set_allocated_trainer_spec(::sentencepiece::TrainerSpec* trainer_spec) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete trainer_spec_;
+  }
+  if (trainer_spec) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      trainer_spec = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, trainer_spec, submessage_arena);
+    }
+    set_has_trainer_spec();
+  } else {
+    clear_has_trainer_spec();
+  }
+  trainer_spec_ = trainer_spec;
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.ModelProto.trainer_spec)
+}
+
+// optional .sentencepiece.NormalizerSpec normalizer_spec = 3;
+inline bool ModelProto::has_normalizer_spec() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ModelProto::set_has_normalizer_spec() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ModelProto::clear_has_normalizer_spec() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ModelProto::clear_normalizer_spec() {
+  if (normalizer_spec_ != NULL) normalizer_spec_->Clear();
+  clear_has_normalizer_spec();
+}
+inline const ::sentencepiece::NormalizerSpec& ModelProto::_internal_normalizer_spec() const {
+  return *normalizer_spec_;
+}
+inline const ::sentencepiece::NormalizerSpec& ModelProto::normalizer_spec() const {
+  const ::sentencepiece::NormalizerSpec* p = normalizer_spec_;
+  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.normalizer_spec)
+  return p != NULL ? *p : *reinterpret_cast<const ::sentencepiece::NormalizerSpec*>(
+      &::sentencepiece::_NormalizerSpec_default_instance_);
+}
+inline ::sentencepiece::NormalizerSpec* ModelProto::release_normalizer_spec() {
+  // @@protoc_insertion_point(field_release:sentencepiece.ModelProto.normalizer_spec)
+  clear_has_normalizer_spec();
+  ::sentencepiece::NormalizerSpec* temp = normalizer_spec_;
+  normalizer_spec_ = NULL;
+  return temp;
+}
+inline ::sentencepiece::NormalizerSpec* ModelProto::mutable_normalizer_spec() {
+  set_has_normalizer_spec();
+  if (normalizer_spec_ == NULL) {
+    auto* p = CreateMaybeMessage<::sentencepiece::NormalizerSpec>(GetArenaNoVirtual());
+    normalizer_spec_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.normalizer_spec)
+  return normalizer_spec_;
+}
+inline void ModelProto::set_allocated_normalizer_spec(::sentencepiece::NormalizerSpec* normalizer_spec) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete normalizer_spec_;
+  }
+  if (normalizer_spec) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      normalizer_spec = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, normalizer_spec, submessage_arena);
+    }
+    set_has_normalizer_spec();
+  } else {
+    clear_has_normalizer_spec();
+  }
+  normalizer_spec_ = normalizer_spec;
+  // @@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 {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void ModelProto::set_has_self_test_data() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void ModelProto::clear_has_self_test_data() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void ModelProto::clear_self_test_data() {
+  if (self_test_data_ != NULL) self_test_data_->Clear();
+  clear_has_self_test_data();
+}
+inline const ::sentencepiece::SelfTestData& ModelProto::_internal_self_test_data() const {
+  return *self_test_data_;
+}
+inline const ::sentencepiece::SelfTestData& ModelProto::self_test_data() const {
+  const ::sentencepiece::SelfTestData* p = self_test_data_;
+  // @@protoc_insertion_point(field_get:sentencepiece.ModelProto.self_test_data)
+  return p != NULL ? *p : *reinterpret_cast<const ::sentencepiece::SelfTestData*>(
+      &::sentencepiece::_SelfTestData_default_instance_);
+}
+inline ::sentencepiece::SelfTestData* ModelProto::release_self_test_data() {
+  // @@protoc_insertion_point(field_release:sentencepiece.ModelProto.self_test_data)
+  clear_has_self_test_data();
+  ::sentencepiece::SelfTestData* temp = self_test_data_;
+  self_test_data_ = NULL;
+  return temp;
+}
+inline ::sentencepiece::SelfTestData* ModelProto::mutable_self_test_data() {
+  set_has_self_test_data();
+  if (self_test_data_ == NULL) {
+    auto* p = CreateMaybeMessage<::sentencepiece::SelfTestData>(GetArenaNoVirtual());
+    self_test_data_ = p;
+  }
+  // @@protoc_insertion_point(field_mutable:sentencepiece.ModelProto.self_test_data)
+  return self_test_data_;
+}
+inline void ModelProto::set_allocated_self_test_data(::sentencepiece::SelfTestData* self_test_data) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete self_test_data_;
+  }
+  if (self_test_data) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      self_test_data = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, self_test_data, submessage_arena);
+    }
+    set_has_self_test_data();
+  } else {
+    clear_has_self_test_data();
+  }
+  self_test_data_ = self_test_data;
+  // @@protoc_insertion_point(field_set_allocated:sentencepiece.ModelProto.self_test_data)
+}
+
+#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 is_proto_enum< ::sentencepiece::ModelProto_SentencePiece_Type> : ::std::true_type {};
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_INCLUDED_sentencepiece_5fmodel_2eproto