text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  // source: google/protobuf/unittest_no_field_presence.proto
  
  #ifndef GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2funittest_5fno_5ffield_5fpresence_2eproto
  #define GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2funittest_5fno_5ffield_5fpresence_2eproto
  
  #include <limits>
  #include <string>
  
  #include <google/protobuf/port_def.inc>
  #if PROTOBUF_VERSION < 3017000
  #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 3017003 < 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/port_undef.inc>
  #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/metadata_lite.h>
  #include <google/protobuf/generated_message_reflection.h>
  #include <google/protobuf/message.h>
  #include <google/protobuf/repeated_field.h>  // IWYU pragma: export
  #include <google/protobuf/extension_set.h>  // IWYU pragma: export
  #include <google/protobuf/generated_enum_reflection.h>
  #include <google/protobuf/unknown_field_set.h>
  #include "google/protobuf/unittest.pb.h"
  // @@protoc_insertion_point(includes)
  #include <google/protobuf/port_def.inc>
  #define PROTOBUF_INTERNAL_EXPORT_google_2fprotobuf_2funittest_5fno_5ffield_5fpresence_2eproto
  PROTOBUF_NAMESPACE_OPEN
  namespace internal {
  class AnyMetadata;
  }  // namespace internal
  PROTOBUF_NAMESPACE_CLOSE
  
  // Internal implementation detail -- do not use these members.
  struct TableStruct_google_2fprotobuf_2funittest_5fno_5ffield_5fpresence_2eproto {
    static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
      PROTOBUF_SECTION_VARIABLE(protodesc_cold);
    static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
    static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
    static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
  };
  extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_google_2fprotobuf_2funittest_5fno_5ffield_5fpresence_2eproto;
  namespace proto2_nofieldpresence_unittest {
  class ForeignMessage;
  struct ForeignMessageDefaultTypeInternal;
  extern ForeignMessageDefaultTypeInternal _ForeignMessage_default_instance_;
  class TestAllTypes;
  struct TestAllTypesDefaultTypeInternal;
  extern TestAllTypesDefaultTypeInternal _TestAllTypes_default_instance_;
  class TestAllTypes_NestedMessage;
  struct TestAllTypes_NestedMessageDefaultTypeInternal;
  extern TestAllTypes_NestedMessageDefaultTypeInternal _TestAllTypes_NestedMessage_default_instance_;
  class TestProto2Required;
  struct TestProto2RequiredDefaultTypeInternal;
  extern TestProto2RequiredDefaultTypeInternal _TestProto2Required_default_instance_;
  }  // namespace proto2_nofieldpresence_unittest
  PROTOBUF_NAMESPACE_OPEN
  template<> ::proto2_nofieldpresence_unittest::ForeignMessage* Arena::CreateMaybeMessage<::proto2_nofieldpresence_unittest::ForeignMessage>(Arena*);
  template<> ::proto2_nofieldpresence_unittest::TestAllTypes* Arena::CreateMaybeMessage<::proto2_nofieldpresence_unittest::TestAllTypes>(Arena*);
  template<> ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* Arena::CreateMaybeMessage<::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage>(Arena*);
  template<> ::proto2_nofieldpresence_unittest::TestProto2Required* Arena::CreateMaybeMessage<::proto2_nofieldpresence_unittest::TestProto2Required>(Arena*);
  PROTOBUF_NAMESPACE_CLOSE
  namespace proto2_nofieldpresence_unittest {
  
  enum TestAllTypes_NestedEnum : int {
    TestAllTypes_NestedEnum_FOO = 0,
    TestAllTypes_NestedEnum_BAR = 1,
    TestAllTypes_NestedEnum_BAZ = 2,
    TestAllTypes_NestedEnum_TestAllTypes_NestedEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    TestAllTypes_NestedEnum_TestAllTypes_NestedEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool TestAllTypes_NestedEnum_IsValid(int value);
  constexpr TestAllTypes_NestedEnum TestAllTypes_NestedEnum_NestedEnum_MIN = TestAllTypes_NestedEnum_FOO;
  constexpr TestAllTypes_NestedEnum TestAllTypes_NestedEnum_NestedEnum_MAX = TestAllTypes_NestedEnum_BAZ;
  constexpr int TestAllTypes_NestedEnum_NestedEnum_ARRAYSIZE = TestAllTypes_NestedEnum_NestedEnum_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* TestAllTypes_NestedEnum_descriptor();
  template<typename T>
  inline const std::string& TestAllTypes_NestedEnum_Name(T enum_t_value) {
    static_assert(::std::is_same<T, TestAllTypes_NestedEnum>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function TestAllTypes_NestedEnum_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      TestAllTypes_NestedEnum_descriptor(), enum_t_value);
  }
  inline bool TestAllTypes_NestedEnum_Parse(
      ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, TestAllTypes_NestedEnum* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<TestAllTypes_NestedEnum>(
      TestAllTypes_NestedEnum_descriptor(), name, value);
  }
  enum ForeignEnum : int {
    FOREIGN_FOO = 0,
    FOREIGN_BAR = 1,
    FOREIGN_BAZ = 2,
    ForeignEnum_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
    ForeignEnum_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
  };
  bool ForeignEnum_IsValid(int value);
  constexpr ForeignEnum ForeignEnum_MIN = FOREIGN_FOO;
  constexpr ForeignEnum ForeignEnum_MAX = FOREIGN_BAZ;
  constexpr int ForeignEnum_ARRAYSIZE = ForeignEnum_MAX + 1;
  
  const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ForeignEnum_descriptor();
  template<typename T>
  inline const std::string& ForeignEnum_Name(T enum_t_value) {
    static_assert(::std::is_same<T, ForeignEnum>::value ||
      ::std::is_integral<T>::value,
      "Incorrect type passed to function ForeignEnum_Name.");
    return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
      ForeignEnum_descriptor(), enum_t_value);
  }
  inline bool ForeignEnum_Parse(
      ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ForeignEnum* value) {
    return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ForeignEnum>(
      ForeignEnum_descriptor(), name, value);
  }
  // ===================================================================
  
  class TestAllTypes_NestedMessage final :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage) */ {
   public:
    inline TestAllTypes_NestedMessage() : TestAllTypes_NestedMessage(nullptr) {}
    ~TestAllTypes_NestedMessage() override;
    explicit constexpr TestAllTypes_NestedMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  
    TestAllTypes_NestedMessage(const TestAllTypes_NestedMessage& from);
    TestAllTypes_NestedMessage(TestAllTypes_NestedMessage&& from) noexcept
      : TestAllTypes_NestedMessage() {
      *this = ::std::move(from);
    }
  
    inline TestAllTypes_NestedMessage& operator=(const TestAllTypes_NestedMessage& from) {
      CopyFrom(from);
      return *this;
    }
    inline TestAllTypes_NestedMessage& operator=(TestAllTypes_NestedMessage&& from) noexcept {
      if (this == &from) return *this;
      if (GetOwningArena() == from.GetOwningArena()
    #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
          && GetOwningArena() != nullptr
    #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
      ) {
        InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return default_instance().GetMetadata().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return default_instance().GetMetadata().reflection;
    }
    static const TestAllTypes_NestedMessage& default_instance() {
      return *internal_default_instance();
    }
    static inline const TestAllTypes_NestedMessage* internal_default_instance() {
      return reinterpret_cast<const TestAllTypes_NestedMessage*>(
                 &_TestAllTypes_NestedMessage_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      0;
  
    friend void swap(TestAllTypes_NestedMessage& a, TestAllTypes_NestedMessage& b) {
      a.Swap(&b);
    }
    inline void Swap(TestAllTypes_NestedMessage* other) {
      if (other == this) return;
    #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
      if (GetOwningArena() != nullptr &&
          GetOwningArena() == other->GetOwningArena()) {
     #else  // PROTOBUF_FORCE_COPY_IN_SWAP
      if (GetOwningArena() == other->GetOwningArena()) {
    #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(TestAllTypes_NestedMessage* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline TestAllTypes_NestedMessage* New() const final {
      return new TestAllTypes_NestedMessage();
    }
  
    TestAllTypes_NestedMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<TestAllTypes_NestedMessage>(arena);
    }
    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
    void CopyFrom(const TestAllTypes_NestedMessage& from);
    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
    void MergeFrom(const TestAllTypes_NestedMessage& from);
    private:
    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
    public:
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
        ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(TestAllTypes_NestedMessage* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage";
    }
    protected:
    explicit TestAllTypes_NestedMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned = false);
    private:
    static void ArenaDtor(void* object);
    inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    public:
  
    static const ClassData _class_data_;
    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kBbFieldNumber = 1,
    };
    // int32 bb = 1;
    void clear_bb();
    ::PROTOBUF_NAMESPACE_ID::int32 bb() const;
    void set_bb(::PROTOBUF_NAMESPACE_ID::int32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_bb() const;
    void _internal_set_bb(::PROTOBUF_NAMESPACE_ID::int32 value);
    public:
  
    // @@protoc_insertion_point(class_scope:proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::int32 bb_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_google_2fprotobuf_2funittest_5fno_5ffield_5fpresence_2eproto;
  };
  // -------------------------------------------------------------------
  
  class TestAllTypes final :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto2_nofieldpresence_unittest.TestAllTypes) */ {
   public:
    inline TestAllTypes() : TestAllTypes(nullptr) {}
    ~TestAllTypes() override;
    explicit constexpr TestAllTypes(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  
    TestAllTypes(const TestAllTypes& from);
    TestAllTypes(TestAllTypes&& from) noexcept
      : TestAllTypes() {
      *this = ::std::move(from);
    }
  
    inline TestAllTypes& operator=(const TestAllTypes& from) {
      CopyFrom(from);
      return *this;
    }
    inline TestAllTypes& operator=(TestAllTypes&& from) noexcept {
      if (this == &from) return *this;
      if (GetOwningArena() == from.GetOwningArena()
    #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
          && GetOwningArena() != nullptr
    #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
      ) {
        InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return default_instance().GetMetadata().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return default_instance().GetMetadata().reflection;
    }
    static const TestAllTypes& default_instance() {
      return *internal_default_instance();
    }
    enum OneofFieldCase {
      kOneofUint32 = 111,
      kOneofNestedMessage = 112,
      kOneofString = 113,
      kOneofEnum = 114,
      ONEOF_FIELD_NOT_SET = 0,
    };
  
    static inline const TestAllTypes* internal_default_instance() {
      return reinterpret_cast<const TestAllTypes*>(
                 &_TestAllTypes_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      1;
  
    friend void swap(TestAllTypes& a, TestAllTypes& b) {
      a.Swap(&b);
    }
    inline void Swap(TestAllTypes* other) {
      if (other == this) return;
    #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
      if (GetOwningArena() != nullptr &&
          GetOwningArena() == other->GetOwningArena()) {
     #else  // PROTOBUF_FORCE_COPY_IN_SWAP
      if (GetOwningArena() == other->GetOwningArena()) {
    #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(TestAllTypes* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline TestAllTypes* New() const final {
      return new TestAllTypes();
    }
  
    TestAllTypes* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<TestAllTypes>(arena);
    }
    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
    void CopyFrom(const TestAllTypes& from);
    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
    void MergeFrom(const TestAllTypes& from);
    private:
    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
    public:
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
        ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(TestAllTypes* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "proto2_nofieldpresence_unittest.TestAllTypes";
    }
    protected:
    explicit TestAllTypes(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned = false);
    private:
    static void ArenaDtor(void* object);
    inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    public:
  
    static const ClassData _class_data_;
    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    typedef TestAllTypes_NestedMessage NestedMessage;
  
    typedef TestAllTypes_NestedEnum NestedEnum;
    static constexpr NestedEnum FOO =
      TestAllTypes_NestedEnum_FOO;
    static constexpr NestedEnum BAR =
      TestAllTypes_NestedEnum_BAR;
    static constexpr NestedEnum BAZ =
      TestAllTypes_NestedEnum_BAZ;
    static inline bool NestedEnum_IsValid(int value) {
      return TestAllTypes_NestedEnum_IsValid(value);
    }
    static constexpr NestedEnum NestedEnum_MIN =
      TestAllTypes_NestedEnum_NestedEnum_MIN;
    static constexpr NestedEnum NestedEnum_MAX =
      TestAllTypes_NestedEnum_NestedEnum_MAX;
    static constexpr int NestedEnum_ARRAYSIZE =
      TestAllTypes_NestedEnum_NestedEnum_ARRAYSIZE;
    static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
    NestedEnum_descriptor() {
      return TestAllTypes_NestedEnum_descriptor();
    }
    template<typename T>
    static inline const std::string& NestedEnum_Name(T enum_t_value) {
      static_assert(::std::is_same<T, NestedEnum>::value ||
        ::std::is_integral<T>::value,
        "Incorrect type passed to function NestedEnum_Name.");
      return TestAllTypes_NestedEnum_Name(enum_t_value);
    }
    static inline bool NestedEnum_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
        NestedEnum* value) {
      return TestAllTypes_NestedEnum_Parse(name, value);
    }
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kRepeatedInt32FieldNumber = 31,
      kRepeatedInt64FieldNumber = 32,
      kRepeatedUint32FieldNumber = 33,
      kRepeatedUint64FieldNumber = 34,
      kRepeatedSint32FieldNumber = 35,
      kRepeatedSint64FieldNumber = 36,
      kRepeatedFixed32FieldNumber = 37,
      kRepeatedFixed64FieldNumber = 38,
      kRepeatedSfixed32FieldNumber = 39,
      kRepeatedSfixed64FieldNumber = 40,
      kRepeatedFloatFieldNumber = 41,
      kRepeatedDoubleFieldNumber = 42,
      kRepeatedBoolFieldNumber = 43,
      kRepeatedStringFieldNumber = 44,
      kRepeatedBytesFieldNumber = 45,
      kRepeatedNestedMessageFieldNumber = 48,
      kRepeatedForeignMessageFieldNumber = 49,
      kRepeatedProto2MessageFieldNumber = 50,
      kRepeatedNestedEnumFieldNumber = 51,
      kRepeatedForeignEnumFieldNumber = 52,
      kRepeatedStringPieceFieldNumber = 54,
      kRepeatedCordFieldNumber = 55,
      kRepeatedLazyMessageFieldNumber = 57,
      kOptionalStringFieldNumber = 14,
      kOptionalBytesFieldNumber = 15,
      kOptionalStringPieceFieldNumber = 24,
      kOptionalCordFieldNumber = 25,
      kOptionalNestedMessageFieldNumber = 18,
      kOptionalForeignMessageFieldNumber = 19,
      kOptionalProto2MessageFieldNumber = 20,
      kOptionalLazyMessageFieldNumber = 30,
      kOptionalInt64FieldNumber = 2,
      kOptionalInt32FieldNumber = 1,
      kOptionalUint32FieldNumber = 3,
      kOptionalUint64FieldNumber = 4,
      kOptionalSint64FieldNumber = 6,
      kOptionalSint32FieldNumber = 5,
      kOptionalFixed32FieldNumber = 7,
      kOptionalFixed64FieldNumber = 8,
      kOptionalSfixed64FieldNumber = 10,
      kOptionalSfixed32FieldNumber = 9,
      kOptionalFloatFieldNumber = 11,
      kOptionalDoubleFieldNumber = 12,
      kOptionalBoolFieldNumber = 13,
      kOptionalNestedEnumFieldNumber = 21,
      kOptionalForeignEnumFieldNumber = 22,
      kOneofUint32FieldNumber = 111,
      kOneofNestedMessageFieldNumber = 112,
      kOneofStringFieldNumber = 113,
      kOneofEnumFieldNumber = 114,
    };
    // repeated int32 repeated_int32 = 31;
    int repeated_int32_size() const;
    private:
    int _internal_repeated_int32_size() const;
    public:
    void clear_repeated_int32();
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_repeated_int32(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
        _internal_repeated_int32() const;
    void _internal_add_repeated_int32(::PROTOBUF_NAMESPACE_ID::int32 value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
        _internal_mutable_repeated_int32();
    public:
    ::PROTOBUF_NAMESPACE_ID::int32 repeated_int32(int index) const;
    void set_repeated_int32(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
    void add_repeated_int32(::PROTOBUF_NAMESPACE_ID::int32 value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
        repeated_int32() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
        mutable_repeated_int32();
  
    // repeated int64 repeated_int64 = 32;
    int repeated_int64_size() const;
    private:
    int _internal_repeated_int64_size() const;
    public:
    void clear_repeated_int64();
    private:
    ::PROTOBUF_NAMESPACE_ID::int64 _internal_repeated_int64(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
        _internal_repeated_int64() const;
    void _internal_add_repeated_int64(::PROTOBUF_NAMESPACE_ID::int64 value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
        _internal_mutable_repeated_int64();
    public:
    ::PROTOBUF_NAMESPACE_ID::int64 repeated_int64(int index) const;
    void set_repeated_int64(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
    void add_repeated_int64(::PROTOBUF_NAMESPACE_ID::int64 value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
        repeated_int64() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
        mutable_repeated_int64();
  
    // repeated uint32 repeated_uint32 = 33;
    int repeated_uint32_size() const;
    private:
    int _internal_repeated_uint32_size() const;
    public:
    void clear_repeated_uint32();
    private:
    ::PROTOBUF_NAMESPACE_ID::uint32 _internal_repeated_uint32(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
        _internal_repeated_uint32() const;
    void _internal_add_repeated_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
        _internal_mutable_repeated_uint32();
    public:
    ::PROTOBUF_NAMESPACE_ID::uint32 repeated_uint32(int index) const;
    void set_repeated_uint32(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value);
    void add_repeated_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
        repeated_uint32() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
        mutable_repeated_uint32();
  
    // repeated uint64 repeated_uint64 = 34;
    int repeated_uint64_size() const;
    private:
    int _internal_repeated_uint64_size() const;
    public:
    void clear_repeated_uint64();
    private:
    ::PROTOBUF_NAMESPACE_ID::uint64 _internal_repeated_uint64(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
        _internal_repeated_uint64() const;
    void _internal_add_repeated_uint64(::PROTOBUF_NAMESPACE_ID::uint64 value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
        _internal_mutable_repeated_uint64();
    public:
    ::PROTOBUF_NAMESPACE_ID::uint64 repeated_uint64(int index) const;
    void set_repeated_uint64(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value);
    void add_repeated_uint64(::PROTOBUF_NAMESPACE_ID::uint64 value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
        repeated_uint64() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
        mutable_repeated_uint64();
  
    // repeated sint32 repeated_sint32 = 35;
    int repeated_sint32_size() const;
    private:
    int _internal_repeated_sint32_size() const;
    public:
    void clear_repeated_sint32();
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_repeated_sint32(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
        _internal_repeated_sint32() const;
    void _internal_add_repeated_sint32(::PROTOBUF_NAMESPACE_ID::int32 value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
        _internal_mutable_repeated_sint32();
    public:
    ::PROTOBUF_NAMESPACE_ID::int32 repeated_sint32(int index) const;
    void set_repeated_sint32(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
    void add_repeated_sint32(::PROTOBUF_NAMESPACE_ID::int32 value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
        repeated_sint32() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
        mutable_repeated_sint32();
  
    // repeated sint64 repeated_sint64 = 36;
    int repeated_sint64_size() const;
    private:
    int _internal_repeated_sint64_size() const;
    public:
    void clear_repeated_sint64();
    private:
    ::PROTOBUF_NAMESPACE_ID::int64 _internal_repeated_sint64(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
        _internal_repeated_sint64() const;
    void _internal_add_repeated_sint64(::PROTOBUF_NAMESPACE_ID::int64 value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
        _internal_mutable_repeated_sint64();
    public:
    ::PROTOBUF_NAMESPACE_ID::int64 repeated_sint64(int index) const;
    void set_repeated_sint64(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
    void add_repeated_sint64(::PROTOBUF_NAMESPACE_ID::int64 value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
        repeated_sint64() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
        mutable_repeated_sint64();
  
    // repeated fixed32 repeated_fixed32 = 37;
    int repeated_fixed32_size() const;
    private:
    int _internal_repeated_fixed32_size() const;
    public:
    void clear_repeated_fixed32();
    private:
    ::PROTOBUF_NAMESPACE_ID::uint32 _internal_repeated_fixed32(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
        _internal_repeated_fixed32() const;
    void _internal_add_repeated_fixed32(::PROTOBUF_NAMESPACE_ID::uint32 value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
        _internal_mutable_repeated_fixed32();
    public:
    ::PROTOBUF_NAMESPACE_ID::uint32 repeated_fixed32(int index) const;
    void set_repeated_fixed32(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value);
    void add_repeated_fixed32(::PROTOBUF_NAMESPACE_ID::uint32 value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
        repeated_fixed32() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
        mutable_repeated_fixed32();
  
    // repeated fixed64 repeated_fixed64 = 38;
    int repeated_fixed64_size() const;
    private:
    int _internal_repeated_fixed64_size() const;
    public:
    void clear_repeated_fixed64();
    private:
    ::PROTOBUF_NAMESPACE_ID::uint64 _internal_repeated_fixed64(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
        _internal_repeated_fixed64() const;
    void _internal_add_repeated_fixed64(::PROTOBUF_NAMESPACE_ID::uint64 value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
        _internal_mutable_repeated_fixed64();
    public:
    ::PROTOBUF_NAMESPACE_ID::uint64 repeated_fixed64(int index) const;
    void set_repeated_fixed64(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value);
    void add_repeated_fixed64(::PROTOBUF_NAMESPACE_ID::uint64 value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
        repeated_fixed64() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
        mutable_repeated_fixed64();
  
    // repeated sfixed32 repeated_sfixed32 = 39;
    int repeated_sfixed32_size() const;
    private:
    int _internal_repeated_sfixed32_size() const;
    public:
    void clear_repeated_sfixed32();
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_repeated_sfixed32(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
        _internal_repeated_sfixed32() const;
    void _internal_add_repeated_sfixed32(::PROTOBUF_NAMESPACE_ID::int32 value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
        _internal_mutable_repeated_sfixed32();
    public:
    ::PROTOBUF_NAMESPACE_ID::int32 repeated_sfixed32(int index) const;
    void set_repeated_sfixed32(int index, ::PROTOBUF_NAMESPACE_ID::int32 value);
    void add_repeated_sfixed32(::PROTOBUF_NAMESPACE_ID::int32 value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
        repeated_sfixed32() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
        mutable_repeated_sfixed32();
  
    // repeated sfixed64 repeated_sfixed64 = 40;
    int repeated_sfixed64_size() const;
    private:
    int _internal_repeated_sfixed64_size() const;
    public:
    void clear_repeated_sfixed64();
    private:
    ::PROTOBUF_NAMESPACE_ID::int64 _internal_repeated_sfixed64(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
        _internal_repeated_sfixed64() const;
    void _internal_add_repeated_sfixed64(::PROTOBUF_NAMESPACE_ID::int64 value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
        _internal_mutable_repeated_sfixed64();
    public:
    ::PROTOBUF_NAMESPACE_ID::int64 repeated_sfixed64(int index) const;
    void set_repeated_sfixed64(int index, ::PROTOBUF_NAMESPACE_ID::int64 value);
    void add_repeated_sfixed64(::PROTOBUF_NAMESPACE_ID::int64 value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
        repeated_sfixed64() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
        mutable_repeated_sfixed64();
  
    // repeated float repeated_float = 41;
    int repeated_float_size() const;
    private:
    int _internal_repeated_float_size() const;
    public:
    void clear_repeated_float();
    private:
    float _internal_repeated_float(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
        _internal_repeated_float() const;
    void _internal_add_repeated_float(float value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
        _internal_mutable_repeated_float();
    public:
    float repeated_float(int index) const;
    void set_repeated_float(int index, float value);
    void add_repeated_float(float value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
        repeated_float() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
        mutable_repeated_float();
  
    // repeated double repeated_double = 42;
    int repeated_double_size() const;
    private:
    int _internal_repeated_double_size() const;
    public:
    void clear_repeated_double();
    private:
    double _internal_repeated_double(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
        _internal_repeated_double() const;
    void _internal_add_repeated_double(double value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
        _internal_mutable_repeated_double();
    public:
    double repeated_double(int index) const;
    void set_repeated_double(int index, double value);
    void add_repeated_double(double value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
        repeated_double() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
        mutable_repeated_double();
  
    // repeated bool repeated_bool = 43;
    int repeated_bool_size() const;
    private:
    int _internal_repeated_bool_size() const;
    public:
    void clear_repeated_bool();
    private:
    bool _internal_repeated_bool(int index) const;
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
        _internal_repeated_bool() const;
    void _internal_add_repeated_bool(bool value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
        _internal_mutable_repeated_bool();
    public:
    bool repeated_bool(int index) const;
    void set_repeated_bool(int index, bool value);
    void add_repeated_bool(bool value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
        repeated_bool() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
        mutable_repeated_bool();
  
    // repeated string repeated_string = 44;
    int repeated_string_size() const;
    private:
    int _internal_repeated_string_size() const;
    public:
    void clear_repeated_string();
    const std::string& repeated_string(int index) const;
    std::string* mutable_repeated_string(int index);
    void set_repeated_string(int index, const std::string& value);
    void set_repeated_string(int index, std::string&& value);
    void set_repeated_string(int index, const char* value);
    void set_repeated_string(int index, const char* value, size_t size);
    std::string* add_repeated_string();
    void add_repeated_string(const std::string& value);
    void add_repeated_string(std::string&& value);
    void add_repeated_string(const char* value);
    void add_repeated_string(const char* value, size_t size);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& repeated_string() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_repeated_string();
    private:
    const std::string& _internal_repeated_string(int index) const;
    std::string* _internal_add_repeated_string();
    public:
  
    // repeated bytes repeated_bytes = 45;
    int repeated_bytes_size() const;
    private:
    int _internal_repeated_bytes_size() const;
    public:
    void clear_repeated_bytes();
    const std::string& repeated_bytes(int index) const;
    std::string* mutable_repeated_bytes(int index);
    void set_repeated_bytes(int index, const std::string& value);
    void set_repeated_bytes(int index, std::string&& value);
    void set_repeated_bytes(int index, const char* value);
    void set_repeated_bytes(int index, const void* value, size_t size);
    std::string* add_repeated_bytes();
    void add_repeated_bytes(const std::string& value);
    void add_repeated_bytes(std::string&& value);
    void add_repeated_bytes(const char* value);
    void add_repeated_bytes(const void* value, size_t size);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& repeated_bytes() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_repeated_bytes();
    private:
    const std::string& _internal_repeated_bytes(int index) const;
    std::string* _internal_add_repeated_bytes();
    public:
  
    // repeated .proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage repeated_nested_message = 48;
    int repeated_nested_message_size() const;
    private:
    int _internal_repeated_nested_message_size() const;
    public:
    void clear_repeated_nested_message();
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* mutable_repeated_nested_message(int index);
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage >*
        mutable_repeated_nested_message();
    private:
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& _internal_repeated_nested_message(int index) const;
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* _internal_add_repeated_nested_message();
    public:
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& repeated_nested_message(int index) const;
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* add_repeated_nested_message();
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage >&
        repeated_nested_message() const;
  
    // repeated .proto2_nofieldpresence_unittest.ForeignMessage repeated_foreign_message = 49;
    int repeated_foreign_message_size() const;
    private:
    int _internal_repeated_foreign_message_size() const;
    public:
    void clear_repeated_foreign_message();
    ::proto2_nofieldpresence_unittest::ForeignMessage* mutable_repeated_foreign_message(int index);
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::ForeignMessage >*
        mutable_repeated_foreign_message();
    private:
    const ::proto2_nofieldpresence_unittest::ForeignMessage& _internal_repeated_foreign_message(int index) const;
    ::proto2_nofieldpresence_unittest::ForeignMessage* _internal_add_repeated_foreign_message();
    public:
    const ::proto2_nofieldpresence_unittest::ForeignMessage& repeated_foreign_message(int index) const;
    ::proto2_nofieldpresence_unittest::ForeignMessage* add_repeated_foreign_message();
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::ForeignMessage >&
        repeated_foreign_message() const;
  
    // repeated .protobuf_unittest.TestAllTypes repeated_proto2_message = 50;
    int repeated_proto2_message_size() const;
    private:
    int _internal_repeated_proto2_message_size() const;
    public:
    void clear_repeated_proto2_message();
    ::protobuf_unittest::TestAllTypes* mutable_repeated_proto2_message(int index);
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
        mutable_repeated_proto2_message();
    private:
    const ::protobuf_unittest::TestAllTypes& _internal_repeated_proto2_message(int index) const;
    ::protobuf_unittest::TestAllTypes* _internal_add_repeated_proto2_message();
    public:
    const ::protobuf_unittest::TestAllTypes& repeated_proto2_message(int index) const;
    ::protobuf_unittest::TestAllTypes* add_repeated_proto2_message();
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
        repeated_proto2_message() const;
  
    // repeated .proto2_nofieldpresence_unittest.TestAllTypes.NestedEnum repeated_nested_enum = 51;
    int repeated_nested_enum_size() const;
    private:
    int _internal_repeated_nested_enum_size() const;
    public:
    void clear_repeated_nested_enum();
    private:
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum _internal_repeated_nested_enum(int index) const;
    void _internal_add_repeated_nested_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_repeated_nested_enum();
    public:
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum repeated_nested_enum(int index) const;
    void set_repeated_nested_enum(int index, ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value);
    void add_repeated_nested_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& repeated_nested_enum() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_repeated_nested_enum();
  
    // repeated .proto2_nofieldpresence_unittest.ForeignEnum repeated_foreign_enum = 52;
    int repeated_foreign_enum_size() const;
    private:
    int _internal_repeated_foreign_enum_size() const;
    public:
    void clear_repeated_foreign_enum();
    private:
    ::proto2_nofieldpresence_unittest::ForeignEnum _internal_repeated_foreign_enum(int index) const;
    void _internal_add_repeated_foreign_enum(::proto2_nofieldpresence_unittest::ForeignEnum value);
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_repeated_foreign_enum();
    public:
    ::proto2_nofieldpresence_unittest::ForeignEnum repeated_foreign_enum(int index) const;
    void set_repeated_foreign_enum(int index, ::proto2_nofieldpresence_unittest::ForeignEnum value);
    void add_repeated_foreign_enum(::proto2_nofieldpresence_unittest::ForeignEnum value);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& repeated_foreign_enum() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_repeated_foreign_enum();
  
    // repeated string repeated_string_piece = 54 [ctype = STRING_PIECE];
    int repeated_string_piece_size() const;
    private:
    int _internal_repeated_string_piece_size() const;
    public:
    void clear_repeated_string_piece();
   private:
    // Hidden due to unknown ctype option.
    const std::string& repeated_string_piece(int index) const;
    std::string* mutable_repeated_string_piece(int index);
    void set_repeated_string_piece(int index, const std::string& value);
    void set_repeated_string_piece(int index, std::string&& value);
    void set_repeated_string_piece(int index, const char* value);
    void set_repeated_string_piece(int index, const char* value, size_t size);
    std::string* add_repeated_string_piece();
    void add_repeated_string_piece(const std::string& value);
    void add_repeated_string_piece(std::string&& value);
    void add_repeated_string_piece(const char* value);
    void add_repeated_string_piece(const char* value, size_t size);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& repeated_string_piece() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_repeated_string_piece();
    private:
    const std::string& _internal_repeated_string_piece(int index) const;
    std::string* _internal_add_repeated_string_piece();
    public:
   public:
  
    // repeated string repeated_cord = 55 [ctype = CORD];
    int repeated_cord_size() const;
    private:
    int _internal_repeated_cord_size() const;
    public:
    void clear_repeated_cord();
   private:
    // Hidden due to unknown ctype option.
    const std::string& repeated_cord(int index) const;
    std::string* mutable_repeated_cord(int index);
    void set_repeated_cord(int index, const std::string& value);
    void set_repeated_cord(int index, std::string&& value);
    void set_repeated_cord(int index, const char* value);
    void set_repeated_cord(int index, const char* value, size_t size);
    std::string* add_repeated_cord();
    void add_repeated_cord(const std::string& value);
    void add_repeated_cord(std::string&& value);
    void add_repeated_cord(const char* value);
    void add_repeated_cord(const char* value, size_t size);
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& repeated_cord() const;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_repeated_cord();
    private:
    const std::string& _internal_repeated_cord(int index) const;
    std::string* _internal_add_repeated_cord();
    public:
   public:
  
    // repeated .proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage repeated_lazy_message = 57 [lazy = true];
    int repeated_lazy_message_size() const;
    private:
    int _internal_repeated_lazy_message_size() const;
    public:
    void clear_repeated_lazy_message();
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* mutable_repeated_lazy_message(int index);
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage >*
        mutable_repeated_lazy_message();
    private:
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& _internal_repeated_lazy_message(int index) const;
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* _internal_add_repeated_lazy_message();
    public:
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& repeated_lazy_message(int index) const;
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* add_repeated_lazy_message();
    const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage >&
        repeated_lazy_message() const;
  
    // string optional_string = 14;
    void clear_optional_string();
    const std::string& optional_string() const;
    template <typename ArgT0 = const std::string&, typename... ArgT>
    void set_optional_string(ArgT0&& arg0, ArgT... args);
    std::string* mutable_optional_string();
    PROTOBUF_MUST_USE_RESULT std::string* release_optional_string();
    void set_allocated_optional_string(std::string* optional_string);
    private:
    const std::string& _internal_optional_string() const;
    inline PROTOBUF_ALWAYS_INLINE void _internal_set_optional_string(const std::string& value);
    std::string* _internal_mutable_optional_string();
    public:
  
    // bytes optional_bytes = 15;
    void clear_optional_bytes();
    const std::string& optional_bytes() const;
    template <typename ArgT0 = const std::string&, typename... ArgT>
    void set_optional_bytes(ArgT0&& arg0, ArgT... args);
    std::string* mutable_optional_bytes();
    PROTOBUF_MUST_USE_RESULT std::string* release_optional_bytes();
    void set_allocated_optional_bytes(std::string* optional_bytes);
    private:
    const std::string& _internal_optional_bytes() const;
    inline PROTOBUF_ALWAYS_INLINE void _internal_set_optional_bytes(const std::string& value);
    std::string* _internal_mutable_optional_bytes();
    public:
  
    // string optional_string_piece = 24 [ctype = STRING_PIECE];
    void clear_optional_string_piece();
   private:
    // Hidden due to unknown ctype option.
    const std::string& optional_string_piece() const;
    template <typename ArgT0 = const std::string&, typename... ArgT>
    void set_optional_string_piece(ArgT0&& arg0, ArgT... args);
    std::string* mutable_optional_string_piece();
    PROTOBUF_MUST_USE_RESULT std::string* release_optional_string_piece();
    void set_allocated_optional_string_piece(std::string* optional_string_piece);
    private:
    const std::string& _internal_optional_string_piece() const;
    inline PROTOBUF_ALWAYS_INLINE void _internal_set_optional_string_piece(const std::string& value);
    std::string* _internal_mutable_optional_string_piece();
    public:
   public:
  
    // string optional_cord = 25 [ctype = CORD];
    void clear_optional_cord();
   private:
    // Hidden due to unknown ctype option.
    const std::string& optional_cord() const;
    template <typename ArgT0 = const std::string&, typename... ArgT>
    void set_optional_cord(ArgT0&& arg0, ArgT... args);
    std::string* mutable_optional_cord();
    PROTOBUF_MUST_USE_RESULT std::string* release_optional_cord();
    void set_allocated_optional_cord(std::string* optional_cord);
    private:
    const std::string& _internal_optional_cord() const;
    inline PROTOBUF_ALWAYS_INLINE void _internal_set_optional_cord(const std::string& value);
    std::string* _internal_mutable_optional_cord();
    public:
   public:
  
    // .proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage optional_nested_message = 18;
    bool has_optional_nested_message() const;
    private:
    bool _internal_has_optional_nested_message() const;
    public:
    void clear_optional_nested_message();
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& optional_nested_message() const;
    PROTOBUF_MUST_USE_RESULT ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* release_optional_nested_message();
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* mutable_optional_nested_message();
    void set_allocated_optional_nested_message(::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* optional_nested_message);
    private:
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& _internal_optional_nested_message() const;
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* _internal_mutable_optional_nested_message();
    public:
    void unsafe_arena_set_allocated_optional_nested_message(
        ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* optional_nested_message);
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* unsafe_arena_release_optional_nested_message();
  
    // .proto2_nofieldpresence_unittest.ForeignMessage optional_foreign_message = 19;
    bool has_optional_foreign_message() const;
    private:
    bool _internal_has_optional_foreign_message() const;
    public:
    void clear_optional_foreign_message();
    const ::proto2_nofieldpresence_unittest::ForeignMessage& optional_foreign_message() const;
    PROTOBUF_MUST_USE_RESULT ::proto2_nofieldpresence_unittest::ForeignMessage* release_optional_foreign_message();
    ::proto2_nofieldpresence_unittest::ForeignMessage* mutable_optional_foreign_message();
    void set_allocated_optional_foreign_message(::proto2_nofieldpresence_unittest::ForeignMessage* optional_foreign_message);
    private:
    const ::proto2_nofieldpresence_unittest::ForeignMessage& _internal_optional_foreign_message() const;
    ::proto2_nofieldpresence_unittest::ForeignMessage* _internal_mutable_optional_foreign_message();
    public:
    void unsafe_arena_set_allocated_optional_foreign_message(
        ::proto2_nofieldpresence_unittest::ForeignMessage* optional_foreign_message);
    ::proto2_nofieldpresence_unittest::ForeignMessage* unsafe_arena_release_optional_foreign_message();
  
    // .protobuf_unittest.TestAllTypes optional_proto2_message = 20;
    bool has_optional_proto2_message() const;
    private:
    bool _internal_has_optional_proto2_message() const;
    public:
    void clear_optional_proto2_message();
    const ::protobuf_unittest::TestAllTypes& optional_proto2_message() const;
    PROTOBUF_MUST_USE_RESULT ::protobuf_unittest::TestAllTypes* release_optional_proto2_message();
    ::protobuf_unittest::TestAllTypes* mutable_optional_proto2_message();
    void set_allocated_optional_proto2_message(::protobuf_unittest::TestAllTypes* optional_proto2_message);
    private:
    const ::protobuf_unittest::TestAllTypes& _internal_optional_proto2_message() const;
    ::protobuf_unittest::TestAllTypes* _internal_mutable_optional_proto2_message();
    public:
    void unsafe_arena_set_allocated_optional_proto2_message(
        ::protobuf_unittest::TestAllTypes* optional_proto2_message);
    ::protobuf_unittest::TestAllTypes* unsafe_arena_release_optional_proto2_message();
  
    // .proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage optional_lazy_message = 30 [lazy = true];
    bool has_optional_lazy_message() const;
    private:
    bool _internal_has_optional_lazy_message() const;
    public:
    void clear_optional_lazy_message();
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& optional_lazy_message() const;
    PROTOBUF_MUST_USE_RESULT ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* release_optional_lazy_message();
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* mutable_optional_lazy_message();
    void set_allocated_optional_lazy_message(::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* optional_lazy_message);
    private:
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& _internal_optional_lazy_message() const;
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* _internal_mutable_optional_lazy_message();
    public:
    void unsafe_arena_set_allocated_optional_lazy_message(
        ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* optional_lazy_message);
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* unsafe_arena_release_optional_lazy_message();
  
    // int64 optional_int64 = 2;
    void clear_optional_int64();
    ::PROTOBUF_NAMESPACE_ID::int64 optional_int64() const;
    void set_optional_int64(::PROTOBUF_NAMESPACE_ID::int64 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int64 _internal_optional_int64() const;
    void _internal_set_optional_int64(::PROTOBUF_NAMESPACE_ID::int64 value);
    public:
  
    // int32 optional_int32 = 1;
    void clear_optional_int32();
    ::PROTOBUF_NAMESPACE_ID::int32 optional_int32() const;
    void set_optional_int32(::PROTOBUF_NAMESPACE_ID::int32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_optional_int32() const;
    void _internal_set_optional_int32(::PROTOBUF_NAMESPACE_ID::int32 value);
    public:
  
    // uint32 optional_uint32 = 3;
    void clear_optional_uint32();
    ::PROTOBUF_NAMESPACE_ID::uint32 optional_uint32() const;
    void set_optional_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::uint32 _internal_optional_uint32() const;
    void _internal_set_optional_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value);
    public:
  
    // uint64 optional_uint64 = 4;
    void clear_optional_uint64();
    ::PROTOBUF_NAMESPACE_ID::uint64 optional_uint64() const;
    void set_optional_uint64(::PROTOBUF_NAMESPACE_ID::uint64 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::uint64 _internal_optional_uint64() const;
    void _internal_set_optional_uint64(::PROTOBUF_NAMESPACE_ID::uint64 value);
    public:
  
    // sint64 optional_sint64 = 6;
    void clear_optional_sint64();
    ::PROTOBUF_NAMESPACE_ID::int64 optional_sint64() const;
    void set_optional_sint64(::PROTOBUF_NAMESPACE_ID::int64 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int64 _internal_optional_sint64() const;
    void _internal_set_optional_sint64(::PROTOBUF_NAMESPACE_ID::int64 value);
    public:
  
    // sint32 optional_sint32 = 5;
    void clear_optional_sint32();
    ::PROTOBUF_NAMESPACE_ID::int32 optional_sint32() const;
    void set_optional_sint32(::PROTOBUF_NAMESPACE_ID::int32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_optional_sint32() const;
    void _internal_set_optional_sint32(::PROTOBUF_NAMESPACE_ID::int32 value);
    public:
  
    // fixed32 optional_fixed32 = 7;
    void clear_optional_fixed32();
    ::PROTOBUF_NAMESPACE_ID::uint32 optional_fixed32() const;
    void set_optional_fixed32(::PROTOBUF_NAMESPACE_ID::uint32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::uint32 _internal_optional_fixed32() const;
    void _internal_set_optional_fixed32(::PROTOBUF_NAMESPACE_ID::uint32 value);
    public:
  
    // fixed64 optional_fixed64 = 8;
    void clear_optional_fixed64();
    ::PROTOBUF_NAMESPACE_ID::uint64 optional_fixed64() const;
    void set_optional_fixed64(::PROTOBUF_NAMESPACE_ID::uint64 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::uint64 _internal_optional_fixed64() const;
    void _internal_set_optional_fixed64(::PROTOBUF_NAMESPACE_ID::uint64 value);
    public:
  
    // sfixed64 optional_sfixed64 = 10;
    void clear_optional_sfixed64();
    ::PROTOBUF_NAMESPACE_ID::int64 optional_sfixed64() const;
    void set_optional_sfixed64(::PROTOBUF_NAMESPACE_ID::int64 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int64 _internal_optional_sfixed64() const;
    void _internal_set_optional_sfixed64(::PROTOBUF_NAMESPACE_ID::int64 value);
    public:
  
    // sfixed32 optional_sfixed32 = 9;
    void clear_optional_sfixed32();
    ::PROTOBUF_NAMESPACE_ID::int32 optional_sfixed32() const;
    void set_optional_sfixed32(::PROTOBUF_NAMESPACE_ID::int32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_optional_sfixed32() const;
    void _internal_set_optional_sfixed32(::PROTOBUF_NAMESPACE_ID::int32 value);
    public:
  
    // float optional_float = 11;
    void clear_optional_float();
    float optional_float() const;
    void set_optional_float(float value);
    private:
    float _internal_optional_float() const;
    void _internal_set_optional_float(float value);
    public:
  
    // double optional_double = 12;
    void clear_optional_double();
    double optional_double() const;
    void set_optional_double(double value);
    private:
    double _internal_optional_double() const;
    void _internal_set_optional_double(double value);
    public:
  
    // bool optional_bool = 13;
    void clear_optional_bool();
    bool optional_bool() const;
    void set_optional_bool(bool value);
    private:
    bool _internal_optional_bool() const;
    void _internal_set_optional_bool(bool value);
    public:
  
    // .proto2_nofieldpresence_unittest.TestAllTypes.NestedEnum optional_nested_enum = 21;
    void clear_optional_nested_enum();
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum optional_nested_enum() const;
    void set_optional_nested_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value);
    private:
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum _internal_optional_nested_enum() const;
    void _internal_set_optional_nested_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value);
    public:
  
    // .proto2_nofieldpresence_unittest.ForeignEnum optional_foreign_enum = 22;
    void clear_optional_foreign_enum();
    ::proto2_nofieldpresence_unittest::ForeignEnum optional_foreign_enum() const;
    void set_optional_foreign_enum(::proto2_nofieldpresence_unittest::ForeignEnum value);
    private:
    ::proto2_nofieldpresence_unittest::ForeignEnum _internal_optional_foreign_enum() const;
    void _internal_set_optional_foreign_enum(::proto2_nofieldpresence_unittest::ForeignEnum value);
    public:
  
    // uint32 oneof_uint32 = 111;
    bool has_oneof_uint32() const;
    private:
    bool _internal_has_oneof_uint32() const;
    public:
    void clear_oneof_uint32();
    ::PROTOBUF_NAMESPACE_ID::uint32 oneof_uint32() const;
    void set_oneof_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::uint32 _internal_oneof_uint32() const;
    void _internal_set_oneof_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value);
    public:
  
    // .proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage oneof_nested_message = 112;
    bool has_oneof_nested_message() const;
    private:
    bool _internal_has_oneof_nested_message() const;
    public:
    void clear_oneof_nested_message();
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& oneof_nested_message() const;
    PROTOBUF_MUST_USE_RESULT ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* release_oneof_nested_message();
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* mutable_oneof_nested_message();
    void set_allocated_oneof_nested_message(::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* oneof_nested_message);
    private:
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& _internal_oneof_nested_message() const;
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* _internal_mutable_oneof_nested_message();
    public:
    void unsafe_arena_set_allocated_oneof_nested_message(
        ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* oneof_nested_message);
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* unsafe_arena_release_oneof_nested_message();
  
    // string oneof_string = 113;
    bool has_oneof_string() const;
    private:
    bool _internal_has_oneof_string() const;
    public:
    void clear_oneof_string();
    const std::string& oneof_string() const;
    template <typename ArgT0 = const std::string&, typename... ArgT>
    void set_oneof_string(ArgT0&& arg0, ArgT... args);
    std::string* mutable_oneof_string();
    PROTOBUF_MUST_USE_RESULT std::string* release_oneof_string();
    void set_allocated_oneof_string(std::string* oneof_string);
    private:
    const std::string& _internal_oneof_string() const;
    inline PROTOBUF_ALWAYS_INLINE void _internal_set_oneof_string(const std::string& value);
    std::string* _internal_mutable_oneof_string();
    public:
  
    // .proto2_nofieldpresence_unittest.TestAllTypes.NestedEnum oneof_enum = 114;
    bool has_oneof_enum() const;
    private:
    bool _internal_has_oneof_enum() const;
    public:
    void clear_oneof_enum();
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum oneof_enum() const;
    void set_oneof_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value);
    private:
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum _internal_oneof_enum() const;
    void _internal_set_oneof_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value);
    public:
  
    void clear_oneof_field();
    OneofFieldCase oneof_field_case() const;
    // @@protoc_insertion_point(class_scope:proto2_nofieldpresence_unittest.TestAllTypes)
   private:
    class _Internal;
    void set_has_oneof_uint32();
    void set_has_oneof_nested_message();
    void set_has_oneof_string();
    void set_has_oneof_enum();
  
    inline bool has_oneof_field() const;
    inline void clear_has_oneof_field();
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > repeated_int32_;
    mutable std::atomic<int> _repeated_int32_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > repeated_int64_;
    mutable std::atomic<int> _repeated_int64_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > repeated_uint32_;
    mutable std::atomic<int> _repeated_uint32_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 > repeated_uint64_;
    mutable std::atomic<int> _repeated_uint64_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > repeated_sint32_;
    mutable std::atomic<int> _repeated_sint32_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > repeated_sint64_;
    mutable std::atomic<int> _repeated_sint64_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 > repeated_fixed32_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 > repeated_fixed64_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 > repeated_sfixed32_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 > repeated_sfixed64_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< float > repeated_float_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > repeated_double_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > repeated_bool_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> repeated_string_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> repeated_bytes_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage > repeated_nested_message_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::ForeignMessage > repeated_foreign_message_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf_unittest::TestAllTypes > repeated_proto2_message_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> repeated_nested_enum_;
    mutable std::atomic<int> _repeated_nested_enum_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> repeated_foreign_enum_;
    mutable std::atomic<int> _repeated_foreign_enum_cached_byte_size_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> repeated_string_piece_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> repeated_cord_;
    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage > repeated_lazy_message_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr optional_string_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr optional_bytes_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr optional_string_piece_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr optional_cord_;
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* optional_nested_message_;
    ::proto2_nofieldpresence_unittest::ForeignMessage* optional_foreign_message_;
    ::protobuf_unittest::TestAllTypes* optional_proto2_message_;
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* optional_lazy_message_;
    ::PROTOBUF_NAMESPACE_ID::int64 optional_int64_;
    ::PROTOBUF_NAMESPACE_ID::int32 optional_int32_;
    ::PROTOBUF_NAMESPACE_ID::uint32 optional_uint32_;
    ::PROTOBUF_NAMESPACE_ID::uint64 optional_uint64_;
    ::PROTOBUF_NAMESPACE_ID::int64 optional_sint64_;
    ::PROTOBUF_NAMESPACE_ID::int32 optional_sint32_;
    ::PROTOBUF_NAMESPACE_ID::uint32 optional_fixed32_;
    ::PROTOBUF_NAMESPACE_ID::uint64 optional_fixed64_;
    ::PROTOBUF_NAMESPACE_ID::int64 optional_sfixed64_;
    ::PROTOBUF_NAMESPACE_ID::int32 optional_sfixed32_;
    float optional_float_;
    double optional_double_;
    bool optional_bool_;
    int optional_nested_enum_;
    int optional_foreign_enum_;
    union OneofFieldUnion {
      constexpr OneofFieldUnion() : _constinit_{} {}
        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
      ::PROTOBUF_NAMESPACE_ID::uint32 oneof_uint32_;
      ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* oneof_nested_message_;
      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oneof_string_;
      int oneof_enum_;
    } oneof_field_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
  
    friend struct ::TableStruct_google_2fprotobuf_2funittest_5fno_5ffield_5fpresence_2eproto;
  };
  // -------------------------------------------------------------------
  
  class TestProto2Required final :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto2_nofieldpresence_unittest.TestProto2Required) */ {
   public:
    inline TestProto2Required() : TestProto2Required(nullptr) {}
    ~TestProto2Required() override;
    explicit constexpr TestProto2Required(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  
    TestProto2Required(const TestProto2Required& from);
    TestProto2Required(TestProto2Required&& from) noexcept
      : TestProto2Required() {
      *this = ::std::move(from);
    }
  
    inline TestProto2Required& operator=(const TestProto2Required& from) {
      CopyFrom(from);
      return *this;
    }
    inline TestProto2Required& operator=(TestProto2Required&& from) noexcept {
      if (this == &from) return *this;
      if (GetOwningArena() == from.GetOwningArena()
    #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
          && GetOwningArena() != nullptr
    #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
      ) {
        InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return default_instance().GetMetadata().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return default_instance().GetMetadata().reflection;
    }
    static const TestProto2Required& default_instance() {
      return *internal_default_instance();
    }
    static inline const TestProto2Required* internal_default_instance() {
      return reinterpret_cast<const TestProto2Required*>(
                 &_TestProto2Required_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      2;
  
    friend void swap(TestProto2Required& a, TestProto2Required& b) {
      a.Swap(&b);
    }
    inline void Swap(TestProto2Required* other) {
      if (other == this) return;
    #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
      if (GetOwningArena() != nullptr &&
          GetOwningArena() == other->GetOwningArena()) {
     #else  // PROTOBUF_FORCE_COPY_IN_SWAP
      if (GetOwningArena() == other->GetOwningArena()) {
    #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(TestProto2Required* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline TestProto2Required* New() const final {
      return new TestProto2Required();
    }
  
    TestProto2Required* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<TestProto2Required>(arena);
    }
    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
    void CopyFrom(const TestProto2Required& from);
    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
    void MergeFrom(const TestProto2Required& from);
    private:
    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
    public:
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
        ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(TestProto2Required* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "proto2_nofieldpresence_unittest.TestProto2Required";
    }
    protected:
    explicit TestProto2Required(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned = false);
    private:
    static void ArenaDtor(void* object);
    inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    public:
  
    static const ClassData _class_data_;
    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kProto2FieldNumber = 1,
    };
    // .protobuf_unittest.TestRequired proto2 = 1;
    bool has_proto2() const;
    private:
    bool _internal_has_proto2() const;
    public:
    void clear_proto2();
    const ::protobuf_unittest::TestRequired& proto2() const;
    PROTOBUF_MUST_USE_RESULT ::protobuf_unittest::TestRequired* release_proto2();
    ::protobuf_unittest::TestRequired* mutable_proto2();
    void set_allocated_proto2(::protobuf_unittest::TestRequired* proto2);
    private:
    const ::protobuf_unittest::TestRequired& _internal_proto2() const;
    ::protobuf_unittest::TestRequired* _internal_mutable_proto2();
    public:
    void unsafe_arena_set_allocated_proto2(
        ::protobuf_unittest::TestRequired* proto2);
    ::protobuf_unittest::TestRequired* unsafe_arena_release_proto2();
  
    // @@protoc_insertion_point(class_scope:proto2_nofieldpresence_unittest.TestProto2Required)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::protobuf_unittest::TestRequired* proto2_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_google_2fprotobuf_2funittest_5fno_5ffield_5fpresence_2eproto;
  };
  // -------------------------------------------------------------------
  
  class ForeignMessage final :
      public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto2_nofieldpresence_unittest.ForeignMessage) */ {
   public:
    inline ForeignMessage() : ForeignMessage(nullptr) {}
    ~ForeignMessage() override;
    explicit constexpr ForeignMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  
    ForeignMessage(const ForeignMessage& from);
    ForeignMessage(ForeignMessage&& from) noexcept
      : ForeignMessage() {
      *this = ::std::move(from);
    }
  
    inline ForeignMessage& operator=(const ForeignMessage& from) {
      CopyFrom(from);
      return *this;
    }
    inline ForeignMessage& operator=(ForeignMessage&& from) noexcept {
      if (this == &from) return *this;
      if (GetOwningArena() == from.GetOwningArena()
    #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
          && GetOwningArena() != nullptr
    #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE
      ) {
        InternalSwap(&from);
      } else {
        CopyFrom(from);
      }
      return *this;
    }
  
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
      return GetDescriptor();
    }
    static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
      return default_instance().GetMetadata().descriptor;
    }
    static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
      return default_instance().GetMetadata().reflection;
    }
    static const ForeignMessage& default_instance() {
      return *internal_default_instance();
    }
    static inline const ForeignMessage* internal_default_instance() {
      return reinterpret_cast<const ForeignMessage*>(
                 &_ForeignMessage_default_instance_);
    }
    static constexpr int kIndexInFileMessages =
      3;
  
    friend void swap(ForeignMessage& a, ForeignMessage& b) {
      a.Swap(&b);
    }
    inline void Swap(ForeignMessage* other) {
      if (other == this) return;
    #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
      if (GetOwningArena() != nullptr &&
          GetOwningArena() == other->GetOwningArena()) {
     #else  // PROTOBUF_FORCE_COPY_IN_SWAP
      if (GetOwningArena() == other->GetOwningArena()) {
    #endif  // !PROTOBUF_FORCE_COPY_IN_SWAP
        InternalSwap(other);
      } else {
        ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
      }
    }
    void UnsafeArenaSwap(ForeignMessage* other) {
      if (other == this) return;
      GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
      InternalSwap(other);
    }
  
    // implements Message ----------------------------------------------
  
    inline ForeignMessage* New() const final {
      return new ForeignMessage();
    }
  
    ForeignMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
      return CreateMaybeMessage<ForeignMessage>(arena);
    }
    using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
    void CopyFrom(const ForeignMessage& from);
    using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
    void MergeFrom(const ForeignMessage& from);
    private:
    static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
    public:
    PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
    bool IsInitialized() const final;
  
    size_t ByteSizeLong() const final;
    const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
    ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
        ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
    int GetCachedSize() const final { return _cached_size_.Get(); }
  
    private:
    void SharedCtor();
    void SharedDtor();
    void SetCachedSize(int size) const final;
    void InternalSwap(ForeignMessage* other);
    friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
    static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
      return "proto2_nofieldpresence_unittest.ForeignMessage";
    }
    protected:
    explicit ForeignMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
                         bool is_message_owned = false);
    private:
    static void ArenaDtor(void* object);
    inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
    public:
  
    static const ClassData _class_data_;
    const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
  
    ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  
    // nested types ----------------------------------------------------
  
    // accessors -------------------------------------------------------
  
    enum : int {
      kCFieldNumber = 1,
    };
    // int32 c = 1;
    void clear_c();
    ::PROTOBUF_NAMESPACE_ID::int32 c() const;
    void set_c(::PROTOBUF_NAMESPACE_ID::int32 value);
    private:
    ::PROTOBUF_NAMESPACE_ID::int32 _internal_c() const;
    void _internal_set_c(::PROTOBUF_NAMESPACE_ID::int32 value);
    public:
  
    // @@protoc_insertion_point(class_scope:proto2_nofieldpresence_unittest.ForeignMessage)
   private:
    class _Internal;
  
    template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
    typedef void InternalArenaConstructable_;
    typedef void DestructorSkippable_;
    ::PROTOBUF_NAMESPACE_ID::int32 c_;
    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
    friend struct ::TableStruct_google_2fprotobuf_2funittest_5fno_5ffield_5fpresence_2eproto;
  };
  // ===================================================================
  
  
  // ===================================================================
  
  #ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wstrict-aliasing"
  #endif  // __GNUC__
  // TestAllTypes_NestedMessage
  
  // int32 bb = 1;
  inline void TestAllTypes_NestedMessage::clear_bb() {
    bb_ = 0;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes_NestedMessage::_internal_bb() const {
    return bb_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes_NestedMessage::bb() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage.bb)
    return _internal_bb();
  }
  inline void TestAllTypes_NestedMessage::_internal_set_bb(::PROTOBUF_NAMESPACE_ID::int32 value) {
    
    bb_ = value;
  }
  inline void TestAllTypes_NestedMessage::set_bb(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_set_bb(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage.bb)
  }
  
  // -------------------------------------------------------------------
  
  // TestAllTypes
  
  // int32 optional_int32 = 1;
  inline void TestAllTypes::clear_optional_int32() {
    optional_int32_ = 0;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::_internal_optional_int32() const {
    return optional_int32_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::optional_int32() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_int32)
    return _internal_optional_int32();
  }
  inline void TestAllTypes::_internal_set_optional_int32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    
    optional_int32_ = value;
  }
  inline void TestAllTypes::set_optional_int32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_set_optional_int32(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_int32)
  }
  
  // int64 optional_int64 = 2;
  inline void TestAllTypes::clear_optional_int64() {
    optional_int64_ = int64_t{0};
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::_internal_optional_int64() const {
    return optional_int64_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::optional_int64() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_int64)
    return _internal_optional_int64();
  }
  inline void TestAllTypes::_internal_set_optional_int64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    optional_int64_ = value;
  }
  inline void TestAllTypes::set_optional_int64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    _internal_set_optional_int64(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_int64)
  }
  
  // uint32 optional_uint32 = 3;
  inline void TestAllTypes::clear_optional_uint32() {
    optional_uint32_ = 0u;
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint32 TestAllTypes::_internal_optional_uint32() const {
    return optional_uint32_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint32 TestAllTypes::optional_uint32() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_uint32)
    return _internal_optional_uint32();
  }
  inline void TestAllTypes::_internal_set_optional_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value) {
    
    optional_uint32_ = value;
  }
  inline void TestAllTypes::set_optional_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value) {
    _internal_set_optional_uint32(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_uint32)
  }
  
  // uint64 optional_uint64 = 4;
  inline void TestAllTypes::clear_optional_uint64() {
    optional_uint64_ = uint64_t{0u};
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 TestAllTypes::_internal_optional_uint64() const {
    return optional_uint64_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 TestAllTypes::optional_uint64() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_uint64)
    return _internal_optional_uint64();
  }
  inline void TestAllTypes::_internal_set_optional_uint64(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    
    optional_uint64_ = value;
  }
  inline void TestAllTypes::set_optional_uint64(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    _internal_set_optional_uint64(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_uint64)
  }
  
  // sint32 optional_sint32 = 5;
  inline void TestAllTypes::clear_optional_sint32() {
    optional_sint32_ = 0;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::_internal_optional_sint32() const {
    return optional_sint32_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::optional_sint32() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_sint32)
    return _internal_optional_sint32();
  }
  inline void TestAllTypes::_internal_set_optional_sint32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    
    optional_sint32_ = value;
  }
  inline void TestAllTypes::set_optional_sint32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_set_optional_sint32(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_sint32)
  }
  
  // sint64 optional_sint64 = 6;
  inline void TestAllTypes::clear_optional_sint64() {
    optional_sint64_ = int64_t{0};
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::_internal_optional_sint64() const {
    return optional_sint64_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::optional_sint64() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_sint64)
    return _internal_optional_sint64();
  }
  inline void TestAllTypes::_internal_set_optional_sint64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    optional_sint64_ = value;
  }
  inline void TestAllTypes::set_optional_sint64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    _internal_set_optional_sint64(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_sint64)
  }
  
  // fixed32 optional_fixed32 = 7;
  inline void TestAllTypes::clear_optional_fixed32() {
    optional_fixed32_ = 0u;
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint32 TestAllTypes::_internal_optional_fixed32() const {
    return optional_fixed32_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint32 TestAllTypes::optional_fixed32() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_fixed32)
    return _internal_optional_fixed32();
  }
  inline void TestAllTypes::_internal_set_optional_fixed32(::PROTOBUF_NAMESPACE_ID::uint32 value) {
    
    optional_fixed32_ = value;
  }
  inline void TestAllTypes::set_optional_fixed32(::PROTOBUF_NAMESPACE_ID::uint32 value) {
    _internal_set_optional_fixed32(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_fixed32)
  }
  
  // fixed64 optional_fixed64 = 8;
  inline void TestAllTypes::clear_optional_fixed64() {
    optional_fixed64_ = uint64_t{0u};
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 TestAllTypes::_internal_optional_fixed64() const {
    return optional_fixed64_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 TestAllTypes::optional_fixed64() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_fixed64)
    return _internal_optional_fixed64();
  }
  inline void TestAllTypes::_internal_set_optional_fixed64(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    
    optional_fixed64_ = value;
  }
  inline void TestAllTypes::set_optional_fixed64(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    _internal_set_optional_fixed64(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_fixed64)
  }
  
  // sfixed32 optional_sfixed32 = 9;
  inline void TestAllTypes::clear_optional_sfixed32() {
    optional_sfixed32_ = 0;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::_internal_optional_sfixed32() const {
    return optional_sfixed32_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::optional_sfixed32() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_sfixed32)
    return _internal_optional_sfixed32();
  }
  inline void TestAllTypes::_internal_set_optional_sfixed32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    
    optional_sfixed32_ = value;
  }
  inline void TestAllTypes::set_optional_sfixed32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_set_optional_sfixed32(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_sfixed32)
  }
  
  // sfixed64 optional_sfixed64 = 10;
  inline void TestAllTypes::clear_optional_sfixed64() {
    optional_sfixed64_ = int64_t{0};
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::_internal_optional_sfixed64() const {
    return optional_sfixed64_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::optional_sfixed64() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_sfixed64)
    return _internal_optional_sfixed64();
  }
  inline void TestAllTypes::_internal_set_optional_sfixed64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    
    optional_sfixed64_ = value;
  }
  inline void TestAllTypes::set_optional_sfixed64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    _internal_set_optional_sfixed64(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_sfixed64)
  }
  
  // float optional_float = 11;
  inline void TestAllTypes::clear_optional_float() {
    optional_float_ = 0;
  }
  inline float TestAllTypes::_internal_optional_float() const {
    return optional_float_;
  }
  inline float TestAllTypes::optional_float() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_float)
    return _internal_optional_float();
  }
  inline void TestAllTypes::_internal_set_optional_float(float value) {
    
    optional_float_ = value;
  }
  inline void TestAllTypes::set_optional_float(float value) {
    _internal_set_optional_float(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_float)
  }
  
  // double optional_double = 12;
  inline void TestAllTypes::clear_optional_double() {
    optional_double_ = 0;
  }
  inline double TestAllTypes::_internal_optional_double() const {
    return optional_double_;
  }
  inline double TestAllTypes::optional_double() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_double)
    return _internal_optional_double();
  }
  inline void TestAllTypes::_internal_set_optional_double(double value) {
    
    optional_double_ = value;
  }
  inline void TestAllTypes::set_optional_double(double value) {
    _internal_set_optional_double(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_double)
  }
  
  // bool optional_bool = 13;
  inline void TestAllTypes::clear_optional_bool() {
    optional_bool_ = false;
  }
  inline bool TestAllTypes::_internal_optional_bool() const {
    return optional_bool_;
  }
  inline bool TestAllTypes::optional_bool() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_bool)
    return _internal_optional_bool();
  }
  inline void TestAllTypes::_internal_set_optional_bool(bool value) {
    
    optional_bool_ = value;
  }
  inline void TestAllTypes::set_optional_bool(bool value) {
    _internal_set_optional_bool(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_bool)
  }
  
  // string optional_string = 14;
  inline void TestAllTypes::clear_optional_string() {
    optional_string_.ClearToEmpty();
  }
  inline const std::string& TestAllTypes::optional_string() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_string)
    return _internal_optional_string();
  }
  template <typename ArgT0, typename... ArgT>
  inline PROTOBUF_ALWAYS_INLINE
  void TestAllTypes::set_optional_string(ArgT0&& arg0, ArgT... args) {
   
   optional_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_string)
  }
  inline std::string* TestAllTypes::mutable_optional_string() {
    std::string* _s = _internal_mutable_optional_string();
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.optional_string)
    return _s;
  }
  inline const std::string& TestAllTypes::_internal_optional_string() const {
    return optional_string_.Get();
  }
  inline void TestAllTypes::_internal_set_optional_string(const std::string& value) {
    
    optional_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
  }
  inline std::string* TestAllTypes::_internal_mutable_optional_string() {
    
    return optional_string_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
  }
  inline std::string* TestAllTypes::release_optional_string() {
    // @@protoc_insertion_point(field_release:proto2_nofieldpresence_unittest.TestAllTypes.optional_string)
    return optional_string_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  }
  inline void TestAllTypes::set_allocated_optional_string(std::string* optional_string) {
    if (optional_string != nullptr) {
      
    } else {
      
    }
    optional_string_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), optional_string,
        GetArenaForAllocation());
    // @@protoc_insertion_point(field_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_string)
  }
  
  // bytes optional_bytes = 15;
  inline void TestAllTypes::clear_optional_bytes() {
    optional_bytes_.ClearToEmpty();
  }
  inline const std::string& TestAllTypes::optional_bytes() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_bytes)
    return _internal_optional_bytes();
  }
  template <typename ArgT0, typename... ArgT>
  inline PROTOBUF_ALWAYS_INLINE
  void TestAllTypes::set_optional_bytes(ArgT0&& arg0, ArgT... args) {
   
   optional_bytes_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_bytes)
  }
  inline std::string* TestAllTypes::mutable_optional_bytes() {
    std::string* _s = _internal_mutable_optional_bytes();
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.optional_bytes)
    return _s;
  }
  inline const std::string& TestAllTypes::_internal_optional_bytes() const {
    return optional_bytes_.Get();
  }
  inline void TestAllTypes::_internal_set_optional_bytes(const std::string& value) {
    
    optional_bytes_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
  }
  inline std::string* TestAllTypes::_internal_mutable_optional_bytes() {
    
    return optional_bytes_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
  }
  inline std::string* TestAllTypes::release_optional_bytes() {
    // @@protoc_insertion_point(field_release:proto2_nofieldpresence_unittest.TestAllTypes.optional_bytes)
    return optional_bytes_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  }
  inline void TestAllTypes::set_allocated_optional_bytes(std::string* optional_bytes) {
    if (optional_bytes != nullptr) {
      
    } else {
      
    }
    optional_bytes_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), optional_bytes,
        GetArenaForAllocation());
    // @@protoc_insertion_point(field_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_bytes)
  }
  
  // .proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage optional_nested_message = 18;
  inline bool TestAllTypes::_internal_has_optional_nested_message() const {
    return this != internal_default_instance() && optional_nested_message_ != nullptr;
  }
  inline bool TestAllTypes::has_optional_nested_message() const {
    return _internal_has_optional_nested_message();
  }
  inline void TestAllTypes::clear_optional_nested_message() {
    if (GetArenaForAllocation() == nullptr && optional_nested_message_ != nullptr) {
      delete optional_nested_message_;
    }
    optional_nested_message_ = nullptr;
  }
  inline const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& TestAllTypes::_internal_optional_nested_message() const {
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* p = optional_nested_message_;
    return p != nullptr ? *p : reinterpret_cast<const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage&>(
        ::proto2_nofieldpresence_unittest::_TestAllTypes_NestedMessage_default_instance_);
  }
  inline const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& TestAllTypes::optional_nested_message() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_nested_message)
    return _internal_optional_nested_message();
  }
  inline void TestAllTypes::unsafe_arena_set_allocated_optional_nested_message(
      ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* optional_nested_message) {
    if (GetArenaForAllocation() == nullptr) {
      delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optional_nested_message_);
    }
    optional_nested_message_ = optional_nested_message;
    if (optional_nested_message) {
      
    } else {
      
    }
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_nested_message)
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::release_optional_nested_message() {
    
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* temp = optional_nested_message_;
    optional_nested_message_ = nullptr;
  #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
    auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    if (GetArenaForAllocation() == nullptr) { delete old; }
  #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
  #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
    return temp;
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::unsafe_arena_release_optional_nested_message() {
    // @@protoc_insertion_point(field_release:proto2_nofieldpresence_unittest.TestAllTypes.optional_nested_message)
    
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* temp = optional_nested_message_;
    optional_nested_message_ = nullptr;
    return temp;
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::_internal_mutable_optional_nested_message() {
    
    if (optional_nested_message_ == nullptr) {
      auto* p = CreateMaybeMessage<::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage>(GetArenaForAllocation());
      optional_nested_message_ = p;
    }
    return optional_nested_message_;
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::mutable_optional_nested_message() {
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* _msg = _internal_mutable_optional_nested_message();
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.optional_nested_message)
    return _msg;
  }
  inline void TestAllTypes::set_allocated_optional_nested_message(::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* optional_nested_message) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
    if (message_arena == nullptr) {
      delete optional_nested_message_;
    }
    if (optional_nested_message) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
          ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage>::GetOwningArena(optional_nested_message);
      if (message_arena != submessage_arena) {
        optional_nested_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, optional_nested_message, submessage_arena);
      }
      
    } else {
      
    }
    optional_nested_message_ = optional_nested_message;
    // @@protoc_insertion_point(field_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_nested_message)
  }
  
  // .proto2_nofieldpresence_unittest.ForeignMessage optional_foreign_message = 19;
  inline bool TestAllTypes::_internal_has_optional_foreign_message() const {
    return this != internal_default_instance() && optional_foreign_message_ != nullptr;
  }
  inline bool TestAllTypes::has_optional_foreign_message() const {
    return _internal_has_optional_foreign_message();
  }
  inline void TestAllTypes::clear_optional_foreign_message() {
    if (GetArenaForAllocation() == nullptr && optional_foreign_message_ != nullptr) {
      delete optional_foreign_message_;
    }
    optional_foreign_message_ = nullptr;
  }
  inline const ::proto2_nofieldpresence_unittest::ForeignMessage& TestAllTypes::_internal_optional_foreign_message() const {
    const ::proto2_nofieldpresence_unittest::ForeignMessage* p = optional_foreign_message_;
    return p != nullptr ? *p : reinterpret_cast<const ::proto2_nofieldpresence_unittest::ForeignMessage&>(
        ::proto2_nofieldpresence_unittest::_ForeignMessage_default_instance_);
  }
  inline const ::proto2_nofieldpresence_unittest::ForeignMessage& TestAllTypes::optional_foreign_message() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_foreign_message)
    return _internal_optional_foreign_message();
  }
  inline void TestAllTypes::unsafe_arena_set_allocated_optional_foreign_message(
      ::proto2_nofieldpresence_unittest::ForeignMessage* optional_foreign_message) {
    if (GetArenaForAllocation() == nullptr) {
      delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optional_foreign_message_);
    }
    optional_foreign_message_ = optional_foreign_message;
    if (optional_foreign_message) {
      
    } else {
      
    }
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_foreign_message)
  }
  inline ::proto2_nofieldpresence_unittest::ForeignMessage* TestAllTypes::release_optional_foreign_message() {
    
    ::proto2_nofieldpresence_unittest::ForeignMessage* temp = optional_foreign_message_;
    optional_foreign_message_ = nullptr;
  #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
    auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    if (GetArenaForAllocation() == nullptr) { delete old; }
  #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
  #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
    return temp;
  }
  inline ::proto2_nofieldpresence_unittest::ForeignMessage* TestAllTypes::unsafe_arena_release_optional_foreign_message() {
    // @@protoc_insertion_point(field_release:proto2_nofieldpresence_unittest.TestAllTypes.optional_foreign_message)
    
    ::proto2_nofieldpresence_unittest::ForeignMessage* temp = optional_foreign_message_;
    optional_foreign_message_ = nullptr;
    return temp;
  }
  inline ::proto2_nofieldpresence_unittest::ForeignMessage* TestAllTypes::_internal_mutable_optional_foreign_message() {
    
    if (optional_foreign_message_ == nullptr) {
      auto* p = CreateMaybeMessage<::proto2_nofieldpresence_unittest::ForeignMessage>(GetArenaForAllocation());
      optional_foreign_message_ = p;
    }
    return optional_foreign_message_;
  }
  inline ::proto2_nofieldpresence_unittest::ForeignMessage* TestAllTypes::mutable_optional_foreign_message() {
    ::proto2_nofieldpresence_unittest::ForeignMessage* _msg = _internal_mutable_optional_foreign_message();
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.optional_foreign_message)
    return _msg;
  }
  inline void TestAllTypes::set_allocated_optional_foreign_message(::proto2_nofieldpresence_unittest::ForeignMessage* optional_foreign_message) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
    if (message_arena == nullptr) {
      delete optional_foreign_message_;
    }
    if (optional_foreign_message) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
          ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto2_nofieldpresence_unittest::ForeignMessage>::GetOwningArena(optional_foreign_message);
      if (message_arena != submessage_arena) {
        optional_foreign_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, optional_foreign_message, submessage_arena);
      }
      
    } else {
      
    }
    optional_foreign_message_ = optional_foreign_message;
    // @@protoc_insertion_point(field_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_foreign_message)
  }
  
  // .protobuf_unittest.TestAllTypes optional_proto2_message = 20;
  inline bool TestAllTypes::_internal_has_optional_proto2_message() const {
    return this != internal_default_instance() && optional_proto2_message_ != nullptr;
  }
  inline bool TestAllTypes::has_optional_proto2_message() const {
    return _internal_has_optional_proto2_message();
  }
  inline const ::protobuf_unittest::TestAllTypes& TestAllTypes::_internal_optional_proto2_message() const {
    const ::protobuf_unittest::TestAllTypes* p = optional_proto2_message_;
    return p != nullptr ? *p : reinterpret_cast<const ::protobuf_unittest::TestAllTypes&>(
        ::protobuf_unittest::_TestAllTypes_default_instance_);
  }
  inline const ::protobuf_unittest::TestAllTypes& TestAllTypes::optional_proto2_message() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_proto2_message)
    return _internal_optional_proto2_message();
  }
  inline void TestAllTypes::unsafe_arena_set_allocated_optional_proto2_message(
      ::protobuf_unittest::TestAllTypes* optional_proto2_message) {
    if (GetArenaForAllocation() == nullptr) {
      delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optional_proto2_message_);
    }
    optional_proto2_message_ = optional_proto2_message;
    if (optional_proto2_message) {
      
    } else {
      
    }
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_proto2_message)
  }
  inline ::protobuf_unittest::TestAllTypes* TestAllTypes::release_optional_proto2_message() {
    
    ::protobuf_unittest::TestAllTypes* temp = optional_proto2_message_;
    optional_proto2_message_ = nullptr;
  #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
    auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    if (GetArenaForAllocation() == nullptr) { delete old; }
  #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
  #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
    return temp;
  }
  inline ::protobuf_unittest::TestAllTypes* TestAllTypes::unsafe_arena_release_optional_proto2_message() {
    // @@protoc_insertion_point(field_release:proto2_nofieldpresence_unittest.TestAllTypes.optional_proto2_message)
    
    ::protobuf_unittest::TestAllTypes* temp = optional_proto2_message_;
    optional_proto2_message_ = nullptr;
    return temp;
  }
  inline ::protobuf_unittest::TestAllTypes* TestAllTypes::_internal_mutable_optional_proto2_message() {
    
    if (optional_proto2_message_ == nullptr) {
      auto* p = CreateMaybeMessage<::protobuf_unittest::TestAllTypes>(GetArenaForAllocation());
      optional_proto2_message_ = p;
    }
    return optional_proto2_message_;
  }
  inline ::protobuf_unittest::TestAllTypes* TestAllTypes::mutable_optional_proto2_message() {
    ::protobuf_unittest::TestAllTypes* _msg = _internal_mutable_optional_proto2_message();
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.optional_proto2_message)
    return _msg;
  }
  inline void TestAllTypes::set_allocated_optional_proto2_message(::protobuf_unittest::TestAllTypes* optional_proto2_message) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
    if (message_arena == nullptr) {
      delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(optional_proto2_message_);
    }
    if (optional_proto2_message) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
          ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
              ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optional_proto2_message));
      if (message_arena != submessage_arena) {
        optional_proto2_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, optional_proto2_message, submessage_arena);
      }
      
    } else {
      
    }
    optional_proto2_message_ = optional_proto2_message;
    // @@protoc_insertion_point(field_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_proto2_message)
  }
  
  // .proto2_nofieldpresence_unittest.TestAllTypes.NestedEnum optional_nested_enum = 21;
  inline void TestAllTypes::clear_optional_nested_enum() {
    optional_nested_enum_ = 0;
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum TestAllTypes::_internal_optional_nested_enum() const {
    return static_cast< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum >(optional_nested_enum_);
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum TestAllTypes::optional_nested_enum() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_nested_enum)
    return _internal_optional_nested_enum();
  }
  inline void TestAllTypes::_internal_set_optional_nested_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value) {
    
    optional_nested_enum_ = value;
  }
  inline void TestAllTypes::set_optional_nested_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value) {
    _internal_set_optional_nested_enum(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_nested_enum)
  }
  
  // .proto2_nofieldpresence_unittest.ForeignEnum optional_foreign_enum = 22;
  inline void TestAllTypes::clear_optional_foreign_enum() {
    optional_foreign_enum_ = 0;
  }
  inline ::proto2_nofieldpresence_unittest::ForeignEnum TestAllTypes::_internal_optional_foreign_enum() const {
    return static_cast< ::proto2_nofieldpresence_unittest::ForeignEnum >(optional_foreign_enum_);
  }
  inline ::proto2_nofieldpresence_unittest::ForeignEnum TestAllTypes::optional_foreign_enum() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_foreign_enum)
    return _internal_optional_foreign_enum();
  }
  inline void TestAllTypes::_internal_set_optional_foreign_enum(::proto2_nofieldpresence_unittest::ForeignEnum value) {
    
    optional_foreign_enum_ = value;
  }
  inline void TestAllTypes::set_optional_foreign_enum(::proto2_nofieldpresence_unittest::ForeignEnum value) {
    _internal_set_optional_foreign_enum(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_foreign_enum)
  }
  
  // string optional_string_piece = 24 [ctype = STRING_PIECE];
  inline void TestAllTypes::clear_optional_string_piece() {
    optional_string_piece_.ClearToEmpty();
  }
  inline const std::string& TestAllTypes::optional_string_piece() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_string_piece)
    return _internal_optional_string_piece();
  }
  template <typename ArgT0, typename... ArgT>
  inline PROTOBUF_ALWAYS_INLINE
  void TestAllTypes::set_optional_string_piece(ArgT0&& arg0, ArgT... args) {
   
   optional_string_piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_string_piece)
  }
  inline std::string* TestAllTypes::mutable_optional_string_piece() {
    std::string* _s = _internal_mutable_optional_string_piece();
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.optional_string_piece)
    return _s;
  }
  inline const std::string& TestAllTypes::_internal_optional_string_piece() const {
    return optional_string_piece_.Get();
  }
  inline void TestAllTypes::_internal_set_optional_string_piece(const std::string& value) {
    
    optional_string_piece_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
  }
  inline std::string* TestAllTypes::_internal_mutable_optional_string_piece() {
    
    return optional_string_piece_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
  }
  inline std::string* TestAllTypes::release_optional_string_piece() {
    // @@protoc_insertion_point(field_release:proto2_nofieldpresence_unittest.TestAllTypes.optional_string_piece)
    return optional_string_piece_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  }
  inline void TestAllTypes::set_allocated_optional_string_piece(std::string* optional_string_piece) {
    if (optional_string_piece != nullptr) {
      
    } else {
      
    }
    optional_string_piece_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), optional_string_piece,
        GetArenaForAllocation());
    // @@protoc_insertion_point(field_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_string_piece)
  }
  
  // string optional_cord = 25 [ctype = CORD];
  inline void TestAllTypes::clear_optional_cord() {
    optional_cord_.ClearToEmpty();
  }
  inline const std::string& TestAllTypes::optional_cord() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_cord)
    return _internal_optional_cord();
  }
  template <typename ArgT0, typename... ArgT>
  inline PROTOBUF_ALWAYS_INLINE
  void TestAllTypes::set_optional_cord(ArgT0&& arg0, ArgT... args) {
   
   optional_cord_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.optional_cord)
  }
  inline std::string* TestAllTypes::mutable_optional_cord() {
    std::string* _s = _internal_mutable_optional_cord();
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.optional_cord)
    return _s;
  }
  inline const std::string& TestAllTypes::_internal_optional_cord() const {
    return optional_cord_.Get();
  }
  inline void TestAllTypes::_internal_set_optional_cord(const std::string& value) {
    
    optional_cord_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
  }
  inline std::string* TestAllTypes::_internal_mutable_optional_cord() {
    
    return optional_cord_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
  }
  inline std::string* TestAllTypes::release_optional_cord() {
    // @@protoc_insertion_point(field_release:proto2_nofieldpresence_unittest.TestAllTypes.optional_cord)
    return optional_cord_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
  }
  inline void TestAllTypes::set_allocated_optional_cord(std::string* optional_cord) {
    if (optional_cord != nullptr) {
      
    } else {
      
    }
    optional_cord_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), optional_cord,
        GetArenaForAllocation());
    // @@protoc_insertion_point(field_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_cord)
  }
  
  // .proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage optional_lazy_message = 30 [lazy = true];
  inline bool TestAllTypes::_internal_has_optional_lazy_message() const {
    return this != internal_default_instance() && optional_lazy_message_ != nullptr;
  }
  inline bool TestAllTypes::has_optional_lazy_message() const {
    return _internal_has_optional_lazy_message();
  }
  inline void TestAllTypes::clear_optional_lazy_message() {
    if (GetArenaForAllocation() == nullptr && optional_lazy_message_ != nullptr) {
      delete optional_lazy_message_;
    }
    optional_lazy_message_ = nullptr;
  }
  inline const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& TestAllTypes::_internal_optional_lazy_message() const {
    const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* p = optional_lazy_message_;
    return p != nullptr ? *p : reinterpret_cast<const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage&>(
        ::proto2_nofieldpresence_unittest::_TestAllTypes_NestedMessage_default_instance_);
  }
  inline const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& TestAllTypes::optional_lazy_message() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.optional_lazy_message)
    return _internal_optional_lazy_message();
  }
  inline void TestAllTypes::unsafe_arena_set_allocated_optional_lazy_message(
      ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* optional_lazy_message) {
    if (GetArenaForAllocation() == nullptr) {
      delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(optional_lazy_message_);
    }
    optional_lazy_message_ = optional_lazy_message;
    if (optional_lazy_message) {
      
    } else {
      
    }
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_lazy_message)
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::release_optional_lazy_message() {
    
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* temp = optional_lazy_message_;
    optional_lazy_message_ = nullptr;
  #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
    auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    if (GetArenaForAllocation() == nullptr) { delete old; }
  #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
  #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
    return temp;
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::unsafe_arena_release_optional_lazy_message() {
    // @@protoc_insertion_point(field_release:proto2_nofieldpresence_unittest.TestAllTypes.optional_lazy_message)
    
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* temp = optional_lazy_message_;
    optional_lazy_message_ = nullptr;
    return temp;
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::_internal_mutable_optional_lazy_message() {
    
    if (optional_lazy_message_ == nullptr) {
      auto* p = CreateMaybeMessage<::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage>(GetArenaForAllocation());
      optional_lazy_message_ = p;
    }
    return optional_lazy_message_;
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::mutable_optional_lazy_message() {
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* _msg = _internal_mutable_optional_lazy_message();
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.optional_lazy_message)
    return _msg;
  }
  inline void TestAllTypes::set_allocated_optional_lazy_message(::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* optional_lazy_message) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
    if (message_arena == nullptr) {
      delete optional_lazy_message_;
    }
    if (optional_lazy_message) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
          ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage>::GetOwningArena(optional_lazy_message);
      if (message_arena != submessage_arena) {
        optional_lazy_message = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, optional_lazy_message, submessage_arena);
      }
      
    } else {
      
    }
    optional_lazy_message_ = optional_lazy_message;
    // @@protoc_insertion_point(field_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.optional_lazy_message)
  }
  
  // repeated int32 repeated_int32 = 31;
  inline int TestAllTypes::_internal_repeated_int32_size() const {
    return repeated_int32_.size();
  }
  inline int TestAllTypes::repeated_int32_size() const {
    return _internal_repeated_int32_size();
  }
  inline void TestAllTypes::clear_repeated_int32() {
    repeated_int32_.Clear();
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::_internal_repeated_int32(int index) const {
    return repeated_int32_.Get(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::repeated_int32(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_int32)
    return _internal_repeated_int32(index);
  }
  inline void TestAllTypes::set_repeated_int32(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
    repeated_int32_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_int32)
  }
  inline void TestAllTypes::_internal_add_repeated_int32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    repeated_int32_.Add(value);
  }
  inline void TestAllTypes::add_repeated_int32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_add_repeated_int32(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_int32)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
  TestAllTypes::_internal_repeated_int32() const {
    return repeated_int32_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
  TestAllTypes::repeated_int32() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_int32)
    return _internal_repeated_int32();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
  TestAllTypes::_internal_mutable_repeated_int32() {
    return &repeated_int32_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
  TestAllTypes::mutable_repeated_int32() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_int32)
    return _internal_mutable_repeated_int32();
  }
  
  // repeated int64 repeated_int64 = 32;
  inline int TestAllTypes::_internal_repeated_int64_size() const {
    return repeated_int64_.size();
  }
  inline int TestAllTypes::repeated_int64_size() const {
    return _internal_repeated_int64_size();
  }
  inline void TestAllTypes::clear_repeated_int64() {
    repeated_int64_.Clear();
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::_internal_repeated_int64(int index) const {
    return repeated_int64_.Get(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::repeated_int64(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_int64)
    return _internal_repeated_int64(index);
  }
  inline void TestAllTypes::set_repeated_int64(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
    repeated_int64_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_int64)
  }
  inline void TestAllTypes::_internal_add_repeated_int64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    repeated_int64_.Add(value);
  }
  inline void TestAllTypes::add_repeated_int64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    _internal_add_repeated_int64(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_int64)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
  TestAllTypes::_internal_repeated_int64() const {
    return repeated_int64_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
  TestAllTypes::repeated_int64() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_int64)
    return _internal_repeated_int64();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
  TestAllTypes::_internal_mutable_repeated_int64() {
    return &repeated_int64_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
  TestAllTypes::mutable_repeated_int64() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_int64)
    return _internal_mutable_repeated_int64();
  }
  
  // repeated uint32 repeated_uint32 = 33;
  inline int TestAllTypes::_internal_repeated_uint32_size() const {
    return repeated_uint32_.size();
  }
  inline int TestAllTypes::repeated_uint32_size() const {
    return _internal_repeated_uint32_size();
  }
  inline void TestAllTypes::clear_repeated_uint32() {
    repeated_uint32_.Clear();
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint32 TestAllTypes::_internal_repeated_uint32(int index) const {
    return repeated_uint32_.Get(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint32 TestAllTypes::repeated_uint32(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_uint32)
    return _internal_repeated_uint32(index);
  }
  inline void TestAllTypes::set_repeated_uint32(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) {
    repeated_uint32_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_uint32)
  }
  inline void TestAllTypes::_internal_add_repeated_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value) {
    repeated_uint32_.Add(value);
  }
  inline void TestAllTypes::add_repeated_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value) {
    _internal_add_repeated_uint32(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_uint32)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
  TestAllTypes::_internal_repeated_uint32() const {
    return repeated_uint32_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
  TestAllTypes::repeated_uint32() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_uint32)
    return _internal_repeated_uint32();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
  TestAllTypes::_internal_mutable_repeated_uint32() {
    return &repeated_uint32_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
  TestAllTypes::mutable_repeated_uint32() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_uint32)
    return _internal_mutable_repeated_uint32();
  }
  
  // repeated uint64 repeated_uint64 = 34;
  inline int TestAllTypes::_internal_repeated_uint64_size() const {
    return repeated_uint64_.size();
  }
  inline int TestAllTypes::repeated_uint64_size() const {
    return _internal_repeated_uint64_size();
  }
  inline void TestAllTypes::clear_repeated_uint64() {
    repeated_uint64_.Clear();
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 TestAllTypes::_internal_repeated_uint64(int index) const {
    return repeated_uint64_.Get(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 TestAllTypes::repeated_uint64(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_uint64)
    return _internal_repeated_uint64(index);
  }
  inline void TestAllTypes::set_repeated_uint64(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value) {
    repeated_uint64_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_uint64)
  }
  inline void TestAllTypes::_internal_add_repeated_uint64(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    repeated_uint64_.Add(value);
  }
  inline void TestAllTypes::add_repeated_uint64(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    _internal_add_repeated_uint64(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_uint64)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
  TestAllTypes::_internal_repeated_uint64() const {
    return repeated_uint64_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
  TestAllTypes::repeated_uint64() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_uint64)
    return _internal_repeated_uint64();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
  TestAllTypes::_internal_mutable_repeated_uint64() {
    return &repeated_uint64_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
  TestAllTypes::mutable_repeated_uint64() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_uint64)
    return _internal_mutable_repeated_uint64();
  }
  
  // repeated sint32 repeated_sint32 = 35;
  inline int TestAllTypes::_internal_repeated_sint32_size() const {
    return repeated_sint32_.size();
  }
  inline int TestAllTypes::repeated_sint32_size() const {
    return _internal_repeated_sint32_size();
  }
  inline void TestAllTypes::clear_repeated_sint32() {
    repeated_sint32_.Clear();
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::_internal_repeated_sint32(int index) const {
    return repeated_sint32_.Get(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::repeated_sint32(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sint32)
    return _internal_repeated_sint32(index);
  }
  inline void TestAllTypes::set_repeated_sint32(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
    repeated_sint32_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sint32)
  }
  inline void TestAllTypes::_internal_add_repeated_sint32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    repeated_sint32_.Add(value);
  }
  inline void TestAllTypes::add_repeated_sint32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_add_repeated_sint32(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sint32)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
  TestAllTypes::_internal_repeated_sint32() const {
    return repeated_sint32_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
  TestAllTypes::repeated_sint32() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sint32)
    return _internal_repeated_sint32();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
  TestAllTypes::_internal_mutable_repeated_sint32() {
    return &repeated_sint32_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
  TestAllTypes::mutable_repeated_sint32() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sint32)
    return _internal_mutable_repeated_sint32();
  }
  
  // repeated sint64 repeated_sint64 = 36;
  inline int TestAllTypes::_internal_repeated_sint64_size() const {
    return repeated_sint64_.size();
  }
  inline int TestAllTypes::repeated_sint64_size() const {
    return _internal_repeated_sint64_size();
  }
  inline void TestAllTypes::clear_repeated_sint64() {
    repeated_sint64_.Clear();
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::_internal_repeated_sint64(int index) const {
    return repeated_sint64_.Get(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::repeated_sint64(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sint64)
    return _internal_repeated_sint64(index);
  }
  inline void TestAllTypes::set_repeated_sint64(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
    repeated_sint64_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sint64)
  }
  inline void TestAllTypes::_internal_add_repeated_sint64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    repeated_sint64_.Add(value);
  }
  inline void TestAllTypes::add_repeated_sint64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    _internal_add_repeated_sint64(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sint64)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
  TestAllTypes::_internal_repeated_sint64() const {
    return repeated_sint64_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
  TestAllTypes::repeated_sint64() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sint64)
    return _internal_repeated_sint64();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
  TestAllTypes::_internal_mutable_repeated_sint64() {
    return &repeated_sint64_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
  TestAllTypes::mutable_repeated_sint64() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sint64)
    return _internal_mutable_repeated_sint64();
  }
  
  // repeated fixed32 repeated_fixed32 = 37;
  inline int TestAllTypes::_internal_repeated_fixed32_size() const {
    return repeated_fixed32_.size();
  }
  inline int TestAllTypes::repeated_fixed32_size() const {
    return _internal_repeated_fixed32_size();
  }
  inline void TestAllTypes::clear_repeated_fixed32() {
    repeated_fixed32_.Clear();
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint32 TestAllTypes::_internal_repeated_fixed32(int index) const {
    return repeated_fixed32_.Get(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint32 TestAllTypes::repeated_fixed32(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_fixed32)
    return _internal_repeated_fixed32(index);
  }
  inline void TestAllTypes::set_repeated_fixed32(int index, ::PROTOBUF_NAMESPACE_ID::uint32 value) {
    repeated_fixed32_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_fixed32)
  }
  inline void TestAllTypes::_internal_add_repeated_fixed32(::PROTOBUF_NAMESPACE_ID::uint32 value) {
    repeated_fixed32_.Add(value);
  }
  inline void TestAllTypes::add_repeated_fixed32(::PROTOBUF_NAMESPACE_ID::uint32 value) {
    _internal_add_repeated_fixed32(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_fixed32)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
  TestAllTypes::_internal_repeated_fixed32() const {
    return repeated_fixed32_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >&
  TestAllTypes::repeated_fixed32() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_fixed32)
    return _internal_repeated_fixed32();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
  TestAllTypes::_internal_mutable_repeated_fixed32() {
    return &repeated_fixed32_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint32 >*
  TestAllTypes::mutable_repeated_fixed32() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_fixed32)
    return _internal_mutable_repeated_fixed32();
  }
  
  // repeated fixed64 repeated_fixed64 = 38;
  inline int TestAllTypes::_internal_repeated_fixed64_size() const {
    return repeated_fixed64_.size();
  }
  inline int TestAllTypes::repeated_fixed64_size() const {
    return _internal_repeated_fixed64_size();
  }
  inline void TestAllTypes::clear_repeated_fixed64() {
    repeated_fixed64_.Clear();
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 TestAllTypes::_internal_repeated_fixed64(int index) const {
    return repeated_fixed64_.Get(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint64 TestAllTypes::repeated_fixed64(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_fixed64)
    return _internal_repeated_fixed64(index);
  }
  inline void TestAllTypes::set_repeated_fixed64(int index, ::PROTOBUF_NAMESPACE_ID::uint64 value) {
    repeated_fixed64_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_fixed64)
  }
  inline void TestAllTypes::_internal_add_repeated_fixed64(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    repeated_fixed64_.Add(value);
  }
  inline void TestAllTypes::add_repeated_fixed64(::PROTOBUF_NAMESPACE_ID::uint64 value) {
    _internal_add_repeated_fixed64(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_fixed64)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
  TestAllTypes::_internal_repeated_fixed64() const {
    return repeated_fixed64_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >&
  TestAllTypes::repeated_fixed64() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_fixed64)
    return _internal_repeated_fixed64();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
  TestAllTypes::_internal_mutable_repeated_fixed64() {
    return &repeated_fixed64_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::uint64 >*
  TestAllTypes::mutable_repeated_fixed64() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_fixed64)
    return _internal_mutable_repeated_fixed64();
  }
  
  // repeated sfixed32 repeated_sfixed32 = 39;
  inline int TestAllTypes::_internal_repeated_sfixed32_size() const {
    return repeated_sfixed32_.size();
  }
  inline int TestAllTypes::repeated_sfixed32_size() const {
    return _internal_repeated_sfixed32_size();
  }
  inline void TestAllTypes::clear_repeated_sfixed32() {
    repeated_sfixed32_.Clear();
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::_internal_repeated_sfixed32(int index) const {
    return repeated_sfixed32_.Get(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 TestAllTypes::repeated_sfixed32(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sfixed32)
    return _internal_repeated_sfixed32(index);
  }
  inline void TestAllTypes::set_repeated_sfixed32(int index, ::PROTOBUF_NAMESPACE_ID::int32 value) {
    repeated_sfixed32_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sfixed32)
  }
  inline void TestAllTypes::_internal_add_repeated_sfixed32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    repeated_sfixed32_.Add(value);
  }
  inline void TestAllTypes::add_repeated_sfixed32(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_add_repeated_sfixed32(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sfixed32)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
  TestAllTypes::_internal_repeated_sfixed32() const {
    return repeated_sfixed32_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >&
  TestAllTypes::repeated_sfixed32() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sfixed32)
    return _internal_repeated_sfixed32();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
  TestAllTypes::_internal_mutable_repeated_sfixed32() {
    return &repeated_sfixed32_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int32 >*
  TestAllTypes::mutable_repeated_sfixed32() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sfixed32)
    return _internal_mutable_repeated_sfixed32();
  }
  
  // repeated sfixed64 repeated_sfixed64 = 40;
  inline int TestAllTypes::_internal_repeated_sfixed64_size() const {
    return repeated_sfixed64_.size();
  }
  inline int TestAllTypes::repeated_sfixed64_size() const {
    return _internal_repeated_sfixed64_size();
  }
  inline void TestAllTypes::clear_repeated_sfixed64() {
    repeated_sfixed64_.Clear();
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::_internal_repeated_sfixed64(int index) const {
    return repeated_sfixed64_.Get(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::int64 TestAllTypes::repeated_sfixed64(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sfixed64)
    return _internal_repeated_sfixed64(index);
  }
  inline void TestAllTypes::set_repeated_sfixed64(int index, ::PROTOBUF_NAMESPACE_ID::int64 value) {
    repeated_sfixed64_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sfixed64)
  }
  inline void TestAllTypes::_internal_add_repeated_sfixed64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    repeated_sfixed64_.Add(value);
  }
  inline void TestAllTypes::add_repeated_sfixed64(::PROTOBUF_NAMESPACE_ID::int64 value) {
    _internal_add_repeated_sfixed64(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sfixed64)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
  TestAllTypes::_internal_repeated_sfixed64() const {
    return repeated_sfixed64_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >&
  TestAllTypes::repeated_sfixed64() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sfixed64)
    return _internal_repeated_sfixed64();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
  TestAllTypes::_internal_mutable_repeated_sfixed64() {
    return &repeated_sfixed64_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< ::PROTOBUF_NAMESPACE_ID::int64 >*
  TestAllTypes::mutable_repeated_sfixed64() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_sfixed64)
    return _internal_mutable_repeated_sfixed64();
  }
  
  // repeated float repeated_float = 41;
  inline int TestAllTypes::_internal_repeated_float_size() const {
    return repeated_float_.size();
  }
  inline int TestAllTypes::repeated_float_size() const {
    return _internal_repeated_float_size();
  }
  inline void TestAllTypes::clear_repeated_float() {
    repeated_float_.Clear();
  }
  inline float TestAllTypes::_internal_repeated_float(int index) const {
    return repeated_float_.Get(index);
  }
  inline float TestAllTypes::repeated_float(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_float)
    return _internal_repeated_float(index);
  }
  inline void TestAllTypes::set_repeated_float(int index, float value) {
    repeated_float_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_float)
  }
  inline void TestAllTypes::_internal_add_repeated_float(float value) {
    repeated_float_.Add(value);
  }
  inline void TestAllTypes::add_repeated_float(float value) {
    _internal_add_repeated_float(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_float)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
  TestAllTypes::_internal_repeated_float() const {
    return repeated_float_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >&
  TestAllTypes::repeated_float() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_float)
    return _internal_repeated_float();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
  TestAllTypes::_internal_mutable_repeated_float() {
    return &repeated_float_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< float >*
  TestAllTypes::mutable_repeated_float() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_float)
    return _internal_mutable_repeated_float();
  }
  
  // repeated double repeated_double = 42;
  inline int TestAllTypes::_internal_repeated_double_size() const {
    return repeated_double_.size();
  }
  inline int TestAllTypes::repeated_double_size() const {
    return _internal_repeated_double_size();
  }
  inline void TestAllTypes::clear_repeated_double() {
    repeated_double_.Clear();
  }
  inline double TestAllTypes::_internal_repeated_double(int index) const {
    return repeated_double_.Get(index);
  }
  inline double TestAllTypes::repeated_double(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_double)
    return _internal_repeated_double(index);
  }
  inline void TestAllTypes::set_repeated_double(int index, double value) {
    repeated_double_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_double)
  }
  inline void TestAllTypes::_internal_add_repeated_double(double value) {
    repeated_double_.Add(value);
  }
  inline void TestAllTypes::add_repeated_double(double value) {
    _internal_add_repeated_double(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_double)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
  TestAllTypes::_internal_repeated_double() const {
    return repeated_double_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
  TestAllTypes::repeated_double() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_double)
    return _internal_repeated_double();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
  TestAllTypes::_internal_mutable_repeated_double() {
    return &repeated_double_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
  TestAllTypes::mutable_repeated_double() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_double)
    return _internal_mutable_repeated_double();
  }
  
  // repeated bool repeated_bool = 43;
  inline int TestAllTypes::_internal_repeated_bool_size() const {
    return repeated_bool_.size();
  }
  inline int TestAllTypes::repeated_bool_size() const {
    return _internal_repeated_bool_size();
  }
  inline void TestAllTypes::clear_repeated_bool() {
    repeated_bool_.Clear();
  }
  inline bool TestAllTypes::_internal_repeated_bool(int index) const {
    return repeated_bool_.Get(index);
  }
  inline bool TestAllTypes::repeated_bool(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bool)
    return _internal_repeated_bool(index);
  }
  inline void TestAllTypes::set_repeated_bool(int index, bool value) {
    repeated_bool_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bool)
  }
  inline void TestAllTypes::_internal_add_repeated_bool(bool value) {
    repeated_bool_.Add(value);
  }
  inline void TestAllTypes::add_repeated_bool(bool value) {
    _internal_add_repeated_bool(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bool)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
  TestAllTypes::_internal_repeated_bool() const {
    return repeated_bool_;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
  TestAllTypes::repeated_bool() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bool)
    return _internal_repeated_bool();
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
  TestAllTypes::_internal_mutable_repeated_bool() {
    return &repeated_bool_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
  TestAllTypes::mutable_repeated_bool() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bool)
    return _internal_mutable_repeated_bool();
  }
  
  // repeated string repeated_string = 44;
  inline int TestAllTypes::_internal_repeated_string_size() const {
    return repeated_string_.size();
  }
  inline int TestAllTypes::repeated_string_size() const {
    return _internal_repeated_string_size();
  }
  inline void TestAllTypes::clear_repeated_string() {
    repeated_string_.Clear();
  }
  inline std::string* TestAllTypes::add_repeated_string() {
    std::string* _s = _internal_add_repeated_string();
    // @@protoc_insertion_point(field_add_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
    return _s;
  }
  inline const std::string& TestAllTypes::_internal_repeated_string(int index) const {
    return repeated_string_.Get(index);
  }
  inline const std::string& TestAllTypes::repeated_string(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
    return _internal_repeated_string(index);
  }
  inline std::string* TestAllTypes::mutable_repeated_string(int index) {
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
    return repeated_string_.Mutable(index);
  }
  inline void TestAllTypes::set_repeated_string(int index, const std::string& value) {
    repeated_string_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
  }
  inline void TestAllTypes::set_repeated_string(int index, std::string&& value) {
    repeated_string_.Mutable(index)->assign(std::move(value));
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
  }
  inline void TestAllTypes::set_repeated_string(int index, const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    repeated_string_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set_char:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
  }
  inline void TestAllTypes::set_repeated_string(int index, const char* value, size_t size) {
    repeated_string_.Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_set_pointer:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
  }
  inline std::string* TestAllTypes::_internal_add_repeated_string() {
    return repeated_string_.Add();
  }
  inline void TestAllTypes::add_repeated_string(const std::string& value) {
    repeated_string_.Add()->assign(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
  }
  inline void TestAllTypes::add_repeated_string(std::string&& value) {
    repeated_string_.Add(std::move(value));
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
  }
  inline void TestAllTypes::add_repeated_string(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    repeated_string_.Add()->assign(value);
    // @@protoc_insertion_point(field_add_char:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
  }
  inline void TestAllTypes::add_repeated_string(const char* value, size_t size) {
    repeated_string_.Add()->assign(reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_add_pointer:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
  TestAllTypes::repeated_string() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
    return repeated_string_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
  TestAllTypes::mutable_repeated_string() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string)
    return &repeated_string_;
  }
  
  // repeated bytes repeated_bytes = 45;
  inline int TestAllTypes::_internal_repeated_bytes_size() const {
    return repeated_bytes_.size();
  }
  inline int TestAllTypes::repeated_bytes_size() const {
    return _internal_repeated_bytes_size();
  }
  inline void TestAllTypes::clear_repeated_bytes() {
    repeated_bytes_.Clear();
  }
  inline std::string* TestAllTypes::add_repeated_bytes() {
    std::string* _s = _internal_add_repeated_bytes();
    // @@protoc_insertion_point(field_add_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
    return _s;
  }
  inline const std::string& TestAllTypes::_internal_repeated_bytes(int index) const {
    return repeated_bytes_.Get(index);
  }
  inline const std::string& TestAllTypes::repeated_bytes(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
    return _internal_repeated_bytes(index);
  }
  inline std::string* TestAllTypes::mutable_repeated_bytes(int index) {
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
    return repeated_bytes_.Mutable(index);
  }
  inline void TestAllTypes::set_repeated_bytes(int index, const std::string& value) {
    repeated_bytes_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
  }
  inline void TestAllTypes::set_repeated_bytes(int index, std::string&& value) {
    repeated_bytes_.Mutable(index)->assign(std::move(value));
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
  }
  inline void TestAllTypes::set_repeated_bytes(int index, const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    repeated_bytes_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set_char:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
  }
  inline void TestAllTypes::set_repeated_bytes(int index, const void* value, size_t size) {
    repeated_bytes_.Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_set_pointer:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
  }
  inline std::string* TestAllTypes::_internal_add_repeated_bytes() {
    return repeated_bytes_.Add();
  }
  inline void TestAllTypes::add_repeated_bytes(const std::string& value) {
    repeated_bytes_.Add()->assign(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
  }
  inline void TestAllTypes::add_repeated_bytes(std::string&& value) {
    repeated_bytes_.Add(std::move(value));
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
  }
  inline void TestAllTypes::add_repeated_bytes(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    repeated_bytes_.Add()->assign(value);
    // @@protoc_insertion_point(field_add_char:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
  }
  inline void TestAllTypes::add_repeated_bytes(const void* value, size_t size) {
    repeated_bytes_.Add()->assign(reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_add_pointer:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
  TestAllTypes::repeated_bytes() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
    return repeated_bytes_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
  TestAllTypes::mutable_repeated_bytes() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_bytes)
    return &repeated_bytes_;
  }
  
  // repeated .proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage repeated_nested_message = 48;
  inline int TestAllTypes::_internal_repeated_nested_message_size() const {
    return repeated_nested_message_.size();
  }
  inline int TestAllTypes::repeated_nested_message_size() const {
    return _internal_repeated_nested_message_size();
  }
  inline void TestAllTypes::clear_repeated_nested_message() {
    repeated_nested_message_.Clear();
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::mutable_repeated_nested_message(int index) {
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_nested_message)
    return repeated_nested_message_.Mutable(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage >*
  TestAllTypes::mutable_repeated_nested_message() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_nested_message)
    return &repeated_nested_message_;
  }
  inline const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& TestAllTypes::_internal_repeated_nested_message(int index) const {
    return repeated_nested_message_.Get(index);
  }
  inline const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& TestAllTypes::repeated_nested_message(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_nested_message)
    return _internal_repeated_nested_message(index);
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::_internal_add_repeated_nested_message() {
    return repeated_nested_message_.Add();
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::add_repeated_nested_message() {
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* _add = _internal_add_repeated_nested_message();
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_nested_message)
    return _add;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage >&
  TestAllTypes::repeated_nested_message() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_nested_message)
    return repeated_nested_message_;
  }
  
  // repeated .proto2_nofieldpresence_unittest.ForeignMessage repeated_foreign_message = 49;
  inline int TestAllTypes::_internal_repeated_foreign_message_size() const {
    return repeated_foreign_message_.size();
  }
  inline int TestAllTypes::repeated_foreign_message_size() const {
    return _internal_repeated_foreign_message_size();
  }
  inline void TestAllTypes::clear_repeated_foreign_message() {
    repeated_foreign_message_.Clear();
  }
  inline ::proto2_nofieldpresence_unittest::ForeignMessage* TestAllTypes::mutable_repeated_foreign_message(int index) {
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_foreign_message)
    return repeated_foreign_message_.Mutable(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::ForeignMessage >*
  TestAllTypes::mutable_repeated_foreign_message() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_foreign_message)
    return &repeated_foreign_message_;
  }
  inline const ::proto2_nofieldpresence_unittest::ForeignMessage& TestAllTypes::_internal_repeated_foreign_message(int index) const {
    return repeated_foreign_message_.Get(index);
  }
  inline const ::proto2_nofieldpresence_unittest::ForeignMessage& TestAllTypes::repeated_foreign_message(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_foreign_message)
    return _internal_repeated_foreign_message(index);
  }
  inline ::proto2_nofieldpresence_unittest::ForeignMessage* TestAllTypes::_internal_add_repeated_foreign_message() {
    return repeated_foreign_message_.Add();
  }
  inline ::proto2_nofieldpresence_unittest::ForeignMessage* TestAllTypes::add_repeated_foreign_message() {
    ::proto2_nofieldpresence_unittest::ForeignMessage* _add = _internal_add_repeated_foreign_message();
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_foreign_message)
    return _add;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::ForeignMessage >&
  TestAllTypes::repeated_foreign_message() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_foreign_message)
    return repeated_foreign_message_;
  }
  
  // repeated .protobuf_unittest.TestAllTypes repeated_proto2_message = 50;
  inline int TestAllTypes::_internal_repeated_proto2_message_size() const {
    return repeated_proto2_message_.size();
  }
  inline int TestAllTypes::repeated_proto2_message_size() const {
    return _internal_repeated_proto2_message_size();
  }
  inline ::protobuf_unittest::TestAllTypes* TestAllTypes::mutable_repeated_proto2_message(int index) {
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_proto2_message)
    return repeated_proto2_message_.Mutable(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >*
  TestAllTypes::mutable_repeated_proto2_message() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_proto2_message)
    return &repeated_proto2_message_;
  }
  inline const ::protobuf_unittest::TestAllTypes& TestAllTypes::_internal_repeated_proto2_message(int index) const {
    return repeated_proto2_message_.Get(index);
  }
  inline const ::protobuf_unittest::TestAllTypes& TestAllTypes::repeated_proto2_message(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_proto2_message)
    return _internal_repeated_proto2_message(index);
  }
  inline ::protobuf_unittest::TestAllTypes* TestAllTypes::_internal_add_repeated_proto2_message() {
    return repeated_proto2_message_.Add();
  }
  inline ::protobuf_unittest::TestAllTypes* TestAllTypes::add_repeated_proto2_message() {
    ::protobuf_unittest::TestAllTypes* _add = _internal_add_repeated_proto2_message();
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_proto2_message)
    return _add;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::protobuf_unittest::TestAllTypes >&
  TestAllTypes::repeated_proto2_message() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_proto2_message)
    return repeated_proto2_message_;
  }
  
  // repeated .proto2_nofieldpresence_unittest.TestAllTypes.NestedEnum repeated_nested_enum = 51;
  inline int TestAllTypes::_internal_repeated_nested_enum_size() const {
    return repeated_nested_enum_.size();
  }
  inline int TestAllTypes::repeated_nested_enum_size() const {
    return _internal_repeated_nested_enum_size();
  }
  inline void TestAllTypes::clear_repeated_nested_enum() {
    repeated_nested_enum_.Clear();
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum TestAllTypes::_internal_repeated_nested_enum(int index) const {
    return static_cast< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum >(repeated_nested_enum_.Get(index));
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum TestAllTypes::repeated_nested_enum(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_nested_enum)
    return _internal_repeated_nested_enum(index);
  }
  inline void TestAllTypes::set_repeated_nested_enum(int index, ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value) {
    repeated_nested_enum_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_nested_enum)
  }
  inline void TestAllTypes::_internal_add_repeated_nested_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value) {
    repeated_nested_enum_.Add(value);
  }
  inline void TestAllTypes::add_repeated_nested_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value) {
    _internal_add_repeated_nested_enum(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_nested_enum)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
  TestAllTypes::repeated_nested_enum() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_nested_enum)
    return repeated_nested_enum_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
  TestAllTypes::_internal_mutable_repeated_nested_enum() {
    return &repeated_nested_enum_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
  TestAllTypes::mutable_repeated_nested_enum() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_nested_enum)
    return _internal_mutable_repeated_nested_enum();
  }
  
  // repeated .proto2_nofieldpresence_unittest.ForeignEnum repeated_foreign_enum = 52;
  inline int TestAllTypes::_internal_repeated_foreign_enum_size() const {
    return repeated_foreign_enum_.size();
  }
  inline int TestAllTypes::repeated_foreign_enum_size() const {
    return _internal_repeated_foreign_enum_size();
  }
  inline void TestAllTypes::clear_repeated_foreign_enum() {
    repeated_foreign_enum_.Clear();
  }
  inline ::proto2_nofieldpresence_unittest::ForeignEnum TestAllTypes::_internal_repeated_foreign_enum(int index) const {
    return static_cast< ::proto2_nofieldpresence_unittest::ForeignEnum >(repeated_foreign_enum_.Get(index));
  }
  inline ::proto2_nofieldpresence_unittest::ForeignEnum TestAllTypes::repeated_foreign_enum(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_foreign_enum)
    return _internal_repeated_foreign_enum(index);
  }
  inline void TestAllTypes::set_repeated_foreign_enum(int index, ::proto2_nofieldpresence_unittest::ForeignEnum value) {
    repeated_foreign_enum_.Set(index, value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_foreign_enum)
  }
  inline void TestAllTypes::_internal_add_repeated_foreign_enum(::proto2_nofieldpresence_unittest::ForeignEnum value) {
    repeated_foreign_enum_.Add(value);
  }
  inline void TestAllTypes::add_repeated_foreign_enum(::proto2_nofieldpresence_unittest::ForeignEnum value) {
    _internal_add_repeated_foreign_enum(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_foreign_enum)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
  TestAllTypes::repeated_foreign_enum() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_foreign_enum)
    return repeated_foreign_enum_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
  TestAllTypes::_internal_mutable_repeated_foreign_enum() {
    return &repeated_foreign_enum_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
  TestAllTypes::mutable_repeated_foreign_enum() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_foreign_enum)
    return _internal_mutable_repeated_foreign_enum();
  }
  
  // repeated string repeated_string_piece = 54 [ctype = STRING_PIECE];
  inline int TestAllTypes::_internal_repeated_string_piece_size() const {
    return repeated_string_piece_.size();
  }
  inline int TestAllTypes::repeated_string_piece_size() const {
    return _internal_repeated_string_piece_size();
  }
  inline void TestAllTypes::clear_repeated_string_piece() {
    repeated_string_piece_.Clear();
  }
  inline std::string* TestAllTypes::add_repeated_string_piece() {
    std::string* _s = _internal_add_repeated_string_piece();
    // @@protoc_insertion_point(field_add_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
    return _s;
  }
  inline const std::string& TestAllTypes::_internal_repeated_string_piece(int index) const {
    return repeated_string_piece_.Get(index);
  }
  inline const std::string& TestAllTypes::repeated_string_piece(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
    return _internal_repeated_string_piece(index);
  }
  inline std::string* TestAllTypes::mutable_repeated_string_piece(int index) {
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
    return repeated_string_piece_.Mutable(index);
  }
  inline void TestAllTypes::set_repeated_string_piece(int index, const std::string& value) {
    repeated_string_piece_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
  }
  inline void TestAllTypes::set_repeated_string_piece(int index, std::string&& value) {
    repeated_string_piece_.Mutable(index)->assign(std::move(value));
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
  }
  inline void TestAllTypes::set_repeated_string_piece(int index, const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    repeated_string_piece_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set_char:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
  }
  inline void TestAllTypes::set_repeated_string_piece(int index, const char* value, size_t size) {
    repeated_string_piece_.Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_set_pointer:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
  }
  inline std::string* TestAllTypes::_internal_add_repeated_string_piece() {
    return repeated_string_piece_.Add();
  }
  inline void TestAllTypes::add_repeated_string_piece(const std::string& value) {
    repeated_string_piece_.Add()->assign(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
  }
  inline void TestAllTypes::add_repeated_string_piece(std::string&& value) {
    repeated_string_piece_.Add(std::move(value));
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
  }
  inline void TestAllTypes::add_repeated_string_piece(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    repeated_string_piece_.Add()->assign(value);
    // @@protoc_insertion_point(field_add_char:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
  }
  inline void TestAllTypes::add_repeated_string_piece(const char* value, size_t size) {
    repeated_string_piece_.Add()->assign(reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_add_pointer:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
  TestAllTypes::repeated_string_piece() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
    return repeated_string_piece_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
  TestAllTypes::mutable_repeated_string_piece() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_string_piece)
    return &repeated_string_piece_;
  }
  
  // repeated string repeated_cord = 55 [ctype = CORD];
  inline int TestAllTypes::_internal_repeated_cord_size() const {
    return repeated_cord_.size();
  }
  inline int TestAllTypes::repeated_cord_size() const {
    return _internal_repeated_cord_size();
  }
  inline void TestAllTypes::clear_repeated_cord() {
    repeated_cord_.Clear();
  }
  inline std::string* TestAllTypes::add_repeated_cord() {
    std::string* _s = _internal_add_repeated_cord();
    // @@protoc_insertion_point(field_add_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
    return _s;
  }
  inline const std::string& TestAllTypes::_internal_repeated_cord(int index) const {
    return repeated_cord_.Get(index);
  }
  inline const std::string& TestAllTypes::repeated_cord(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
    return _internal_repeated_cord(index);
  }
  inline std::string* TestAllTypes::mutable_repeated_cord(int index) {
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
    return repeated_cord_.Mutable(index);
  }
  inline void TestAllTypes::set_repeated_cord(int index, const std::string& value) {
    repeated_cord_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
  }
  inline void TestAllTypes::set_repeated_cord(int index, std::string&& value) {
    repeated_cord_.Mutable(index)->assign(std::move(value));
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
  }
  inline void TestAllTypes::set_repeated_cord(int index, const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    repeated_cord_.Mutable(index)->assign(value);
    // @@protoc_insertion_point(field_set_char:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
  }
  inline void TestAllTypes::set_repeated_cord(int index, const char* value, size_t size) {
    repeated_cord_.Mutable(index)->assign(
      reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_set_pointer:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
  }
  inline std::string* TestAllTypes::_internal_add_repeated_cord() {
    return repeated_cord_.Add();
  }
  inline void TestAllTypes::add_repeated_cord(const std::string& value) {
    repeated_cord_.Add()->assign(value);
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
  }
  inline void TestAllTypes::add_repeated_cord(std::string&& value) {
    repeated_cord_.Add(std::move(value));
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
  }
  inline void TestAllTypes::add_repeated_cord(const char* value) {
    GOOGLE_DCHECK(value != nullptr);
    repeated_cord_.Add()->assign(value);
    // @@protoc_insertion_point(field_add_char:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
  }
  inline void TestAllTypes::add_repeated_cord(const char* value, size_t size) {
    repeated_cord_.Add()->assign(reinterpret_cast<const char*>(value), size);
    // @@protoc_insertion_point(field_add_pointer:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
  TestAllTypes::repeated_cord() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
    return repeated_cord_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
  TestAllTypes::mutable_repeated_cord() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_cord)
    return &repeated_cord_;
  }
  
  // repeated .proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage repeated_lazy_message = 57 [lazy = true];
  inline int TestAllTypes::_internal_repeated_lazy_message_size() const {
    return repeated_lazy_message_.size();
  }
  inline int TestAllTypes::repeated_lazy_message_size() const {
    return _internal_repeated_lazy_message_size();
  }
  inline void TestAllTypes::clear_repeated_lazy_message() {
    repeated_lazy_message_.Clear();
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::mutable_repeated_lazy_message(int index) {
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.repeated_lazy_message)
    return repeated_lazy_message_.Mutable(index);
  }
  inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage >*
  TestAllTypes::mutable_repeated_lazy_message() {
    // @@protoc_insertion_point(field_mutable_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_lazy_message)
    return &repeated_lazy_message_;
  }
  inline const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& TestAllTypes::_internal_repeated_lazy_message(int index) const {
    return repeated_lazy_message_.Get(index);
  }
  inline const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& TestAllTypes::repeated_lazy_message(int index) const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.repeated_lazy_message)
    return _internal_repeated_lazy_message(index);
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::_internal_add_repeated_lazy_message() {
    return repeated_lazy_message_.Add();
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::add_repeated_lazy_message() {
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* _add = _internal_add_repeated_lazy_message();
    // @@protoc_insertion_point(field_add:proto2_nofieldpresence_unittest.TestAllTypes.repeated_lazy_message)
    return _add;
  }
  inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage >&
  TestAllTypes::repeated_lazy_message() const {
    // @@protoc_insertion_point(field_list:proto2_nofieldpresence_unittest.TestAllTypes.repeated_lazy_message)
    return repeated_lazy_message_;
  }
  
  // uint32 oneof_uint32 = 111;
  inline bool TestAllTypes::_internal_has_oneof_uint32() const {
    return oneof_field_case() == kOneofUint32;
  }
  inline bool TestAllTypes::has_oneof_uint32() const {
    return _internal_has_oneof_uint32();
  }
  inline void TestAllTypes::set_has_oneof_uint32() {
    _oneof_case_[0] = kOneofUint32;
  }
  inline void TestAllTypes::clear_oneof_uint32() {
    if (_internal_has_oneof_uint32()) {
      oneof_field_.oneof_uint32_ = 0u;
      clear_has_oneof_field();
    }
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint32 TestAllTypes::_internal_oneof_uint32() const {
    if (_internal_has_oneof_uint32()) {
      return oneof_field_.oneof_uint32_;
    }
    return 0u;
  }
  inline void TestAllTypes::_internal_set_oneof_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value) {
    if (!_internal_has_oneof_uint32()) {
      clear_oneof_field();
      set_has_oneof_uint32();
    }
    oneof_field_.oneof_uint32_ = value;
  }
  inline ::PROTOBUF_NAMESPACE_ID::uint32 TestAllTypes::oneof_uint32() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.oneof_uint32)
    return _internal_oneof_uint32();
  }
  inline void TestAllTypes::set_oneof_uint32(::PROTOBUF_NAMESPACE_ID::uint32 value) {
    _internal_set_oneof_uint32(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.oneof_uint32)
  }
  
  // .proto2_nofieldpresence_unittest.TestAllTypes.NestedMessage oneof_nested_message = 112;
  inline bool TestAllTypes::_internal_has_oneof_nested_message() const {
    return oneof_field_case() == kOneofNestedMessage;
  }
  inline bool TestAllTypes::has_oneof_nested_message() const {
    return _internal_has_oneof_nested_message();
  }
  inline void TestAllTypes::set_has_oneof_nested_message() {
    _oneof_case_[0] = kOneofNestedMessage;
  }
  inline void TestAllTypes::clear_oneof_nested_message() {
    if (_internal_has_oneof_nested_message()) {
      if (GetArenaForAllocation() == nullptr) {
        delete oneof_field_.oneof_nested_message_;
      }
      clear_has_oneof_field();
    }
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::release_oneof_nested_message() {
    // @@protoc_insertion_point(field_release:proto2_nofieldpresence_unittest.TestAllTypes.oneof_nested_message)
    if (_internal_has_oneof_nested_message()) {
      clear_has_oneof_field();
        ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* temp = oneof_field_.oneof_nested_message_;
      if (GetArenaForAllocation() != nullptr) {
        temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
      }
      oneof_field_.oneof_nested_message_ = nullptr;
      return temp;
    } else {
      return nullptr;
    }
  }
  inline const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& TestAllTypes::_internal_oneof_nested_message() const {
    return _internal_has_oneof_nested_message()
        ? *oneof_field_.oneof_nested_message_
        : reinterpret_cast< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage&>(::proto2_nofieldpresence_unittest::_TestAllTypes_NestedMessage_default_instance_);
  }
  inline const ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage& TestAllTypes::oneof_nested_message() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.oneof_nested_message)
    return _internal_oneof_nested_message();
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::unsafe_arena_release_oneof_nested_message() {
    // @@protoc_insertion_point(field_unsafe_arena_release:proto2_nofieldpresence_unittest.TestAllTypes.oneof_nested_message)
    if (_internal_has_oneof_nested_message()) {
      clear_has_oneof_field();
      ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* temp = oneof_field_.oneof_nested_message_;
      oneof_field_.oneof_nested_message_ = nullptr;
      return temp;
    } else {
      return nullptr;
    }
  }
  inline void TestAllTypes::unsafe_arena_set_allocated_oneof_nested_message(::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* oneof_nested_message) {
    clear_oneof_field();
    if (oneof_nested_message) {
      set_has_oneof_nested_message();
      oneof_field_.oneof_nested_message_ = oneof_nested_message;
    }
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.oneof_nested_message)
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::_internal_mutable_oneof_nested_message() {
    if (!_internal_has_oneof_nested_message()) {
      clear_oneof_field();
      set_has_oneof_nested_message();
      oneof_field_.oneof_nested_message_ = CreateMaybeMessage< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage >(GetArenaForAllocation());
    }
    return oneof_field_.oneof_nested_message_;
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* TestAllTypes::mutable_oneof_nested_message() {
    ::proto2_nofieldpresence_unittest::TestAllTypes_NestedMessage* _msg = _internal_mutable_oneof_nested_message();
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.oneof_nested_message)
    return _msg;
  }
  
  // string oneof_string = 113;
  inline bool TestAllTypes::_internal_has_oneof_string() const {
    return oneof_field_case() == kOneofString;
  }
  inline bool TestAllTypes::has_oneof_string() const {
    return _internal_has_oneof_string();
  }
  inline void TestAllTypes::set_has_oneof_string() {
    _oneof_case_[0] = kOneofString;
  }
  inline void TestAllTypes::clear_oneof_string() {
    if (_internal_has_oneof_string()) {
      oneof_field_.oneof_string_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
      clear_has_oneof_field();
    }
  }
  inline const std::string& TestAllTypes::oneof_string() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.oneof_string)
    return _internal_oneof_string();
  }
  template <typename ArgT0, typename... ArgT>
  inline void TestAllTypes::set_oneof_string(ArgT0&& arg0, ArgT... args) {
    if (!_internal_has_oneof_string()) {
      clear_oneof_field();
      set_has_oneof_string();
      oneof_field_.oneof_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
    }
    oneof_field_.oneof_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.oneof_string)
  }
  inline std::string* TestAllTypes::mutable_oneof_string() {
    std::string* _s = _internal_mutable_oneof_string();
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestAllTypes.oneof_string)
    return _s;
  }
  inline const std::string& TestAllTypes::_internal_oneof_string() const {
    if (_internal_has_oneof_string()) {
      return oneof_field_.oneof_string_.Get();
    }
    return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
  }
  inline void TestAllTypes::_internal_set_oneof_string(const std::string& value) {
    if (!_internal_has_oneof_string()) {
      clear_oneof_field();
      set_has_oneof_string();
      oneof_field_.oneof_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
    }
    oneof_field_.oneof_string_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
  }
  inline std::string* TestAllTypes::_internal_mutable_oneof_string() {
    if (!_internal_has_oneof_string()) {
      clear_oneof_field();
      set_has_oneof_string();
      oneof_field_.oneof_string_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
    }
    return oneof_field_.oneof_string_.Mutable(
        ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
  }
  inline std::string* TestAllTypes::release_oneof_string() {
    // @@protoc_insertion_point(field_release:proto2_nofieldpresence_unittest.TestAllTypes.oneof_string)
    if (_internal_has_oneof_string()) {
      clear_has_oneof_field();
      return oneof_field_.oneof_string_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
    } else {
      return nullptr;
    }
  }
  inline void TestAllTypes::set_allocated_oneof_string(std::string* oneof_string) {
    if (has_oneof_field()) {
      clear_oneof_field();
    }
    if (oneof_string != nullptr) {
      set_has_oneof_string();
      oneof_field_.oneof_string_.UnsafeSetDefault(oneof_string);
      ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
      if (arena != nullptr) {
        arena->Own(oneof_string);
      }
    }
    // @@protoc_insertion_point(field_set_allocated:proto2_nofieldpresence_unittest.TestAllTypes.oneof_string)
  }
  
  // .proto2_nofieldpresence_unittest.TestAllTypes.NestedEnum oneof_enum = 114;
  inline bool TestAllTypes::_internal_has_oneof_enum() const {
    return oneof_field_case() == kOneofEnum;
  }
  inline bool TestAllTypes::has_oneof_enum() const {
    return _internal_has_oneof_enum();
  }
  inline void TestAllTypes::set_has_oneof_enum() {
    _oneof_case_[0] = kOneofEnum;
  }
  inline void TestAllTypes::clear_oneof_enum() {
    if (_internal_has_oneof_enum()) {
      oneof_field_.oneof_enum_ = 0;
      clear_has_oneof_field();
    }
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum TestAllTypes::_internal_oneof_enum() const {
    if (_internal_has_oneof_enum()) {
      return static_cast< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum >(oneof_field_.oneof_enum_);
    }
    return static_cast< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum >(0);
  }
  inline ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum TestAllTypes::oneof_enum() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestAllTypes.oneof_enum)
    return _internal_oneof_enum();
  }
  inline void TestAllTypes::_internal_set_oneof_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value) {
    if (!_internal_has_oneof_enum()) {
      clear_oneof_field();
      set_has_oneof_enum();
    }
    oneof_field_.oneof_enum_ = value;
  }
  inline void TestAllTypes::set_oneof_enum(::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum value) {
    _internal_set_oneof_enum(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.TestAllTypes.oneof_enum)
  }
  
  inline bool TestAllTypes::has_oneof_field() const {
    return oneof_field_case() != ONEOF_FIELD_NOT_SET;
  }
  inline void TestAllTypes::clear_has_oneof_field() {
    _oneof_case_[0] = ONEOF_FIELD_NOT_SET;
  }
  inline TestAllTypes::OneofFieldCase TestAllTypes::oneof_field_case() const {
    return TestAllTypes::OneofFieldCase(_oneof_case_[0]);
  }
  // -------------------------------------------------------------------
  
  // TestProto2Required
  
  // .protobuf_unittest.TestRequired proto2 = 1;
  inline bool TestProto2Required::_internal_has_proto2() const {
    return this != internal_default_instance() && proto2_ != nullptr;
  }
  inline bool TestProto2Required::has_proto2() const {
    return _internal_has_proto2();
  }
  inline const ::protobuf_unittest::TestRequired& TestProto2Required::_internal_proto2() const {
    const ::protobuf_unittest::TestRequired* p = proto2_;
    return p != nullptr ? *p : reinterpret_cast<const ::protobuf_unittest::TestRequired&>(
        ::protobuf_unittest::_TestRequired_default_instance_);
  }
  inline const ::protobuf_unittest::TestRequired& TestProto2Required::proto2() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.TestProto2Required.proto2)
    return _internal_proto2();
  }
  inline void TestProto2Required::unsafe_arena_set_allocated_proto2(
      ::protobuf_unittest::TestRequired* proto2) {
    if (GetArenaForAllocation() == nullptr) {
      delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(proto2_);
    }
    proto2_ = proto2;
    if (proto2) {
      
    } else {
      
    }
    // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto2_nofieldpresence_unittest.TestProto2Required.proto2)
  }
  inline ::protobuf_unittest::TestRequired* TestProto2Required::release_proto2() {
    
    ::protobuf_unittest::TestRequired* temp = proto2_;
    proto2_ = nullptr;
  #ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
    auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    if (GetArenaForAllocation() == nullptr) { delete old; }
  #else  // PROTOBUF_FORCE_COPY_IN_RELEASE
    if (GetArenaForAllocation() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
  #endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
    return temp;
  }
  inline ::protobuf_unittest::TestRequired* TestProto2Required::unsafe_arena_release_proto2() {
    // @@protoc_insertion_point(field_release:proto2_nofieldpresence_unittest.TestProto2Required.proto2)
    
    ::protobuf_unittest::TestRequired* temp = proto2_;
    proto2_ = nullptr;
    return temp;
  }
  inline ::protobuf_unittest::TestRequired* TestProto2Required::_internal_mutable_proto2() {
    
    if (proto2_ == nullptr) {
      auto* p = CreateMaybeMessage<::protobuf_unittest::TestRequired>(GetArenaForAllocation());
      proto2_ = p;
    }
    return proto2_;
  }
  inline ::protobuf_unittest::TestRequired* TestProto2Required::mutable_proto2() {
    ::protobuf_unittest::TestRequired* _msg = _internal_mutable_proto2();
    // @@protoc_insertion_point(field_mutable:proto2_nofieldpresence_unittest.TestProto2Required.proto2)
    return _msg;
  }
  inline void TestProto2Required::set_allocated_proto2(::protobuf_unittest::TestRequired* proto2) {
    ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
    if (message_arena == nullptr) {
      delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(proto2_);
    }
    if (proto2) {
      ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
          ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
              ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
                  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(proto2));
      if (message_arena != submessage_arena) {
        proto2 = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
            message_arena, proto2, submessage_arena);
      }
      
    } else {
      
    }
    proto2_ = proto2;
    // @@protoc_insertion_point(field_set_allocated:proto2_nofieldpresence_unittest.TestProto2Required.proto2)
  }
  
  // -------------------------------------------------------------------
  
  // ForeignMessage
  
  // int32 c = 1;
  inline void ForeignMessage::clear_c() {
    c_ = 0;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 ForeignMessage::_internal_c() const {
    return c_;
  }
  inline ::PROTOBUF_NAMESPACE_ID::int32 ForeignMessage::c() const {
    // @@protoc_insertion_point(field_get:proto2_nofieldpresence_unittest.ForeignMessage.c)
    return _internal_c();
  }
  inline void ForeignMessage::_internal_set_c(::PROTOBUF_NAMESPACE_ID::int32 value) {
    
    c_ = value;
  }
  inline void ForeignMessage::set_c(::PROTOBUF_NAMESPACE_ID::int32 value) {
    _internal_set_c(value);
    // @@protoc_insertion_point(field_set:proto2_nofieldpresence_unittest.ForeignMessage.c)
  }
  
  #ifdef __GNUC__
    #pragma GCC diagnostic pop
  #endif  // __GNUC__
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  // -------------------------------------------------------------------
  
  
  // @@protoc_insertion_point(namespace_scope)
  
  }  // namespace proto2_nofieldpresence_unittest
  
  PROTOBUF_NAMESPACE_OPEN
  
  template <> struct is_proto_enum< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum>() {
    return ::proto2_nofieldpresence_unittest::TestAllTypes_NestedEnum_descriptor();
  }
  template <> struct is_proto_enum< ::proto2_nofieldpresence_unittest::ForeignEnum> : ::std::true_type {};
  template <>
  inline const EnumDescriptor* GetEnumDescriptor< ::proto2_nofieldpresence_unittest::ForeignEnum>() {
    return ::proto2_nofieldpresence_unittest::ForeignEnum_descriptor();
  }
  
  PROTOBUF_NAMESPACE_CLOSE
  
  // @@protoc_insertion_point(global_scope)
  
  #include <google/protobuf/port_undef.inc>
  #endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_google_2fprotobuf_2funittest_5fno_5ffield_5fpresence_2eproto
  