// Generated by the protocol buffer compiler.  DO NOT EDIT!

// source: lua_grammar.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_lua_5fgrammar_2eproto

#define GOOGLE_PROTOBUF_INCLUDED_lua_5fgrammar_2eproto

#include <limits>

#include <string>

#include <google/protobuf/port_def.inc>

#if PROTOBUF_VERSION < 3021000

#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 3021007 < 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_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/unknown_field_set.h>

// @@protoc_insertion_point(includes)

#include <google/protobuf/port_def.inc>

#define PROTOBUF_INTERNAL_EXPORT_lua_5fgrammar_2eproto

PROTOBUF_NAMESPACE_OPEN

namespace internal {

class AnyMetadata;

}  // namespace internal

PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.

struct TableStruct_lua_5fgrammar_2eproto {

  static const uint32_t offsets[];

};

extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_lua_5fgrammar_2eproto;

namespace lua_grammar {

class AssignmentList;

struct AssignmentListDefaultTypeInternal;

extern AssignmentListDefaultTypeInternal _AssignmentList_default_instance_;

class AssignmentList_VariableList;

struct AssignmentList_VariableListDefaultTypeInternal;

extern AssignmentList_VariableListDefaultTypeInternal _AssignmentList_VariableList_default_instance_;

class BinaryOperator;

struct BinaryOperatorDefaultTypeInternal;

extern BinaryOperatorDefaultTypeInternal _BinaryOperator_default_instance_;

class Block;

struct BlockDefaultTypeInternal;

extern BlockDefaultTypeInternal _Block_default_instance_;

class Chunk;

struct ChunkDefaultTypeInternal;

extern ChunkDefaultTypeInternal _Chunk_default_instance_;

class DoBlock;

struct DoBlockDefaultTypeInternal;

extern DoBlockDefaultTypeInternal _DoBlock_default_instance_;

class Expression;

struct ExpressionDefaultTypeInternal;

extern ExpressionDefaultTypeInternal _Expression_default_instance_;

class ExpressionList;

struct ExpressionListDefaultTypeInternal;

extern ExpressionListDefaultTypeInternal _ExpressionList_default_instance_;

class Expression_AnonFunc;

struct Expression_AnonFuncDefaultTypeInternal;

extern Expression_AnonFuncDefaultTypeInternal _Expression_AnonFunc_default_instance_;

class Expression_ExpBinaryOpExp;

struct Expression_ExpBinaryOpExpDefaultTypeInternal;

extern Expression_ExpBinaryOpExpDefaultTypeInternal _Expression_ExpBinaryOpExp_default_instance_;

class Expression_UnaryOpExp;

struct Expression_UnaryOpExpDefaultTypeInternal;

extern Expression_UnaryOpExpDefaultTypeInternal _Expression_UnaryOpExp_default_instance_;

class Field;

struct FieldDefaultTypeInternal;

extern FieldDefaultTypeInternal _Field_default_instance_;

class FieldList;

struct FieldListDefaultTypeInternal;

extern FieldListDefaultTypeInternal _FieldList_default_instance_;

class FieldList_FieldWithFieldSep;

struct FieldList_FieldWithFieldSepDefaultTypeInternal;

extern FieldList_FieldWithFieldSepDefaultTypeInternal _FieldList_FieldWithFieldSep_default_instance_;

class FieldSep;

struct FieldSepDefaultTypeInternal;

extern FieldSepDefaultTypeInternal _FieldSep_default_instance_;

class Field_ExpressionAssignment;

struct Field_ExpressionAssignmentDefaultTypeInternal;

extern Field_ExpressionAssignmentDefaultTypeInternal _Field_ExpressionAssignment_default_instance_;

class Field_NameAssignment;

struct Field_NameAssignmentDefaultTypeInternal;

extern Field_NameAssignmentDefaultTypeInternal _Field_NameAssignment_default_instance_;

class ForCycleList;

struct ForCycleListDefaultTypeInternal;

extern ForCycleListDefaultTypeInternal _ForCycleList_default_instance_;

class ForCycleName;

struct ForCycleNameDefaultTypeInternal;

extern ForCycleNameDefaultTypeInternal _ForCycleName_default_instance_;

class FuncBody;

struct FuncBodyDefaultTypeInternal;

extern FuncBodyDefaultTypeInternal _FuncBody_default_instance_;

class FuncBody_NameListWithEllipsis;

struct FuncBody_NameListWithEllipsisDefaultTypeInternal;

extern FuncBody_NameListWithEllipsisDefaultTypeInternal _FuncBody_NameListWithEllipsis_default_instance_;

class FuncBody_ParList;

struct FuncBody_ParListDefaultTypeInternal;

extern FuncBody_ParListDefaultTypeInternal _FuncBody_ParList_default_instance_;

class Function;

struct FunctionDefaultTypeInternal;

extern FunctionDefaultTypeInternal _Function_default_instance_;

class FunctionCall;

struct FunctionCallDefaultTypeInternal;

extern FunctionCallDefaultTypeInternal _FunctionCall_default_instance_;

class FunctionCall_Args;

struct FunctionCall_ArgsDefaultTypeInternal;

extern FunctionCall_ArgsDefaultTypeInternal _FunctionCall_Args_default_instance_;

class FunctionCall_PrefixArgs;

struct FunctionCall_PrefixArgsDefaultTypeInternal;

extern FunctionCall_PrefixArgsDefaultTypeInternal _FunctionCall_PrefixArgs_default_instance_;

class FunctionCall_PrefixNamedArgs;

struct FunctionCall_PrefixNamedArgsDefaultTypeInternal;

extern FunctionCall_PrefixNamedArgsDefaultTypeInternal _FunctionCall_PrefixNamedArgs_default_instance_;

class Function_FuncName;

struct Function_FuncNameDefaultTypeInternal;

extern Function_FuncNameDefaultTypeInternal _Function_FuncName_default_instance_;

class IfStatement;

struct IfStatementDefaultTypeInternal;

extern IfStatementDefaultTypeInternal _IfStatement_default_instance_;

class IfStatement_ElseIfBlock;

struct IfStatement_ElseIfBlockDefaultTypeInternal;

extern IfStatement_ElseIfBlockDefaultTypeInternal _IfStatement_ElseIfBlock_default_instance_;

class LastStatement;

struct LastStatementDefaultTypeInternal;

extern LastStatementDefaultTypeInternal _LastStatement_default_instance_;

class LastStatement_ReturnOptionalExpressionList;

struct LastStatement_ReturnOptionalExpressionListDefaultTypeInternal;

extern LastStatement_ReturnOptionalExpressionListDefaultTypeInternal _LastStatement_ReturnOptionalExpressionList_default_instance_;

class LocalFunc;

struct LocalFuncDefaultTypeInternal;

extern LocalFuncDefaultTypeInternal _LocalFunc_default_instance_;

class LocalNames;

struct LocalNamesDefaultTypeInternal;

extern LocalNamesDefaultTypeInternal _LocalNames_default_instance_;

class Name;

struct NameDefaultTypeInternal;

extern NameDefaultTypeInternal _Name_default_instance_;

class NameList;

struct NameListDefaultTypeInternal;

extern NameListDefaultTypeInternal _NameList_default_instance_;

class OptionalExpressionList;

struct OptionalExpressionListDefaultTypeInternal;

extern OptionalExpressionListDefaultTypeInternal _OptionalExpressionList_default_instance_;

class PrefixExpression;

struct PrefixExpressionDefaultTypeInternal;

extern PrefixExpressionDefaultTypeInternal _PrefixExpression_default_instance_;

class RepeatCycle;

struct RepeatCycleDefaultTypeInternal;

extern RepeatCycleDefaultTypeInternal _RepeatCycle_default_instance_;

class Statement;

struct StatementDefaultTypeInternal;

extern StatementDefaultTypeInternal _Statement_default_instance_;

class TableConstructor;

struct TableConstructorDefaultTypeInternal;

extern TableConstructorDefaultTypeInternal _TableConstructor_default_instance_;

class UnaryOperator;

struct UnaryOperatorDefaultTypeInternal;

extern UnaryOperatorDefaultTypeInternal _UnaryOperator_default_instance_;

class Variable;

struct VariableDefaultTypeInternal;

extern VariableDefaultTypeInternal _Variable_default_instance_;

class Variable_IndexWithExpression;

struct Variable_IndexWithExpressionDefaultTypeInternal;

extern Variable_IndexWithExpressionDefaultTypeInternal _Variable_IndexWithExpression_default_instance_;

class Variable_IndexWithName;

struct Variable_IndexWithNameDefaultTypeInternal;

extern Variable_IndexWithNameDefaultTypeInternal _Variable_IndexWithName_default_instance_;

class WhileCycle;

struct WhileCycleDefaultTypeInternal;

extern WhileCycleDefaultTypeInternal _WhileCycle_default_instance_;

}  // namespace lua_grammar

PROTOBUF_NAMESPACE_OPEN

template<> ::lua_grammar::AssignmentList* Arena::CreateMaybeMessage<::lua_grammar::AssignmentList>(Arena*);

template<> ::lua_grammar::AssignmentList_VariableList* Arena::CreateMaybeMessage<::lua_grammar::AssignmentList_VariableList>(Arena*);

template<> ::lua_grammar::BinaryOperator* Arena::CreateMaybeMessage<::lua_grammar::BinaryOperator>(Arena*);

template<> ::lua_grammar::Block* Arena::CreateMaybeMessage<::lua_grammar::Block>(Arena*);

template<> ::lua_grammar::Chunk* Arena::CreateMaybeMessage<::lua_grammar::Chunk>(Arena*);

template<> ::lua_grammar::DoBlock* Arena::CreateMaybeMessage<::lua_grammar::DoBlock>(Arena*);

template<> ::lua_grammar::Expression* Arena::CreateMaybeMessage<::lua_grammar::Expression>(Arena*);

template<> ::lua_grammar::ExpressionList* Arena::CreateMaybeMessage<::lua_grammar::ExpressionList>(Arena*);

template<> ::lua_grammar::Expression_AnonFunc* Arena::CreateMaybeMessage<::lua_grammar::Expression_AnonFunc>(Arena*);

template<> ::lua_grammar::Expression_ExpBinaryOpExp* Arena::CreateMaybeMessage<::lua_grammar::Expression_ExpBinaryOpExp>(Arena*);

template<> ::lua_grammar::Expression_UnaryOpExp* Arena::CreateMaybeMessage<::lua_grammar::Expression_UnaryOpExp>(Arena*);

template<> ::lua_grammar::Field* Arena::CreateMaybeMessage<::lua_grammar::Field>(Arena*);

template<> ::lua_grammar::FieldList* Arena::CreateMaybeMessage<::lua_grammar::FieldList>(Arena*);

template<> ::lua_grammar::FieldList_FieldWithFieldSep* Arena::CreateMaybeMessage<::lua_grammar::FieldList_FieldWithFieldSep>(Arena*);

template<> ::lua_grammar::FieldSep* Arena::CreateMaybeMessage<::lua_grammar::FieldSep>(Arena*);

template<> ::lua_grammar::Field_ExpressionAssignment* Arena::CreateMaybeMessage<::lua_grammar::Field_ExpressionAssignment>(Arena*);

template<> ::lua_grammar::Field_NameAssignment* Arena::CreateMaybeMessage<::lua_grammar::Field_NameAssignment>(Arena*);

template<> ::lua_grammar::ForCycleList* Arena::CreateMaybeMessage<::lua_grammar::ForCycleList>(Arena*);

template<> ::lua_grammar::ForCycleName* Arena::CreateMaybeMessage<::lua_grammar::ForCycleName>(Arena*);

template<> ::lua_grammar::FuncBody* Arena::CreateMaybeMessage<::lua_grammar::FuncBody>(Arena*);

template<> ::lua_grammar::FuncBody_NameListWithEllipsis* Arena::CreateMaybeMessage<::lua_grammar::FuncBody_NameListWithEllipsis>(Arena*);

template<> ::lua_grammar::FuncBody_ParList* Arena::CreateMaybeMessage<::lua_grammar::FuncBody_ParList>(Arena*);

template<> ::lua_grammar::Function* Arena::CreateMaybeMessage<::lua_grammar::Function>(Arena*);

template<> ::lua_grammar::FunctionCall* Arena::CreateMaybeMessage<::lua_grammar::FunctionCall>(Arena*);

template<> ::lua_grammar::FunctionCall_Args* Arena::CreateMaybeMessage<::lua_grammar::FunctionCall_Args>(Arena*);

template<> ::lua_grammar::FunctionCall_PrefixArgs* Arena::CreateMaybeMessage<::lua_grammar::FunctionCall_PrefixArgs>(Arena*);

template<> ::lua_grammar::FunctionCall_PrefixNamedArgs* Arena::CreateMaybeMessage<::lua_grammar::FunctionCall_PrefixNamedArgs>(Arena*);

template<> ::lua_grammar::Function_FuncName* Arena::CreateMaybeMessage<::lua_grammar::Function_FuncName>(Arena*);

template<> ::lua_grammar::IfStatement* Arena::CreateMaybeMessage<::lua_grammar::IfStatement>(Arena*);

template<> ::lua_grammar::IfStatement_ElseIfBlock* Arena::CreateMaybeMessage<::lua_grammar::IfStatement_ElseIfBlock>(Arena*);

template<> ::lua_grammar::LastStatement* Arena::CreateMaybeMessage<::lua_grammar::LastStatement>(Arena*);

template<> ::lua_grammar::LastStatement_ReturnOptionalExpressionList* Arena::CreateMaybeMessage<::lua_grammar::LastStatement_ReturnOptionalExpressionList>(Arena*);

template<> ::lua_grammar::LocalFunc* Arena::CreateMaybeMessage<::lua_grammar::LocalFunc>(Arena*);

template<> ::lua_grammar::LocalNames* Arena::CreateMaybeMessage<::lua_grammar::LocalNames>(Arena*);

template<> ::lua_grammar::Name* Arena::CreateMaybeMessage<::lua_grammar::Name>(Arena*);

template<> ::lua_grammar::NameList* Arena::CreateMaybeMessage<::lua_grammar::NameList>(Arena*);

template<> ::lua_grammar::OptionalExpressionList* Arena::CreateMaybeMessage<::lua_grammar::OptionalExpressionList>(Arena*);

template<> ::lua_grammar::PrefixExpression* Arena::CreateMaybeMessage<::lua_grammar::PrefixExpression>(Arena*);

template<> ::lua_grammar::RepeatCycle* Arena::CreateMaybeMessage<::lua_grammar::RepeatCycle>(Arena*);

template<> ::lua_grammar::Statement* Arena::CreateMaybeMessage<::lua_grammar::Statement>(Arena*);

template<> ::lua_grammar::TableConstructor* Arena::CreateMaybeMessage<::lua_grammar::TableConstructor>(Arena*);

template<> ::lua_grammar::UnaryOperator* Arena::CreateMaybeMessage<::lua_grammar::UnaryOperator>(Arena*);

template<> ::lua_grammar::Variable* Arena::CreateMaybeMessage<::lua_grammar::Variable>(Arena*);

template<> ::lua_grammar::Variable_IndexWithExpression* Arena::CreateMaybeMessage<::lua_grammar::Variable_IndexWithExpression>(Arena*);

template<> ::lua_grammar::Variable_IndexWithName* Arena::CreateMaybeMessage<::lua_grammar::Variable_IndexWithName>(Arena*);

template<> ::lua_grammar::WhileCycle* Arena::CreateMaybeMessage<::lua_grammar::WhileCycle>(Arena*);

PROTOBUF_NAMESPACE_CLOSE

namespace lua_grammar {

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

class Block final :

    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:lua_grammar.Block) */ {

 public:

  inline Block() : Block(nullptr) {}

  ~Block() override;

  explicit PROTOBUF_CONSTEXPR Block(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Block(const Block& from);

  Block(Block&& from) noexcept

    : Block() {

    *this = ::std::move(from);

  }

  inline Block& operator=(const Block& from) {

    CopyFrom(from);

    return *this;

  }

  inline Block& operator=(Block&& 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;

  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {

    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);

  }

  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {

    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();

  }

  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 Block& default_instance() {

    return *internal_default_instance();

  }

  static inline const Block* internal_default_instance() {

    return reinterpret_cast<const Block*>(

               &_Block_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    0;

  friend void swap(Block& a, Block& b) {

    a.Swap(&b);

  }

  inline void Swap(Block* 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(Block* other) {

    if (other == this) return;

    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());

    InternalSwap(other);

  }

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

  Block* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {

    return CreateMaybeMessage<Block>(arena);

  }

  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;

  void CopyFrom(const Block& from);

  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;

  void MergeFrom( const Block& from) {

    Block::MergeImpl(*this, from);

  }

  private:

  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);

  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;

  uint8_t* _InternalSerialize(

      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;

  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:

  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);

  void SharedDtor();

  void SetCachedSize(int size) const final;

  void InternalSwap(Block* other);

  private:

  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;

  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {

    return "lua_grammar.Block";

  }

  protected:

  explicit Block(::PROTOBUF_NAMESPACE_ID::Arena* arena,

                       bool is_message_owned = false);

  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 {

    kChunkFieldNumber = 1,

  };

  // required .lua_grammar.Chunk chunk = 1;

  bool has_chunk() const;

  private:

  bool _internal_has_chunk() const;

  public:

  void clear_chunk();

  const ::lua_grammar::Chunk& chunk() const;

  PROTOBUF_NODISCARD ::lua_grammar::Chunk* release_chunk();

  ::lua_grammar::Chunk* mutable_chunk();

  void set_allocated_chunk(::lua_grammar::Chunk* chunk);

  private:

  const ::lua_grammar::Chunk& _internal_chunk() const;

  ::lua_grammar::Chunk* _internal_mutable_chunk();

  public:

  void unsafe_arena_set_allocated_chunk(

      ::lua_grammar::Chunk* chunk);

  ::lua_grammar::Chunk* unsafe_arena_release_chunk();

  // @@protoc_insertion_point(class_scope:lua_grammar.Block)

 private:

  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;

  typedef void InternalArenaConstructable_;

  typedef void DestructorSkippable_;

  struct Impl_ {

    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;

    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;

    ::lua_grammar::Chunk* chunk_;

  };

  union { Impl_ _impl_; };

  friend struct ::TableStruct_lua_5fgrammar_2eproto;

};

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

class Chunk final :

    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:lua_grammar.Chunk) */ {

 public:

  inline Chunk() : Chunk(nullptr) {}

  ~Chunk() override;

  explicit PROTOBUF_CONSTEXPR Chunk(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Chunk(const Chunk& from);

  Chunk(Chunk&& from) noexcept

    : Chunk() {

    *this = ::std::move(from);

  }

  inline Chunk& operator=(const Chunk& from) {

    CopyFrom(from);

    return *this;

  }

  inline Chunk& operator=(Chunk&& 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;

  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {

    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);

  }

  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {

    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();

  }

  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 Chunk& default_instance() {

    return *internal_default_instance();

  }

  static inline const Chunk* internal_default_instance() {

    return reinterpret_cast<const Chunk*>(

               &_Chunk_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    1;

  friend void swap(Chunk& a, Chunk& b) {

    a.Swap(&b);

  }

  inline void Swap(Chunk* 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(Chunk* other) {

    if (other == this) return;

    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());

    InternalSwap(other);

  }

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

  Chunk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {

    return CreateMaybeMessage<Chunk>(arena);

  }

  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;

  void CopyFrom(const Chunk& from);

  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;

  void MergeFrom( const Chunk& from) {

    Chunk::MergeImpl(*this, from);

  }

  private:

  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);

  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;

  uint8_t* _InternalSerialize(

      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;

  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:

  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);

  void SharedDtor();

  void SetCachedSize(int size) const final;

  void InternalSwap(Chunk* other);

  private:

  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;

  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {

    return "lua_grammar.Chunk";

  }

  protected:

  explicit Chunk(::PROTOBUF_NAMESPACE_ID::Arena* arena,

                       bool is_message_owned = false);

  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 {

    kStatFieldNumber = 1,

    kLaststatFieldNumber = 2,

  };

  // repeated .lua_grammar.Statement stat = 1;

  int stat_size() const;

  private:

  int _internal_stat_size() const;

  public:

  void clear_stat();

  ::lua_grammar::Statement* mutable_stat(int index);

  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::lua_grammar::Statement >*

      mutable_stat();

  private:

  const ::lua_grammar::Statement& _internal_stat(int index) const;

  ::lua_grammar::Statement* _internal_add_stat();

  public:

  const ::lua_grammar::Statement& stat(int index) const;

  ::lua_grammar::Statement* add_stat();

  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::lua_grammar::Statement >&

      stat() const;

  // optional .lua_grammar.LastStatement laststat = 2;

  bool has_laststat() const;

  private:

  bool _internal_has_laststat() const;

  public:

  void clear_laststat();

  const ::lua_grammar::LastStatement& laststat() const;

  PROTOBUF_NODISCARD ::lua_grammar::LastStatement* release_laststat();

  ::lua_grammar::LastStatement* mutable_laststat();

  void set_allocated_laststat(::lua_grammar::LastStatement* laststat);

  private:

  const ::lua_grammar::LastStatement& _internal_laststat() const;

  ::lua_grammar::LastStatement* _internal_mutable_laststat();

  public:

  void unsafe_arena_set_allocated_laststat(

      ::lua_grammar::LastStatement* laststat);

  ::lua_grammar::LastStatement* unsafe_arena_release_laststat();

  // @@protoc_insertion_point(class_scope:lua_grammar.Chunk)

 private:

  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;

  typedef void InternalArenaConstructable_;

  typedef void DestructorSkippable_;

  struct Impl_ {

    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;

    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;

    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::lua_grammar::Statement > stat_;

    ::lua_grammar::LastStatement* laststat_;

  };

  union { Impl_ _impl_; };

  friend struct ::TableStruct_lua_5fgrammar_2eproto;

};

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

class Statement final :

    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:lua_grammar.Statement) */ {

 public:

  inline Statement() : Statement(nullptr) {}

  ~Statement() override;

  explicit PROTOBUF_CONSTEXPR Statement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Statement(const Statement& from);

  Statement(Statement&& from) noexcept

    : Statement() {

    *this = ::std::move(from);

  }

  inline Statement& operator=(const Statement& from) {

    CopyFrom(from);

    return *this;

  }

  inline Statement& operator=(Statement&& 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;

  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {

    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);

  }

  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {

    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();

  }

  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 Statement& default_instance() {

    return *internal_default_instance();

  }

  enum StatOneofCase {

    kList = 1,

    kCall = 2,

    kBlock = 3,

    kWhilecycle = 4,

    kRepeatcycle = 5,

    kIfstat = 6,

    kForcyclename = 7,

    kForcyclelist = 8,

    kFunc = 9,

    kLocalfunc = 10,

    kLocalnames = 11,

    STAT_ONEOF_NOT_SET = 0,

  };

  static inline const Statement* internal_default_instance() {

    return reinterpret_cast<const Statement*>(

               &_Statement_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    2;

  friend void swap(Statement& a, Statement& b) {

    a.Swap(&b);

  }

  inline void Swap(Statement* 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(Statement* other) {

    if (other == this) return;

    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());

    InternalSwap(other);

  }

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

  Statement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {

    return CreateMaybeMessage<Statement>(arena);

  }

  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;

  void CopyFrom(const Statement& from);

  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;

  void MergeFrom( const Statement& from) {

    Statement::MergeImpl(*this, from);

  }

  private:

  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg);

  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;

  uint8_t* _InternalSerialize(

      uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;

  int GetCachedSize() const final { return _impl_._cached_size_.Get(); }

  private:

  void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned);

  void SharedDtor();

  void SetCachedSize(int size) const final;

  void InternalSwap(Statement* other);

  private:

  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;

  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {

    return "lua_grammar.Statement";

  }

  protected:

  explicit Statement(::PROTOBUF_NAMESPACE_ID::Arena* arena,

                       bool is_message_owned = false);

  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 {

    kSemicolonFieldNumber = 12,

    kListFieldNumber = 1,

    kCallFieldNumber = 2,

    kBlockFieldNumber = 3,

    kWhilecycleFieldNumber = 4,

    kRepeatcycleFieldNumber = 5,

    kIfstatFieldNumber = 6,

    kForcyclenameFieldNumber = 7,

    kForcyclelistFieldNumber = 8,

    kFuncFieldNumber = 9,

    kLocalfuncFieldNumber = 10,

    kLocalnamesFieldNumber = 11,

  };

  // optional bool semicolon = 12;

  bool has_semicolon() const;

  private:

  bool _internal_has_semicolon() const;

  public:

  void clear_semicolon();

  bool semicolon() const;

  void set_semicolon(bool value);

  private:

  bool _internal_semicolon() const;

  void _internal_set_semicolon(bool value);

  public:

  // .lua_grammar.AssignmentList list = 1;

  bool has_list() const;

  private:

  bool _internal_has_list() const;

  public:

  void clear_list();

  const ::lua_grammar::AssignmentList& list() const;

  PROTOBUF_NODISCARD ::lua_grammar::AssignmentList* release_list();

  ::lua_grammar::AssignmentList* mutable_list();

  void set_allocated_list(::lua_grammar::AssignmentList* list);

  private:

  const ::lua_grammar::AssignmentList& _internal_list() const;

  ::lua_grammar::AssignmentList* _internal_mutable_list();

  public:

  void unsafe_arena_set_allocated_list(

      ::lua_grammar::AssignmentList* list);

  ::lua_grammar::AssignmentList* unsafe_arena_release_list();

  // .lua_grammar.FunctionCall call = 2;

  bool has_call() const;

  private:

  bool _internal_has_call() const;

  public:

  void clear_call();

  const ::lua_grammar::FunctionCall& call() const;

  PROTOBUF_NODISCARD ::lua_grammar::FunctionCall* release_call();

  ::lua_grammar::FunctionCall* mutable_call();

  void set_allocated_call(::lua_grammar::FunctionCall* call);

  private:

  const ::lua_grammar::FunctionCall& _internal_call() const;

  ::lua_grammar::FunctionCall* _internal_mutable_call();

  public:

  void unsafe_arena_set_allocated_call(

      ::lua_grammar::FunctionCall* call);

  ::lua_grammar::FunctionCall* unsafe_arena_release_call();

  // .lua_grammar.DoBlock block = 3;

  bool has_block() const;

  private:

  bool _internal_has_block() const;

  public:

  void clear_block();

  const ::lua_grammar::DoBlock& block() const;

  PROTOBUF_NODISCARD ::lua_grammar::DoBlock* release_block();

  ::lua_grammar::DoBlock* mutable_block();

  void set_allocated_block(::lua_grammar::DoBlock* block);

  private:

  const ::lua_grammar::DoBlock& _internal_block() const;

  ::lua_grammar::DoBlock* _internal_mutable_block();

  public:

  void unsafe_arena_set_allocated_block(

      ::lua_grammar::DoBlock* block);

  ::lua_grammar::DoBlock* unsafe_arena_release_block();

  // .lua_grammar.WhileCycle whilecycle = 4;

  bool has_whilecycle() const;

  private:

  bool _internal_has_whilecycle() const;

  public:

  void clear_whilecycle();

  const ::lua_grammar::WhileCycle& whilecycle() const;

  PROTOBUF_NODISCARD ::lua_grammar::WhileCycle* release_whilecycle();

  ::lua_grammar::WhileCycle* mutable_whilecycle();

  void set_allocated_whilecycle(::lua_grammar::WhileCycle* whilecycle);

  private:

  const ::lua_grammar::WhileCycle& _internal_whilecycle() const;

  ::lua_grammar::WhileCycle* _internal_mutable_whilecycle();

  public:

  void unsafe_arena_set_allocated_whilecycle(

      ::lua_grammar::WhileCycle* whilecycle);

  ::lua_grammar::WhileCycle* unsafe_arena_release_whilecycle();

  // .lua_grammar.RepeatCycle repeatcycle = 5;

  bool has_repeatcycle() const;

  private:

  bool _internal_has_repeatcycle() const;

  public:

  void clear_repeatcycle();

  const ::lua_grammar::RepeatCycle& repeatcycle() const;

  PROTOBUF_NODISCARD ::lua_grammar::RepeatCycle* release_repeatcycle();

  ::lua_grammar::RepeatCycle* mutable_repeatcycle();

  void set_allocated_repeatcycle(::lua_grammar::RepeatCycle* repeatcycle);

  private:

  const ::lua_grammar::RepeatCycle& _internal_repeatcycle() const;

  ::lua_grammar::RepeatCycle* _internal_mutable_repeatcycle();

  public:

  void unsafe_arena_set_allocated_repeatcycle(

      ::lua_grammar::RepeatCycle* repeatcycle);

  ::lua_grammar::RepeatCycle* unsafe_arena_release_repeatcycle();

  // .lua_grammar.IfStatement ifstat = 6;

  bool has_ifstat() const;

  private:

  bool _internal_has_ifstat() const;

  public:

  void clear_ifstat();

  const ::lua_grammar::IfStatement& ifstat() const;

  PROTOBUF_NODISCARD ::lua_grammar::IfStatement* release_ifstat();

  ::lua_grammar::IfStatement* mutable_ifstat();

  void set_allocated_ifstat(::lua_grammar::IfStatement* ifstat);

  private:

  const ::lua_grammar::IfStatement& _internal_ifstat() const;

  ::lua_grammar::IfStatement* _internal_mutable_ifstat();

  public:

  void unsafe_arena_set_allocated_ifstat(

      ::lua_grammar::IfStatement* ifstat);

  ::lua_grammar::IfStatement* unsafe_arena_release_ifstat();

  // .lua_grammar.ForCycleName forcyclename = 7;

  bool has_forcyclename() const;

  private:

  bool _internal_has_forcyclename() const;

  public:

  void clear_forcyclename();

  const ::lua_grammar::ForCycleName& forcyclename() const;

  PROTOBUF_NODISCARD ::lua_grammar::ForCycleName* release_forcyclename();

  ::lua_grammar::ForCycleName* mutable_forcyclename();

  void set_allocated_forcyclename(::lua_grammar::ForCycleName* forcyclename);

  private:

  const ::lua_grammar::ForCycleName& _internal_forcyclename() const;

  ::lua_grammar::ForCycleName* _internal_mutable_forcyclename();

  public:

  void unsafe_arena_set_allocated_forcyclename(

      ::lua_grammar::ForCycleName* forcyclename);

  ::lua_grammar::ForCycleName* unsafe_arena_release_forcyclename();

  // .lua_grammar.ForCycleList forcyclelist = 8;

  bool has_forcyclelist() const;

  private:

  bool _internal_has_forcyclelist() const;

  public:

  void clear_forcyclelist();

  const ::lua_grammar::ForCycleList& forcyclelist() const;

  PROTOBUF_NODISCARD ::lua_grammar::ForCycleList* release_forcyclelist();

  ::lua_grammar::ForCycleList* mutable_forcyclelist();

  void set_allocated_forcyclelist(::lua_grammar::ForCycleList* forcyclelist);

  private:

  const ::lua_grammar::ForCycleList& _internal_forcyclelist() const;

  ::lua_grammar::ForCycleList* _internal_mutable_forcyclelist();

  public:

  void unsafe_arena_set_allocated_forcyclelist(

      ::lua_grammar::ForCycleList* forcyclelist);

  ::lua_grammar::ForCycleList* unsafe_arena_release_forcyclelist();

  // .lua_grammar.Function func = 9;

  bool has_func() const;

  private:

  bool _internal_has_func() const;

  public:

  void clear_func();

  const ::lua_grammar::Function& func() const;

  PROTOBUF_NODISCARD ::lua_grammar::Function* release_func();

  ::lua_grammar::Function* mutable_func();

  void set_allocated_func(::lua_grammar::Function* func);

  private:

  const ::lua_grammar::Function& _internal_func() const;

  ::lua_grammar::Function* _internal_mutable_func();

  public:

  void unsafe_arena_set_allocated_func(

      ::lua_grammar::Function* func);

  ::lua_grammar::Function* unsafe_arena_release_func();

  // .lua_grammar.LocalFunc localfunc = 10;

  bool has_localfunc() const;

  private:

  bool _internal_has_localfunc() const;

  public:

  void clear_localfunc();

  const ::lua_grammar::LocalFunc& localfunc() const;

  PROTOBUF_NODISCARD ::lua_grammar::LocalFunc* release_localfunc();

  ::lua_grammar::LocalFunc* mutable_localfunc();

  void set_allocated_localfunc(::lua_grammar::LocalFunc* localfunc);

  private:

  const ::lua_grammar::LocalFunc& _internal_localfunc() const;

  ::lua_grammar::LocalFunc* _internal_mutable_localfunc();

  public:

  void unsafe_arena_set_allocated_localfunc(

      ::lua_grammar::LocalFunc* localfunc);

  ::lua_grammar::LocalFunc* unsafe_arena_release_localfunc();

  // .lua_grammar.LocalNames localnames = 11;

  bool has_localnames() const;

  private:

  bool _internal_has_localnames() const;

  public:

  void clear_localnames();

  const ::lua_grammar::LocalNames& localnames() const;

  PROTOBUF_NODISCARD ::lua_grammar::LocalNames* release_localnames();

  ::lua_grammar::LocalNames* mutable_localnames();

  void set_allocated_localnames(::lua_grammar::LocalNames* localnames);

  private:

  const ::lua_grammar::LocalNames& _internal_localnames() const;

  ::lua_grammar::LocalNames* _internal_mutable_localnames();

  public:

  void unsafe_arena_set_allocated_localnames(

      ::lua_grammar::LocalNames* localnames);

  ::lua_grammar::LocalNames* unsafe_arena_release_localnames();

  void clear_stat_oneof();

  StatOneofCase stat_oneof_case() const;

  // @@protoc_insertion_point(class_scope:lua_grammar.Statement)

 private:

  class _Internal;

  void set_has_list();

  void set_has_call();

  void set_has_block();

  void set_has_whilecycle();

  void set_has_repeatcycle();

  void set_has_ifstat();

  void set_has_forcyclename();

  void set_has_forcyclelist();

  void set_has_func();

  void set_has_localfunc();

  void set_has_localnames();

  inline bool has_stat_oneof() const;

  inline void clear_has_stat_oneof();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;

  typedef void InternalArenaConstructable_;

  typedef void DestructorSkippable_;

  struct Impl_ {

    ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;

    mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;

    bool semicolon_;

    union StatOneofUnion {

      constexpr StatOneofUnion() : _constinit_{} {}

        ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;

      ::lua_grammar::AssignmentList* list_;

      ::lua_grammar::FunctionCall* call_;

      ::lua_grammar::DoBlock* block_;

      ::lua_grammar::WhileCycle* whilecycle_;

      ::lua_grammar::RepeatCycle* repeatcycle_;

      ::lua_grammar::IfStatement* ifstat_;

      ::lua_grammar::ForCycleName* forcyclename_;

      ::lua_grammar::ForCycleList* forcyclelist_;

      ::lua_grammar::Function* func_;

      ::lua_grammar::LocalFunc* localfunc_;

      ::lua_grammar::LocalNames* localnames_;

    } stat_oneof_;

    uint32_t _oneof_case_[1];

  };

  union { Impl_ _impl_; };

  friend struct ::TableStruct_lua_5fgrammar_2eproto;

};

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

class AssignmentList_VariableList final :

    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:lua_grammar.AssignmentList.VariableList) */ {

 public:

  inline AssignmentList_VariableList() : AssignmentList_VariableList(nullptr) {}

  ~AssignmentList_VariableList() override;

  explicit PROTOBUF_CONSTEXPR AssignmentList_VariableList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  AssignmentList_VariableList(const AssignmentList_VariableList& from);

  AssignmentList_VariableList(AssignmentList_VariableList&& from) noexcept

    : AssignmentList_VariableList() {

    *this = ::std::move(from);

  }

  inline AssignmentList_VariableList& operator=(const AssignmentList_VariableList& from) {

    CopyFrom(from);

    return *this;

  }

  inline AssignmentList_VariableList& operator=(AssignmentList_VariableList&& 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;

  }

  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {

    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);

  }

  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {

    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();

  }

  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 AssignmentList_VariableList& default_instance() {

    return *internal_default_instance();

  }

  static inline const AssignmentList_VariableList* internal_default_instance() {

    return reinterpret_cast<const AssignmentList_VariableList*>(

               &_AssignmentList_VariableList_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    3;

  friend void swap(AssignmentList_VariableList& a, AssignmentList_VariableList& b) {

    a.Swap(&b);

  }

  inline void Swap(AssignmentList_VariableList* other) {