// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: concept.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_concept_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_concept_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3020000
#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 3020003 < 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>
#include "vector.pb.h"
#include "spatial.pb.h"
#include "meta.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_concept_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_concept_2eproto {
  static const uint32_t offsets[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_concept_2eproto;
namespace Messages {
class Command;
struct CommandDefaultTypeInternal;
extern CommandDefaultTypeInternal _Command_default_instance_;
class Coupling;
struct CouplingDefaultTypeInternal;
extern CouplingDefaultTypeInternal _Coupling_default_instance_;
class Function;
struct FunctionDefaultTypeInternal;
extern FunctionDefaultTypeInternal _Function_default_instance_;
class Model;
struct ModelDefaultTypeInternal;
extern ModelDefaultTypeInternal _Model_default_instance_;
class Script;
struct ScriptDefaultTypeInternal;
extern ScriptDefaultTypeInternal _Script_default_instance_;
class System;
struct SystemDefaultTypeInternal;
extern SystemDefaultTypeInternal _System_default_instance_;
class Variables;
struct VariablesDefaultTypeInternal;
extern VariablesDefaultTypeInternal _Variables_default_instance_;
}  // namespace Messages
PROTOBUF_NAMESPACE_OPEN
template<> ::Messages::Command* Arena::CreateMaybeMessage<::Messages::Command>(Arena*);
template<> ::Messages::Coupling* Arena::CreateMaybeMessage<::Messages::Coupling>(Arena*);
template<> ::Messages::Function* Arena::CreateMaybeMessage<::Messages::Function>(Arena*);
template<> ::Messages::Model* Arena::CreateMaybeMessage<::Messages::Model>(Arena*);
template<> ::Messages::Script* Arena::CreateMaybeMessage<::Messages::Script>(Arena*);
template<> ::Messages::System* Arena::CreateMaybeMessage<::Messages::System>(Arena*);
template<> ::Messages::Variables* Arena::CreateMaybeMessage<::Messages::Variables>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace Messages {

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

class Variables final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Messages.Variables) */ {
 public:
  inline Variables() : Variables(nullptr) {}
  ~Variables() override;
  explicit PROTOBUF_CONSTEXPR Variables(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Variables(const Variables& from);
  Variables(Variables&& from) noexcept
    : Variables() {
    *this = ::std::move(from);
  }

  inline Variables& operator=(const Variables& from) {
    CopyFrom(from);
    return *this;
  }
  inline Variables& operator=(Variables&& 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 Variables& default_instance() {
    return *internal_default_instance();
  }
  static inline const Variables* internal_default_instance() {
    return reinterpret_cast<const Variables*>(
               &_Variables_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

  friend void swap(Variables& a, Variables& b) {
    a.Swap(&b);
  }
  inline void Swap(Variables* 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(Variables* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Variables* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Variables>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Variables& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Variables& 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;
  uint8_t* _InternalSerialize(
      uint8_t* 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(Variables* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Messages.Variables";
  }
  protected:
  explicit Variables(::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 {
    kIntNamesFieldNumber = 2,
    kIntValuesFieldNumber = 3,
    kIntDescriptionsFieldNumber = 4,
    kBoolNamesFieldNumber = 6,
    kBoolValuesFieldNumber = 7,
    kBoolDescriptionsFieldNumber = 8,
    kDoubleNamesFieldNumber = 10,
    kDoubleValuesFieldNumber = 11,
    kDoubleDescriptionsFieldNumber = 12,
    kStringNamesFieldNumber = 14,
    kStringValuesFieldNumber = 15,
    kStringDescriptionsFieldNumber = 16,
  };
  // repeated string int_names = 2;
  int int_names_size() const;
  private:
  int _internal_int_names_size() const;
  public:
  void clear_int_names();
  const std::string& int_names(int index) const;
  std::string* mutable_int_names(int index);
  void set_int_names(int index, const std::string& value);
  void set_int_names(int index, std::string&& value);
  void set_int_names(int index, const char* value);
  void set_int_names(int index, const char* value, size_t size);
  std::string* add_int_names();
  void add_int_names(const std::string& value);
  void add_int_names(std::string&& value);
  void add_int_names(const char* value);
  void add_int_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& int_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_int_names();
  private:
  const std::string& _internal_int_names(int index) const;
  std::string* _internal_add_int_names();
  public:

  // repeated int32 int_values = 3;
  int int_values_size() const;
  private:
  int _internal_int_values_size() const;
  public:
  void clear_int_values();
  private:
  int32_t _internal_int_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      _internal_int_values() const;
  void _internal_add_int_values(int32_t value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      _internal_mutable_int_values();
  public:
  int32_t int_values(int index) const;
  void set_int_values(int index, int32_t value);
  void add_int_values(int32_t value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
      int_values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
      mutable_int_values();

  // repeated string int_descriptions = 4;
  int int_descriptions_size() const;
  private:
  int _internal_int_descriptions_size() const;
  public:
  void clear_int_descriptions();
  const std::string& int_descriptions(int index) const;
  std::string* mutable_int_descriptions(int index);
  void set_int_descriptions(int index, const std::string& value);
  void set_int_descriptions(int index, std::string&& value);
  void set_int_descriptions(int index, const char* value);
  void set_int_descriptions(int index, const char* value, size_t size);
  std::string* add_int_descriptions();
  void add_int_descriptions(const std::string& value);
  void add_int_descriptions(std::string&& value);
  void add_int_descriptions(const char* value);
  void add_int_descriptions(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& int_descriptions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_int_descriptions();
  private:
  const std::string& _internal_int_descriptions(int index) const;
  std::string* _internal_add_int_descriptions();
  public:

  // repeated string bool_names = 6;
  int bool_names_size() const;
  private:
  int _internal_bool_names_size() const;
  public:
  void clear_bool_names();
  const std::string& bool_names(int index) const;
  std::string* mutable_bool_names(int index);
  void set_bool_names(int index, const std::string& value);
  void set_bool_names(int index, std::string&& value);
  void set_bool_names(int index, const char* value);
  void set_bool_names(int index, const char* value, size_t size);
  std::string* add_bool_names();
  void add_bool_names(const std::string& value);
  void add_bool_names(std::string&& value);
  void add_bool_names(const char* value);
  void add_bool_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& bool_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_bool_names();
  private:
  const std::string& _internal_bool_names(int index) const;
  std::string* _internal_add_bool_names();
  public:

  // repeated bool bool_values = 7;
  int bool_values_size() const;
  private:
  int _internal_bool_values_size() const;
  public:
  void clear_bool_values();
  private:
  bool _internal_bool_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      _internal_bool_values() const;
  void _internal_add_bool_values(bool value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      _internal_mutable_bool_values();
  public:
  bool bool_values(int index) const;
  void set_bool_values(int index, bool value);
  void add_bool_values(bool value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
      bool_values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
      mutable_bool_values();

  // repeated string bool_descriptions = 8;
  int bool_descriptions_size() const;
  private:
  int _internal_bool_descriptions_size() const;
  public:
  void clear_bool_descriptions();
  const std::string& bool_descriptions(int index) const;
  std::string* mutable_bool_descriptions(int index);
  void set_bool_descriptions(int index, const std::string& value);
  void set_bool_descriptions(int index, std::string&& value);
  void set_bool_descriptions(int index, const char* value);
  void set_bool_descriptions(int index, const char* value, size_t size);
  std::string* add_bool_descriptions();
  void add_bool_descriptions(const std::string& value);
  void add_bool_descriptions(std::string&& value);
  void add_bool_descriptions(const char* value);
  void add_bool_descriptions(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& bool_descriptions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_bool_descriptions();
  private:
  const std::string& _internal_bool_descriptions(int index) const;
  std::string* _internal_add_bool_descriptions();
  public:

  // repeated string double_names = 10;
  int double_names_size() const;
  private:
  int _internal_double_names_size() const;
  public:
  void clear_double_names();
  const std::string& double_names(int index) const;
  std::string* mutable_double_names(int index);
  void set_double_names(int index, const std::string& value);
  void set_double_names(int index, std::string&& value);
  void set_double_names(int index, const char* value);
  void set_double_names(int index, const char* value, size_t size);
  std::string* add_double_names();
  void add_double_names(const std::string& value);
  void add_double_names(std::string&& value);
  void add_double_names(const char* value);
  void add_double_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& double_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_double_names();
  private:
  const std::string& _internal_double_names(int index) const;
  std::string* _internal_add_double_names();
  public:

  // repeated double double_values = 11;
  int double_values_size() const;
  private:
  int _internal_double_values_size() const;
  public:
  void clear_double_values();
  private:
  double _internal_double_values(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_double_values() const;
  void _internal_add_double_values(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_double_values();
  public:
  double double_values(int index) const;
  void set_double_values(int index, double value);
  void add_double_values(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      double_values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_double_values();

  // repeated string double_descriptions = 12;
  int double_descriptions_size() const;
  private:
  int _internal_double_descriptions_size() const;
  public:
  void clear_double_descriptions();
  const std::string& double_descriptions(int index) const;
  std::string* mutable_double_descriptions(int index);
  void set_double_descriptions(int index, const std::string& value);
  void set_double_descriptions(int index, std::string&& value);
  void set_double_descriptions(int index, const char* value);
  void set_double_descriptions(int index, const char* value, size_t size);
  std::string* add_double_descriptions();
  void add_double_descriptions(const std::string& value);
  void add_double_descriptions(std::string&& value);
  void add_double_descriptions(const char* value);
  void add_double_descriptions(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& double_descriptions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_double_descriptions();
  private:
  const std::string& _internal_double_descriptions(int index) const;
  std::string* _internal_add_double_descriptions();
  public:

  // repeated string string_names = 14;
  int string_names_size() const;
  private:
  int _internal_string_names_size() const;
  public:
  void clear_string_names();
  const std::string& string_names(int index) const;
  std::string* mutable_string_names(int index);
  void set_string_names(int index, const std::string& value);
  void set_string_names(int index, std::string&& value);
  void set_string_names(int index, const char* value);
  void set_string_names(int index, const char* value, size_t size);
  std::string* add_string_names();
  void add_string_names(const std::string& value);
  void add_string_names(std::string&& value);
  void add_string_names(const char* value);
  void add_string_names(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_names() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_names();
  private:
  const std::string& _internal_string_names(int index) const;
  std::string* _internal_add_string_names();
  public:

  // repeated string string_values = 15;
  int string_values_size() const;
  private:
  int _internal_string_values_size() const;
  public:
  void clear_string_values();
  const std::string& string_values(int index) const;
  std::string* mutable_string_values(int index);
  void set_string_values(int index, const std::string& value);
  void set_string_values(int index, std::string&& value);
  void set_string_values(int index, const char* value);
  void set_string_values(int index, const char* value, size_t size);
  std::string* add_string_values();
  void add_string_values(const std::string& value);
  void add_string_values(std::string&& value);
  void add_string_values(const char* value);
  void add_string_values(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_values() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_values();
  private:
  const std::string& _internal_string_values(int index) const;
  std::string* _internal_add_string_values();
  public:

  // repeated string string_descriptions = 16;
  int string_descriptions_size() const;
  private:
  int _internal_string_descriptions_size() const;
  public:
  void clear_string_descriptions();
  const std::string& string_descriptions(int index) const;
  std::string* mutable_string_descriptions(int index);
  void set_string_descriptions(int index, const std::string& value);
  void set_string_descriptions(int index, std::string&& value);
  void set_string_descriptions(int index, const char* value);
  void set_string_descriptions(int index, const char* value, size_t size);
  std::string* add_string_descriptions();
  void add_string_descriptions(const std::string& value);
  void add_string_descriptions(std::string&& value);
  void add_string_descriptions(const char* value);
  void add_string_descriptions(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& string_descriptions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_string_descriptions();
  private:
  const std::string& _internal_string_descriptions(int index) const;
  std::string* _internal_add_string_descriptions();
  public:

  // @@protoc_insertion_point(class_scope:Messages.Variables)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> int_names_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > int_values_;
  mutable std::atomic<int> _int_values_cached_byte_size_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> int_descriptions_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> bool_names_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > bool_values_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> bool_descriptions_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> double_names_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > double_values_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> double_descriptions_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_names_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_values_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> string_descriptions_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_concept_2eproto;
};
// -------------------------------------------------------------------

class Function final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Messages.Function) */ {
 public:
  inline Function() : Function(nullptr) {}
  ~Function() override;
  explicit PROTOBUF_CONSTEXPR Function(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Function(const Function& from);
  Function(Function&& from) noexcept
    : Function() {
    *this = ::std::move(from);
  }

  inline Function& operator=(const Function& from) {
    CopyFrom(from);
    return *this;
  }
  inline Function& operator=(Function&& 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 Function& default_instance() {
    return *internal_default_instance();
  }
  static inline const Function* internal_default_instance() {
    return reinterpret_cast<const Function*>(
               &_Function_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Function& a, Function& b) {
    a.Swap(&b);
  }
  inline void Swap(Function* 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(Function* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Function* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Function>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Function& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Function& 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;
  uint8_t* _InternalSerialize(
      uint8_t* 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(Function* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Messages.Function";
  }
  protected:
  explicit Function(::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 {
    kArgumentTypesFieldNumber = 2,
    kArgumentDescriptionsFieldNumber = 3,
    kInputsFieldNumber = 4,
    kOutputsFieldNumber = 5,
    kConstantsFieldNumber = 6,
    kToBeDefinedFieldNumber = 7,
    kDataFieldNumber = 8,
    kNameFieldNumber = 1,
    kCpuCapableFieldNumber = 10,
    kGpuCapableFieldNumber = 11,
    kIncludeAsPreprocessorFieldNumber = 12,
    kOmitFromMainLoopFieldNumber = 13,
    kIncludeAsPostprocessorFieldNumber = 14,
    kMutuallyExclusiveFieldNumber = 15,
    kOnlyOnceFieldNumber = 16,
    kPushFrontFieldNumber = 17,
    kDontFlattenFieldNumber = 18,
  };
  // repeated string argument_types = 2;
  int argument_types_size() const;
  private:
  int _internal_argument_types_size() const;
  public:
  void clear_argument_types();
  const std::string& argument_types(int index) const;
  std::string* mutable_argument_types(int index);
  void set_argument_types(int index, const std::string& value);
  void set_argument_types(int index, std::string&& value);
  void set_argument_types(int index, const char* value);
  void set_argument_types(int index, const char* value, size_t size);
  std::string* add_argument_types();
  void add_argument_types(const std::string& value);
  void add_argument_types(std::string&& value);
  void add_argument_types(const char* value);
  void add_argument_types(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& argument_types() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_argument_types();
  private:
  const std::string& _internal_argument_types(int index) const;
  std::string* _internal_add_argument_types();
  public:

  // repeated string argument_descriptions = 3;
  int argument_descriptions_size() const;
  private:
  int _internal_argument_descriptions_size() const;
  public:
  void clear_argument_descriptions();
  const std::string& argument_descriptions(int index) const;
  std::string* mutable_argument_descriptions(int index);
  void set_argument_descriptions(int index, const std::string& value);
  void set_argument_descriptions(int index, std::string&& value);
  void set_argument_descriptions(int index, const char* value);
  void set_argument_descriptions(int index, const char* value, size_t size);
  std::string* add_argument_descriptions();
  void add_argument_descriptions(const std::string& value);
  void add_argument_descriptions(std::string&& value);
  void add_argument_descriptions(const char* value);
  void add_argument_descriptions(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& argument_descriptions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_argument_descriptions();
  private:
  const std::string& _internal_argument_descriptions(int index) const;
  std::string* _internal_add_argument_descriptions();
  public:

  // repeated string inputs = 4;
  int inputs_size() const;
  private:
  int _internal_inputs_size() const;
  public:
  void clear_inputs();
  const std::string& inputs(int index) const;
  std::string* mutable_inputs(int index);
  void set_inputs(int index, const std::string& value);
  void set_inputs(int index, std::string&& value);
  void set_inputs(int index, const char* value);
  void set_inputs(int index, const char* value, size_t size);
  std::string* add_inputs();
  void add_inputs(const std::string& value);
  void add_inputs(std::string&& value);
  void add_inputs(const char* value);
  void add_inputs(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& inputs() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_inputs();
  private:
  const std::string& _internal_inputs(int index) const;
  std::string* _internal_add_inputs();
  public:

  // repeated string outputs = 5;
  int outputs_size() const;
  private:
  int _internal_outputs_size() const;
  public:
  void clear_outputs();
  const std::string& outputs(int index) const;
  std::string* mutable_outputs(int index);
  void set_outputs(int index, const std::string& value);
  void set_outputs(int index, std::string&& value);
  void set_outputs(int index, const char* value);
  void set_outputs(int index, const char* value, size_t size);
  std::string* add_outputs();
  void add_outputs(const std::string& value);
  void add_outputs(std::string&& value);
  void add_outputs(const char* value);
  void add_outputs(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& outputs() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_outputs();
  private:
  const std::string& _internal_outputs(int index) const;
  std::string* _internal_add_outputs();
  public:

  // repeated string constants = 6;
  int constants_size() const;
  private:
  int _internal_constants_size() const;
  public:
  void clear_constants();
  const std::string& constants(int index) const;
  std::string* mutable_constants(int index);
  void set_constants(int index, const std::string& value);
  void set_constants(int index, std::string&& value);
  void set_constants(int index, const char* value);
  void set_constants(int index, const char* value, size_t size);
  std::string* add_constants();
  void add_constants(const std::string& value);
  void add_constants(std::string&& value);
  void add_constants(const char* value);
  void add_constants(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& constants() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_constants();
  private:
  const std::string& _internal_constants(int index) const;
  std::string* _internal_add_constants();
  public:

  // repeated string to_be_defined = 7;
  int to_be_defined_size() const;
  private:
  int _internal_to_be_defined_size() const;
  public:
  void clear_to_be_defined();
  const std::string& to_be_defined(int index) const;
  std::string* mutable_to_be_defined(int index);
  void set_to_be_defined(int index, const std::string& value);
  void set_to_be_defined(int index, std::string&& value);
  void set_to_be_defined(int index, const char* value);
  void set_to_be_defined(int index, const char* value, size_t size);
  std::string* add_to_be_defined();
  void add_to_be_defined(const std::string& value);
  void add_to_be_defined(std::string&& value);
  void add_to_be_defined(const char* value);
  void add_to_be_defined(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& to_be_defined() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_to_be_defined();
  private:
  const std::string& _internal_to_be_defined(int index) const;
  std::string* _internal_add_to_be_defined();
  public:

  // repeated .Messages.Vector64 data = 8;
  int data_size() const;
  private:
  int _internal_data_size() const;
  public:
  void clear_data();
  ::Messages::Vector64* mutable_data(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Vector64 >*
      mutable_data();
  private:
  const ::Messages::Vector64& _internal_data(int index) const;
  ::Messages::Vector64* _internal_add_data();
  public:
  const ::Messages::Vector64& data(int index) const;
  ::Messages::Vector64* add_data();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Vector64 >&
      data() const;

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // bool cpu_capable = 10;
  void clear_cpu_capable();
  bool cpu_capable() const;
  void set_cpu_capable(bool value);
  private:
  bool _internal_cpu_capable() const;
  void _internal_set_cpu_capable(bool value);
  public:

  // bool gpu_capable = 11;
  void clear_gpu_capable();
  bool gpu_capable() const;
  void set_gpu_capable(bool value);
  private:
  bool _internal_gpu_capable() const;
  void _internal_set_gpu_capable(bool value);
  public:

  // bool include_as_preprocessor = 12;
  void clear_include_as_preprocessor();
  bool include_as_preprocessor() const;
  void set_include_as_preprocessor(bool value);
  private:
  bool _internal_include_as_preprocessor() const;
  void _internal_set_include_as_preprocessor(bool value);
  public:

  // bool omit_from_main_loop = 13;
  void clear_omit_from_main_loop();
  bool omit_from_main_loop() const;
  void set_omit_from_main_loop(bool value);
  private:
  bool _internal_omit_from_main_loop() const;
  void _internal_set_omit_from_main_loop(bool value);
  public:

  // bool include_as_postprocessor = 14;
  void clear_include_as_postprocessor();
  bool include_as_postprocessor() const;
  void set_include_as_postprocessor(bool value);
  private:
  bool _internal_include_as_postprocessor() const;
  void _internal_set_include_as_postprocessor(bool value);
  public:

  // bool mutually_exclusive = 15;
  void clear_mutually_exclusive();
  bool mutually_exclusive() const;
  void set_mutually_exclusive(bool value);
  private:
  bool _internal_mutually_exclusive() const;
  void _internal_set_mutually_exclusive(bool value);
  public:

  // bool only_once = 16;
  void clear_only_once();
  bool only_once() const;
  void set_only_once(bool value);
  private:
  bool _internal_only_once() const;
  void _internal_set_only_once(bool value);
  public:

  // bool push_front = 17;
  void clear_push_front();
  bool push_front() const;
  void set_push_front(bool value);
  private:
  bool _internal_push_front() const;
  void _internal_set_push_front(bool value);
  public:

  // bool dont_flatten = 18;
  void clear_dont_flatten();
  bool dont_flatten() const;
  void set_dont_flatten(bool value);
  private:
  bool _internal_dont_flatten() const;
  void _internal_set_dont_flatten(bool value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.Function)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> argument_types_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> argument_descriptions_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> inputs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> outputs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> constants_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> to_be_defined_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Vector64 > data_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  bool cpu_capable_;
  bool gpu_capable_;
  bool include_as_preprocessor_;
  bool omit_from_main_loop_;
  bool include_as_postprocessor_;
  bool mutually_exclusive_;
  bool only_once_;
  bool push_front_;
  bool dont_flatten_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_concept_2eproto;
};
// -------------------------------------------------------------------

class Command final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Messages.Command) */ {
 public:
  inline Command() : Command(nullptr) {}
  ~Command() override;
  explicit PROTOBUF_CONSTEXPR Command(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Command(const Command& from);
  Command(Command&& from) noexcept
    : Command() {
    *this = ::std::move(from);
  }

  inline Command& operator=(const Command& from) {
    CopyFrom(from);
    return *this;
  }
  inline Command& operator=(Command&& 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 Command& default_instance() {
    return *internal_default_instance();
  }
  static inline const Command* internal_default_instance() {
    return reinterpret_cast<const Command*>(
               &_Command_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(Command& a, Command& b) {
    a.Swap(&b);
  }
  inline void Swap(Command* 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(Command* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Command* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Command>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Command& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Command& 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;
  uint8_t* _InternalSerialize(
      uint8_t* 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(Command* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Messages.Command";
  }
  protected:
  explicit Command(::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 {
    kBeforeFieldNumber = 13,
    kAfterFieldNumber = 14,
    kMsgFieldNumber = 10,
    kFunctionFieldNumber = 1,
    kDataFieldNumber = 12,
    kExecCountFieldNumber = 4,
    kArgsAreSetFieldNumber = 2,
    kIsReadyFieldNumber = 3,
    kProgressFieldNumber = 9,
    kSimdSizeFieldNumber = 5,
    kVersionFieldNumber = 6,
    kIdFieldNumber = 7,
    kNKernelFieldNumber = 8,
    kRegionTypeFieldNumber = 15,
    kRegionIdFieldNumber = 16,
  };
  // repeated .Messages.Command before = 13;
  int before_size() const;
  private:
  int _internal_before_size() const;
  public:
  void clear_before();
  ::Messages::Command* mutable_before(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >*
      mutable_before();
  private:
  const ::Messages::Command& _internal_before(int index) const;
  ::Messages::Command* _internal_add_before();
  public:
  const ::Messages::Command& before(int index) const;
  ::Messages::Command* add_before();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >&
      before() const;

  // repeated .Messages.Command after = 14;
  int after_size() const;
  private:
  int _internal_after_size() const;
  public:
  void clear_after();
  ::Messages::Command* mutable_after(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >*
      mutable_after();
  private:
  const ::Messages::Command& _internal_after(int index) const;
  ::Messages::Command* _internal_add_after();
  public:
  const ::Messages::Command& after(int index) const;
  ::Messages::Command* add_after();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >&
      after() const;

  // string msg = 10;
  void clear_msg();
  const std::string& msg() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_msg(ArgT0&& arg0, ArgT... args);
  std::string* mutable_msg();
  PROTOBUF_NODISCARD std::string* release_msg();
  void set_allocated_msg(std::string* msg);
  private:
  const std::string& _internal_msg() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg(const std::string& value);
  std::string* _internal_mutable_msg();
  public:

  // .Messages.Function function = 1;
  bool has_function() const;
  private:
  bool _internal_has_function() const;
  public:
  void clear_function();
  const ::Messages::Function& function() const;
  PROTOBUF_NODISCARD ::Messages::Function* release_function();
  ::Messages::Function* mutable_function();
  void set_allocated_function(::Messages::Function* function);
  private:
  const ::Messages::Function& _internal_function() const;
  ::Messages::Function* _internal_mutable_function();
  public:
  void unsafe_arena_set_allocated_function(
      ::Messages::Function* function);
  ::Messages::Function* unsafe_arena_release_function();

  // .Messages.Record64 data = 12;
  bool has_data() const;
  private:
  bool _internal_has_data() const;
  public:
  void clear_data();
  const ::Messages::Record64& data() const;
  PROTOBUF_NODISCARD ::Messages::Record64* release_data();
  ::Messages::Record64* mutable_data();
  void set_allocated_data(::Messages::Record64* data);
  private:
  const ::Messages::Record64& _internal_data() const;
  ::Messages::Record64* _internal_mutable_data();
  public:
  void unsafe_arena_set_allocated_data(
      ::Messages::Record64* data);
  ::Messages::Record64* unsafe_arena_release_data();

  // uint64 exec_count = 4;
  void clear_exec_count();
  uint64_t exec_count() const;
  void set_exec_count(uint64_t value);
  private:
  uint64_t _internal_exec_count() const;
  void _internal_set_exec_count(uint64_t value);
  public:

  // bool args_are_set = 2;
  void clear_args_are_set();
  bool args_are_set() const;
  void set_args_are_set(bool value);
  private:
  bool _internal_args_are_set() const;
  void _internal_set_args_are_set(bool value);
  public:

  // bool is_ready = 3;
  void clear_is_ready();
  bool is_ready() const;
  void set_is_ready(bool value);
  private:
  bool _internal_is_ready() const;
  void _internal_set_is_ready(bool value);
  public:

  // float progress = 9;
  void clear_progress();
  float progress() const;
  void set_progress(float value);
  private:
  float _internal_progress() const;
  void _internal_set_progress(float value);
  public:

  // uint64 simd_size = 5;
  void clear_simd_size();
  uint64_t simd_size() const;
  void set_simd_size(uint64_t value);
  private:
  uint64_t _internal_simd_size() const;
  void _internal_set_simd_size(uint64_t value);
  public:

  // uint64 version = 6;
  void clear_version();
  uint64_t version() const;
  void set_version(uint64_t value);
  private:
  uint64_t _internal_version() const;
  void _internal_set_version(uint64_t value);
  public:

  // int64 id = 7;
  void clear_id();
  int64_t id() const;
  void set_id(int64_t value);
  private:
  int64_t _internal_id() const;
  void _internal_set_id(int64_t value);
  public:

  // uint64 n_kernel = 8;
  void clear_n_kernel();
  uint64_t n_kernel() const;
  void set_n_kernel(uint64_t value);
  private:
  uint64_t _internal_n_kernel() const;
  void _internal_set_n_kernel(uint64_t value);
  public:

  // uint32 region_type = 15;
  void clear_region_type();
  uint32_t region_type() const;
  void set_region_type(uint32_t value);
  private:
  uint32_t _internal_region_type() const;
  void _internal_set_region_type(uint32_t value);
  public:

  // int32 region_id = 16;
  void clear_region_id();
  int32_t region_id() const;
  void set_region_id(int32_t value);
  private:
  int32_t _internal_region_id() const;
  void _internal_set_region_id(int32_t value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.Command)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command > before_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command > after_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_;
  ::Messages::Function* function_;
  ::Messages::Record64* data_;
  uint64_t exec_count_;
  bool args_are_set_;
  bool is_ready_;
  float progress_;
  uint64_t simd_size_;
  uint64_t version_;
  int64_t id_;
  uint64_t n_kernel_;
  uint32_t region_type_;
  int32_t region_id_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_concept_2eproto;
};
// -------------------------------------------------------------------

class Script final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Messages.Script) */ {
 public:
  inline Script() : Script(nullptr) {}
  ~Script() override;
  explicit PROTOBUF_CONSTEXPR Script(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Script(const Script& from);
  Script(Script&& from) noexcept
    : Script() {
    *this = ::std::move(from);
  }

  inline Script& operator=(const Script& from) {
    CopyFrom(from);
    return *this;
  }
  inline Script& operator=(Script&& 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 Script& default_instance() {
    return *internal_default_instance();
  }
  static inline const Script* internal_default_instance() {
    return reinterpret_cast<const Script*>(
               &_Script_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(Script& a, Script& b) {
    a.Swap(&b);
  }
  inline void Swap(Script* 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(Script* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Script* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Script>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Script& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Script& 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;
  uint8_t* _InternalSerialize(
      uint8_t* 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(Script* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Messages.Script";
  }
  protected:
  explicit Script(::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 {
    kSequenceFieldNumber = 12,
    kNameFieldNumber = 1,
    kMsgFieldNumber = 2,
    kSourceCodeFieldNumber = 3,
    kVariablesFieldNumber = 10,
    kBeforeFieldNumber = 14,
    kAfterFieldNumber = 15,
    kUidFieldNumber = 4,
    kDeviceFieldNumber = 5,
    kStatusFieldNumber = 6,
    kOrderFieldNumber = 7,
    kProgressFieldNumber = 8,
  };
  // repeated .Messages.Command Sequence = 12;
  int sequence_size() const;
  private:
  int _internal_sequence_size() const;
  public:
  void clear_sequence();
  ::Messages::Command* mutable_sequence(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >*
      mutable_sequence();
  private:
  const ::Messages::Command& _internal_sequence(int index) const;
  ::Messages::Command* _internal_add_sequence();
  public:
  const ::Messages::Command& sequence(int index) const;
  ::Messages::Command* add_sequence();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >&
      sequence() const;

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string msg = 2;
  void clear_msg();
  const std::string& msg() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_msg(ArgT0&& arg0, ArgT... args);
  std::string* mutable_msg();
  PROTOBUF_NODISCARD std::string* release_msg();
  void set_allocated_msg(std::string* msg);
  private:
  const std::string& _internal_msg() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg(const std::string& value);
  std::string* _internal_mutable_msg();
  public:

  // string source_code = 3;
  void clear_source_code();
  const std::string& source_code() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source_code(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source_code();
  PROTOBUF_NODISCARD std::string* release_source_code();
  void set_allocated_source_code(std::string* source_code);
  private:
  const std::string& _internal_source_code() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source_code(const std::string& value);
  std::string* _internal_mutable_source_code();
  public:

  // .Messages.Variables variables = 10;
  bool has_variables() const;
  private:
  bool _internal_has_variables() const;
  public:
  void clear_variables();
  const ::Messages::Variables& variables() const;
  PROTOBUF_NODISCARD ::Messages::Variables* release_variables();
  ::Messages::Variables* mutable_variables();
  void set_allocated_variables(::Messages::Variables* variables);
  private:
  const ::Messages::Variables& _internal_variables() const;
  ::Messages::Variables* _internal_mutable_variables();
  public:
  void unsafe_arena_set_allocated_variables(
      ::Messages::Variables* variables);
  ::Messages::Variables* unsafe_arena_release_variables();

  // .Messages.Script before = 14;
  bool has_before() const;
  private:
  bool _internal_has_before() const;
  public:
  void clear_before();
  const ::Messages::Script& before() const;
  PROTOBUF_NODISCARD ::Messages::Script* release_before();
  ::Messages::Script* mutable_before();
  void set_allocated_before(::Messages::Script* before);
  private:
  const ::Messages::Script& _internal_before() const;
  ::Messages::Script* _internal_mutable_before();
  public:
  void unsafe_arena_set_allocated_before(
      ::Messages::Script* before);
  ::Messages::Script* unsafe_arena_release_before();

  // .Messages.Script after = 15;
  bool has_after() const;
  private:
  bool _internal_has_after() const;
  public:
  void clear_after();
  const ::Messages::Script& after() const;
  PROTOBUF_NODISCARD ::Messages::Script* release_after();
  ::Messages::Script* mutable_after();
  void set_allocated_after(::Messages::Script* after);
  private:
  const ::Messages::Script& _internal_after() const;
  ::Messages::Script* _internal_mutable_after();
  public:
  void unsafe_arena_set_allocated_after(
      ::Messages::Script* after);
  ::Messages::Script* unsafe_arena_release_after();

  // int64 uid = 4;
  void clear_uid();
  int64_t uid() const;
  void set_uid(int64_t value);
  private:
  int64_t _internal_uid() const;
  void _internal_set_uid(int64_t value);
  public:

  // uint32 device = 5;
  void clear_device();
  uint32_t device() const;
  void set_device(uint32_t value);
  private:
  uint32_t _internal_device() const;
  void _internal_set_device(uint32_t value);
  public:

  // uint32 status = 6;
  void clear_status();
  uint32_t status() const;
  void set_status(uint32_t value);
  private:
  uint32_t _internal_status() const;
  void _internal_set_status(uint32_t value);
  public:

  // uint32 order = 7;
  void clear_order();
  uint32_t order() const;
  void set_order(uint32_t value);
  private:
  uint32_t _internal_order() const;
  void _internal_set_order(uint32_t value);
  public:

  // float progress = 8;
  void clear_progress();
  float progress() const;
  void set_progress(float value);
  private:
  float _internal_progress() const;
  void _internal_set_progress(float value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.Script)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command > sequence_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_code_;
  ::Messages::Variables* variables_;
  ::Messages::Script* before_;
  ::Messages::Script* after_;
  int64_t uid_;
  uint32_t device_;
  uint32_t status_;
  uint32_t order_;
  float progress_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_concept_2eproto;
};
// -------------------------------------------------------------------

class Model final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Messages.Model) */ {
 public:
  inline Model() : Model(nullptr) {}
  ~Model() override;
  explicit PROTOBUF_CONSTEXPR Model(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Model(const Model& from);
  Model(Model&& from) noexcept
    : Model() {
    *this = ::std::move(from);
  }

  inline Model& operator=(const Model& from) {
    CopyFrom(from);
    return *this;
  }
  inline Model& operator=(Model&& 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 Model& default_instance() {
    return *internal_default_instance();
  }
  static inline const Model* internal_default_instance() {
    return reinterpret_cast<const Model*>(
               &_Model_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(Model& a, Model& b) {
    a.Swap(&b);
  }
  inline void Swap(Model* 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(Model* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Model* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Model>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Model& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Model& 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;
  uint8_t* _InternalSerialize(
      uint8_t* 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(Model* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Messages.Model";
  }
  protected:
  explicit Model(::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 {
    kDofsFieldNumber = 3,
    kAlgorithmsFieldNumber = 4,
    kAvailableOutputsFieldNumber = 5,
    kExtraPropertiesFieldNumber = 6,
    kCompatibleConditionsFieldNumber = 7,
    kSubModelsFieldNumber = 9,
    kRulesFieldNumber = 11,
    kMutexStackFieldNumber = 12,
    kNameFieldNumber = 1,
    kDefaultDataFieldNumber = 10,
    kMarkovMatrixFieldNumber = 15,
  };
  // repeated string dofs = 3;
  int dofs_size() const;
  private:
  int _internal_dofs_size() const;
  public:
  void clear_dofs();
  const std::string& dofs(int index) const;
  std::string* mutable_dofs(int index);
  void set_dofs(int index, const std::string& value);
  void set_dofs(int index, std::string&& value);
  void set_dofs(int index, const char* value);
  void set_dofs(int index, const char* value, size_t size);
  std::string* add_dofs();
  void add_dofs(const std::string& value);
  void add_dofs(std::string&& value);
  void add_dofs(const char* value);
  void add_dofs(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& dofs() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_dofs();
  private:
  const std::string& _internal_dofs(int index) const;
  std::string* _internal_add_dofs();
  public:

  // repeated string algorithms = 4;
  int algorithms_size() const;
  private:
  int _internal_algorithms_size() const;
  public:
  void clear_algorithms();
  const std::string& algorithms(int index) const;
  std::string* mutable_algorithms(int index);
  void set_algorithms(int index, const std::string& value);
  void set_algorithms(int index, std::string&& value);
  void set_algorithms(int index, const char* value);
  void set_algorithms(int index, const char* value, size_t size);
  std::string* add_algorithms();
  void add_algorithms(const std::string& value);
  void add_algorithms(std::string&& value);
  void add_algorithms(const char* value);
  void add_algorithms(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& algorithms() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_algorithms();
  private:
  const std::string& _internal_algorithms(int index) const;
  std::string* _internal_add_algorithms();
  public:

  // repeated string available_outputs = 5;
  int available_outputs_size() const;
  private:
  int _internal_available_outputs_size() const;
  public:
  void clear_available_outputs();
  const std::string& available_outputs(int index) const;
  std::string* mutable_available_outputs(int index);
  void set_available_outputs(int index, const std::string& value);
  void set_available_outputs(int index, std::string&& value);
  void set_available_outputs(int index, const char* value);
  void set_available_outputs(int index, const char* value, size_t size);
  std::string* add_available_outputs();
  void add_available_outputs(const std::string& value);
  void add_available_outputs(std::string&& value);
  void add_available_outputs(const char* value);
  void add_available_outputs(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& available_outputs() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_available_outputs();
  private:
  const std::string& _internal_available_outputs(int index) const;
  std::string* _internal_add_available_outputs();
  public:

  // repeated string extra_properties = 6;
  int extra_properties_size() const;
  private:
  int _internal_extra_properties_size() const;
  public:
  void clear_extra_properties();
  const std::string& extra_properties(int index) const;
  std::string* mutable_extra_properties(int index);
  void set_extra_properties(int index, const std::string& value);
  void set_extra_properties(int index, std::string&& value);
  void set_extra_properties(int index, const char* value);
  void set_extra_properties(int index, const char* value, size_t size);
  std::string* add_extra_properties();
  void add_extra_properties(const std::string& value);
  void add_extra_properties(std::string&& value);
  void add_extra_properties(const char* value);
  void add_extra_properties(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& extra_properties() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_extra_properties();
  private:
  const std::string& _internal_extra_properties(int index) const;
  std::string* _internal_add_extra_properties();
  public:

  // repeated string compatible_conditions = 7;
  int compatible_conditions_size() const;
  private:
  int _internal_compatible_conditions_size() const;
  public:
  void clear_compatible_conditions();
  const std::string& compatible_conditions(int index) const;
  std::string* mutable_compatible_conditions(int index);
  void set_compatible_conditions(int index, const std::string& value);
  void set_compatible_conditions(int index, std::string&& value);
  void set_compatible_conditions(int index, const char* value);
  void set_compatible_conditions(int index, const char* value, size_t size);
  std::string* add_compatible_conditions();
  void add_compatible_conditions(const std::string& value);
  void add_compatible_conditions(std::string&& value);
  void add_compatible_conditions(const char* value);
  void add_compatible_conditions(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& compatible_conditions() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_compatible_conditions();
  private:
  const std::string& _internal_compatible_conditions(int index) const;
  std::string* _internal_add_compatible_conditions();
  public:

  // repeated .Messages.Model sub_models = 9;
  int sub_models_size() const;
  private:
  int _internal_sub_models_size() const;
  public:
  void clear_sub_models();
  ::Messages::Model* mutable_sub_models(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Model >*
      mutable_sub_models();
  private:
  const ::Messages::Model& _internal_sub_models(int index) const;
  ::Messages::Model* _internal_add_sub_models();
  public:
  const ::Messages::Model& sub_models(int index) const;
  ::Messages::Model* add_sub_models();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Model >&
      sub_models() const;

  // repeated .Messages.Rule rules = 11;
  int rules_size() const;
  private:
  int _internal_rules_size() const;
  public:
  void clear_rules();
  ::Messages::Rule* mutable_rules(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >*
      mutable_rules();
  private:
  const ::Messages::Rule& _internal_rules(int index) const;
  ::Messages::Rule* _internal_add_rules();
  public:
  const ::Messages::Rule& rules(int index) const;
  ::Messages::Rule* add_rules();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >&
      rules() const;

  // repeated .Messages.Rule mutex_stack = 12;
  int mutex_stack_size() const;
  private:
  int _internal_mutex_stack_size() const;
  public:
  void clear_mutex_stack();
  ::Messages::Rule* mutable_mutex_stack(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >*
      mutable_mutex_stack();
  private:
  const ::Messages::Rule& _internal_mutex_stack(int index) const;
  ::Messages::Rule* _internal_add_mutex_stack();
  public:
  const ::Messages::Rule& mutex_stack(int index) const;
  ::Messages::Rule* add_mutex_stack();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >&
      mutex_stack() const;

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .Messages.Record64 default_data = 10;
  bool has_default_data() const;
  private:
  bool _internal_has_default_data() const;
  public:
  void clear_default_data();
  const ::Messages::Record64& default_data() const;
  PROTOBUF_NODISCARD ::Messages::Record64* release_default_data();
  ::Messages::Record64* mutable_default_data();
  void set_allocated_default_data(::Messages::Record64* default_data);
  private:
  const ::Messages::Record64& _internal_default_data() const;
  ::Messages::Record64* _internal_mutable_default_data();
  public:
  void unsafe_arena_set_allocated_default_data(
      ::Messages::Record64* default_data);
  ::Messages::Record64* unsafe_arena_release_default_data();

  // .Messages.SparseMatrix markov_matrix = 15;
  bool has_markov_matrix() const;
  private:
  bool _internal_has_markov_matrix() const;
  public:
  void clear_markov_matrix();
  const ::Messages::SparseMatrix& markov_matrix() const;
  PROTOBUF_NODISCARD ::Messages::SparseMatrix* release_markov_matrix();
  ::Messages::SparseMatrix* mutable_markov_matrix();
  void set_allocated_markov_matrix(::Messages::SparseMatrix* markov_matrix);
  private:
  const ::Messages::SparseMatrix& _internal_markov_matrix() const;
  ::Messages::SparseMatrix* _internal_mutable_markov_matrix();
  public:
  void unsafe_arena_set_allocated_markov_matrix(
      ::Messages::SparseMatrix* markov_matrix);
  ::Messages::SparseMatrix* unsafe_arena_release_markov_matrix();

  // @@protoc_insertion_point(class_scope:Messages.Model)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> dofs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> algorithms_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> available_outputs_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> extra_properties_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> compatible_conditions_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Model > sub_models_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule > rules_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule > mutex_stack_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::Messages::Record64* default_data_;
  ::Messages::SparseMatrix* markov_matrix_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_concept_2eproto;
};
// -------------------------------------------------------------------

class Coupling final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Messages.Coupling) */ {
 public:
  inline Coupling() : Coupling(nullptr) {}
  ~Coupling() override;
  explicit PROTOBUF_CONSTEXPR Coupling(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Coupling(const Coupling& from);
  Coupling(Coupling&& from) noexcept
    : Coupling() {
    *this = ::std::move(from);
  }

  inline Coupling& operator=(const Coupling& from) {
    CopyFrom(from);
    return *this;
  }
  inline Coupling& operator=(Coupling&& 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 Coupling& default_instance() {
    return *internal_default_instance();
  }
  static inline const Coupling* internal_default_instance() {
    return reinterpret_cast<const Coupling*>(
               &_Coupling_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(Coupling& a, Coupling& b) {
    a.Swap(&b);
  }
  inline void Swap(Coupling* 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(Coupling* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  Coupling* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<Coupling>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const Coupling& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const Coupling& 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;
  uint8_t* _InternalSerialize(
      uint8_t* 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(Coupling* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Messages.Coupling";
  }
  protected:
  explicit Coupling(::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 {
    kDofsFieldNumber = 11,
    kSourceSystemFieldNumber = 1,
    kTargetSystemFieldNumber = 2,
    kNameFieldNumber = 10,
    kSourceRegionFieldNumber = 5,
    kTargetRegionFieldNumber = 6,
    kRepresentationFieldNumber = 12,
    kSourceUidFieldNumber = 3,
    kTargetUidFieldNumber = 4,
    kSamplingModeFieldNumber = 9,
    kEnabledFieldNumber = 13,
    kForwardFieldNumber = 14,
    kReverseFieldNumber = 15,
  };
  // repeated string dofs = 11;
  int dofs_size() const;
  private:
  int _internal_dofs_size() const;
  public:
  void clear_dofs();
  const std::string& dofs(int index) const;
  std::string* mutable_dofs(int index);
  void set_dofs(int index, const std::string& value);
  void set_dofs(int index, std::string&& value);
  void set_dofs(int index, const char* value);
  void set_dofs(int index, const char* value, size_t size);
  std::string* add_dofs();
  void add_dofs(const std::string& value);
  void add_dofs(std::string&& value);
  void add_dofs(const char* value);
  void add_dofs(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& dofs() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_dofs();
  private:
  const std::string& _internal_dofs(int index) const;
  std::string* _internal_add_dofs();
  public:

  // string source_system = 1;
  void clear_source_system();
  const std::string& source_system() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_source_system(ArgT0&& arg0, ArgT... args);
  std::string* mutable_source_system();
  PROTOBUF_NODISCARD std::string* release_source_system();
  void set_allocated_source_system(std::string* source_system);
  private:
  const std::string& _internal_source_system() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_source_system(const std::string& value);
  std::string* _internal_mutable_source_system();
  public:

  // string target_system = 2;
  void clear_target_system();
  const std::string& target_system() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_target_system(ArgT0&& arg0, ArgT... args);
  std::string* mutable_target_system();
  PROTOBUF_NODISCARD std::string* release_target_system();
  void set_allocated_target_system(std::string* target_system);
  private:
  const std::string& _internal_target_system() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_target_system(const std::string& value);
  std::string* _internal_mutable_target_system();
  public:

  // string name = 10;
  void clear_name();
  const std::string& name() const;
  template <typename ArgT0 = const std::string&, typename... ArgT>
  void set_name(ArgT0&& arg0, ArgT... args);
  std::string* mutable_name();
  PROTOBUF_NODISCARD std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .Messages.Zone source_region = 5;
  bool has_source_region() const;
  private:
  bool _internal_has_source_region() const;
  public:
  void clear_source_region();
  const ::Messages::Zone& source_region() const;
  PROTOBUF_NODISCARD ::Messages::Zone* release_source_region();
  ::Messages::Zone* mutable_source_region();
  void set_allocated_source_region(::Messages::Zone* source_region);
  private:
  const ::Messages::Zone& _internal_source_region() const;
  ::Messages::Zone* _internal_mutable_source_region();
  public:
  void unsafe_arena_set_allocated_source_region(
      ::Messages::Zone* source_region);
  ::Messages::Zone* unsafe_arena_release_source_region();

  // .Messages.Zone target_region = 6;
  bool has_target_region() const;
  private:
  bool _internal_has_target_region() const;
  public:
  void clear_target_region();
  const ::Messages::Zone& target_region() const;
  PROTOBUF_NODISCARD ::Messages::Zone* release_target_region();
  ::Messages::Zone* mutable_target_region();
  void set_allocated_target_region(::Messages::Zone* target_region);
  private:
  const ::Messages::Zone& _internal_target_region() const;
  ::Messages::Zone* _internal_mutable_target_region();
  public:
  void unsafe_arena_set_allocated_target_region(
      ::Messages::Zone* target_region);
  ::Messages::Zone* unsafe_arena_release_target_region();

  // .Messages.Representation representation = 12;
  bool has_representation() const;
  private:
  bool _internal_has_representation() const;
  public:
  void clear_representation();
  const ::Messages::Representation& representation() const;
  PROTOBUF_NODISCARD ::Messages::Representation* release_representation();
  ::Messages::Representation* mutable_representation();
  void set_allocated_representation(::Messages::Representation* representation);
  private:
  const ::Messages::Representation& _internal_representation() const;
  ::Messages::Representation* _internal_mutable_representation();
  public:
  void unsafe_arena_set_allocated_representation(
      ::Messages::Representation* representation);
  ::Messages::Representation* unsafe_arena_release_representation();

  // int64 source_uid = 3;
  void clear_source_uid();
  int64_t source_uid() const;
  void set_source_uid(int64_t value);
  private:
  int64_t _internal_source_uid() const;
  void _internal_set_source_uid(int64_t value);
  public:

  // int64 target_uid = 4;
  void clear_target_uid();
  int64_t target_uid() const;
  void set_target_uid(int64_t value);
  private:
  int64_t _internal_target_uid() const;
  void _internal_set_target_uid(int64_t value);
  public:

  // uint32 sampling_mode = 9;
  void clear_sampling_mode();
  uint32_t sampling_mode() const;
  void set_sampling_mode(uint32_t value);
  private:
  uint32_t _internal_sampling_mode() const;
  void _internal_set_sampling_mode(uint32_t value);
  public:

  // bool enabled = 13;
  void clear_enabled();
  bool enabled() const;
  void set_enabled(bool value);
  private:
  bool _internal_enabled() const;
  void _internal_set_enabled(bool value);
  public:

  // bool forward = 14;
  void clear_forward();
  bool forward() const;
  void set_forward(bool value);
  private:
  bool _internal_forward() const;
  void _internal_set_forward(bool value);
  public:

  // bool reverse = 15;
  void clear_reverse();
  bool reverse() const;
  void set_reverse(bool value);
  private:
  bool _internal_reverse() const;
  void _internal_set_reverse(bool value);
  public:

  // @@protoc_insertion_point(class_scope:Messages.Coupling)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> dofs_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr source_system_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr target_system_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::Messages::Zone* source_region_;
  ::Messages::Zone* target_region_;
  ::Messages::Representation* representation_;
  int64_t source_uid_;
  int64_t target_uid_;
  uint32_t sampling_mode_;
  bool enabled_;
  bool forward_;
  bool reverse_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_concept_2eproto;
};
// -------------------------------------------------------------------

class System final :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:Messages.System) */ {
 public:
  inline System() : System(nullptr) {}
  ~System() override;
  explicit PROTOBUF_CONSTEXPR System(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  System(const System& from);
  System(System&& from) noexcept
    : System() {
    *this = ::std::move(from);
  }

  inline System& operator=(const System& from) {
    CopyFrom(from);
    return *this;
  }
  inline System& operator=(System&& 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 System& default_instance() {
    return *internal_default_instance();
  }
  static inline const System* internal_default_instance() {
    return reinterpret_cast<const System*>(
               &_System_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(System& a, System& b) {
    a.Swap(&b);
  }
  inline void Swap(System* 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(System* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
    InternalSwap(other);
  }

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

  System* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
    return CreateMaybeMessage<System>(arena);
  }
  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
  void CopyFrom(const System& from);
  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
  void MergeFrom(const System& 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;
  uint8_t* _InternalSerialize(
      uint8_t* 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(System* other);

  private:
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "Messages.System";
  }
  protected:
  explicit System(::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 {
    kScriptFieldNumber = 2,
    kLocalTransformFieldNumber = 3,
    kLocalRateFieldNumber = 4,
    kLocalAccelFieldNumber = 5,
    kChildrenFieldNumber = 6,
    kReferencedFilesFieldNumber = 7,
    kEmbeddedFilesFieldNumber = 8,
    kNotesFieldNumber = 9,
    kCouplingsFieldNumber = 10,
    kModelsFieldNumber = 11,
    kConditionsFieldNumber = 13,
    kMetaFieldNumber = 1,
    kPhysicalConstantsFieldNumber = 12,
  };
  // repeated .Messages.Script script = 2;
  int script_size() const;
  private:
  int _internal_script_size() const;
  public:
  void clear_script();
  ::Messages::Script* mutable_script(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Script >*
      mutable_script();
  private:
  const ::Messages::Script& _internal_script(int index) const;
  ::Messages::Script* _internal_add_script();
  public:
  const ::Messages::Script& script(int index) const;
  ::Messages::Script* add_script();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Script >&
      script() const;

  // repeated double local_transform = 3;
  int local_transform_size() const;
  private:
  int _internal_local_transform_size() const;
  public:
  void clear_local_transform();
  private:
  double _internal_local_transform(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_local_transform() const;
  void _internal_add_local_transform(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_local_transform();
  public:
  double local_transform(int index) const;
  void set_local_transform(int index, double value);
  void add_local_transform(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      local_transform() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_local_transform();

  // repeated double local_rate = 4;
  int local_rate_size() const;
  private:
  int _internal_local_rate_size() const;
  public:
  void clear_local_rate();
  private:
  double _internal_local_rate(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_local_rate() const;
  void _internal_add_local_rate(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_local_rate();
  public:
  double local_rate(int index) const;
  void set_local_rate(int index, double value);
  void add_local_rate(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      local_rate() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_local_rate();

  // repeated double local_accel = 5;
  int local_accel_size() const;
  private:
  int _internal_local_accel_size() const;
  public:
  void clear_local_accel();
  private:
  double _internal_local_accel(int index) const;
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      _internal_local_accel() const;
  void _internal_add_local_accel(double value);
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      _internal_mutable_local_accel();
  public:
  double local_accel(int index) const;
  void set_local_accel(int index, double value);
  void add_local_accel(double value);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
      local_accel() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
      mutable_local_accel();

  // repeated string children = 6;
  int children_size() const;
  private:
  int _internal_children_size() const;
  public:
  void clear_children();
  const std::string& children(int index) const;
  std::string* mutable_children(int index);
  void set_children(int index, const std::string& value);
  void set_children(int index, std::string&& value);
  void set_children(int index, const char* value);
  void set_children(int index, const char* value, size_t size);
  std::string* add_children();
  void add_children(const std::string& value);
  void add_children(std::string&& value);
  void add_children(const char* value);
  void add_children(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& children() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_children();
  private:
  const std::string& _internal_children(int index) const;
  std::string* _internal_add_children();
  public:

  // repeated string referenced_files = 7;
  int referenced_files_size() const;
  private:
  int _internal_referenced_files_size() const;
  public:
  void clear_referenced_files();
  const std::string& referenced_files(int index) const;
  std::string* mutable_referenced_files(int index);
  void set_referenced_files(int index, const std::string& value);
  void set_referenced_files(int index, std::string&& value);
  void set_referenced_files(int index, const char* value);
  void set_referenced_files(int index, const char* value, size_t size);
  std::string* add_referenced_files();
  void add_referenced_files(const std::string& value);
  void add_referenced_files(std::string&& value);
  void add_referenced_files(const char* value);
  void add_referenced_files(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& referenced_files() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_referenced_files();
  private:
  const std::string& _internal_referenced_files(int index) const;
  std::string* _internal_add_referenced_files();
  public:

  // repeated .Messages.File embedded_files = 8;
  int embedded_files_size() const;
  private:
  int _internal_embedded_files_size() const;
  public:
  void clear_embedded_files();
  ::Messages::File* mutable_embedded_files(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::File >*
      mutable_embedded_files();
  private:
  const ::Messages::File& _internal_embedded_files(int index) const;
  ::Messages::File* _internal_add_embedded_files();
  public:
  const ::Messages::File& embedded_files(int index) const;
  ::Messages::File* add_embedded_files();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::File >&
      embedded_files() const;

  // repeated string notes = 9;
  int notes_size() const;
  private:
  int _internal_notes_size() const;
  public:
  void clear_notes();
  const std::string& notes(int index) const;
  std::string* mutable_notes(int index);
  void set_notes(int index, const std::string& value);
  void set_notes(int index, std::string&& value);
  void set_notes(int index, const char* value);
  void set_notes(int index, const char* value, size_t size);
  std::string* add_notes();
  void add_notes(const std::string& value);
  void add_notes(std::string&& value);
  void add_notes(const char* value);
  void add_notes(const char* value, size_t size);
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& notes() const;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_notes();
  private:
  const std::string& _internal_notes(int index) const;
  std::string* _internal_add_notes();
  public:

  // repeated .Messages.Coupling couplings = 10;
  int couplings_size() const;
  private:
  int _internal_couplings_size() const;
  public:
  void clear_couplings();
  ::Messages::Coupling* mutable_couplings(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Coupling >*
      mutable_couplings();
  private:
  const ::Messages::Coupling& _internal_couplings(int index) const;
  ::Messages::Coupling* _internal_add_couplings();
  public:
  const ::Messages::Coupling& couplings(int index) const;
  ::Messages::Coupling* add_couplings();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Coupling >&
      couplings() const;

  // repeated .Messages.Model models = 11;
  int models_size() const;
  private:
  int _internal_models_size() const;
  public:
  void clear_models();
  ::Messages::Model* mutable_models(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Model >*
      mutable_models();
  private:
  const ::Messages::Model& _internal_models(int index) const;
  ::Messages::Model* _internal_add_models();
  public:
  const ::Messages::Model& models(int index) const;
  ::Messages::Model* add_models();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Model >&
      models() const;

  // repeated .Messages.Command conditions = 13;
  int conditions_size() const;
  private:
  int _internal_conditions_size() const;
  public:
  void clear_conditions();
  ::Messages::Command* mutable_conditions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >*
      mutable_conditions();
  private:
  const ::Messages::Command& _internal_conditions(int index) const;
  ::Messages::Command* _internal_add_conditions();
  public:
  const ::Messages::Command& conditions(int index) const;
  ::Messages::Command* add_conditions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >&
      conditions() const;

  // .Messages.Meta meta = 1;
  bool has_meta() const;
  private:
  bool _internal_has_meta() const;
  public:
  void clear_meta();
  const ::Messages::Meta& meta() const;
  PROTOBUF_NODISCARD ::Messages::Meta* release_meta();
  ::Messages::Meta* mutable_meta();
  void set_allocated_meta(::Messages::Meta* meta);
  private:
  const ::Messages::Meta& _internal_meta() const;
  ::Messages::Meta* _internal_mutable_meta();
  public:
  void unsafe_arena_set_allocated_meta(
      ::Messages::Meta* meta);
  ::Messages::Meta* unsafe_arena_release_meta();

  // .Messages.Record64 physical_constants = 12;
  bool has_physical_constants() const;
  private:
  bool _internal_has_physical_constants() const;
  public:
  void clear_physical_constants();
  const ::Messages::Record64& physical_constants() const;
  PROTOBUF_NODISCARD ::Messages::Record64* release_physical_constants();
  ::Messages::Record64* mutable_physical_constants();
  void set_allocated_physical_constants(::Messages::Record64* physical_constants);
  private:
  const ::Messages::Record64& _internal_physical_constants() const;
  ::Messages::Record64* _internal_mutable_physical_constants();
  public:
  void unsafe_arena_set_allocated_physical_constants(
      ::Messages::Record64* physical_constants);
  ::Messages::Record64* unsafe_arena_release_physical_constants();

  // @@protoc_insertion_point(class_scope:Messages.System)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Script > script_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > local_transform_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > local_rate_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedField< double > local_accel_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> children_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> referenced_files_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::File > embedded_files_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> notes_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Coupling > couplings_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Model > models_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command > conditions_;
  ::Messages::Meta* meta_;
  ::Messages::Record64* physical_constants_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_concept_2eproto;
};
// ===================================================================


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

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

// repeated string int_names = 2;
inline int Variables::_internal_int_names_size() const {
  return int_names_.size();
}
inline int Variables::int_names_size() const {
  return _internal_int_names_size();
}
inline void Variables::clear_int_names() {
  int_names_.Clear();
}
inline std::string* Variables::add_int_names() {
  std::string* _s = _internal_add_int_names();
  // @@protoc_insertion_point(field_add_mutable:Messages.Variables.int_names)
  return _s;
}
inline const std::string& Variables::_internal_int_names(int index) const {
  return int_names_.Get(index);
}
inline const std::string& Variables::int_names(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.int_names)
  return _internal_int_names(index);
}
inline std::string* Variables::mutable_int_names(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Variables.int_names)
  return int_names_.Mutable(index);
}
inline void Variables::set_int_names(int index, const std::string& value) {
  int_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Variables.int_names)
}
inline void Variables::set_int_names(int index, std::string&& value) {
  int_names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Variables.int_names)
}
inline void Variables::set_int_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  int_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Variables.int_names)
}
inline void Variables::set_int_names(int index, const char* value, size_t size) {
  int_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Variables.int_names)
}
inline std::string* Variables::_internal_add_int_names() {
  return int_names_.Add();
}
inline void Variables::add_int_names(const std::string& value) {
  int_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.int_names)
}
inline void Variables::add_int_names(std::string&& value) {
  int_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Variables.int_names)
}
inline void Variables::add_int_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  int_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Variables.int_names)
}
inline void Variables::add_int_names(const char* value, size_t size) {
  int_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Variables.int_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Variables::int_names() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.int_names)
  return int_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Variables::mutable_int_names() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.int_names)
  return &int_names_;
}

// repeated int32 int_values = 3;
inline int Variables::_internal_int_values_size() const {
  return int_values_.size();
}
inline int Variables::int_values_size() const {
  return _internal_int_values_size();
}
inline void Variables::clear_int_values() {
  int_values_.Clear();
}
inline int32_t Variables::_internal_int_values(int index) const {
  return int_values_.Get(index);
}
inline int32_t Variables::int_values(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.int_values)
  return _internal_int_values(index);
}
inline void Variables::set_int_values(int index, int32_t value) {
  int_values_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Variables.int_values)
}
inline void Variables::_internal_add_int_values(int32_t value) {
  int_values_.Add(value);
}
inline void Variables::add_int_values(int32_t value) {
  _internal_add_int_values(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.int_values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Variables::_internal_int_values() const {
  return int_values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&
Variables::int_values() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.int_values)
  return _internal_int_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Variables::_internal_mutable_int_values() {
  return &int_values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*
Variables::mutable_int_values() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.int_values)
  return _internal_mutable_int_values();
}

// repeated string int_descriptions = 4;
inline int Variables::_internal_int_descriptions_size() const {
  return int_descriptions_.size();
}
inline int Variables::int_descriptions_size() const {
  return _internal_int_descriptions_size();
}
inline void Variables::clear_int_descriptions() {
  int_descriptions_.Clear();
}
inline std::string* Variables::add_int_descriptions() {
  std::string* _s = _internal_add_int_descriptions();
  // @@protoc_insertion_point(field_add_mutable:Messages.Variables.int_descriptions)
  return _s;
}
inline const std::string& Variables::_internal_int_descriptions(int index) const {
  return int_descriptions_.Get(index);
}
inline const std::string& Variables::int_descriptions(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.int_descriptions)
  return _internal_int_descriptions(index);
}
inline std::string* Variables::mutable_int_descriptions(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Variables.int_descriptions)
  return int_descriptions_.Mutable(index);
}
inline void Variables::set_int_descriptions(int index, const std::string& value) {
  int_descriptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Variables.int_descriptions)
}
inline void Variables::set_int_descriptions(int index, std::string&& value) {
  int_descriptions_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Variables.int_descriptions)
}
inline void Variables::set_int_descriptions(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  int_descriptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Variables.int_descriptions)
}
inline void Variables::set_int_descriptions(int index, const char* value, size_t size) {
  int_descriptions_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Variables.int_descriptions)
}
inline std::string* Variables::_internal_add_int_descriptions() {
  return int_descriptions_.Add();
}
inline void Variables::add_int_descriptions(const std::string& value) {
  int_descriptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.int_descriptions)
}
inline void Variables::add_int_descriptions(std::string&& value) {
  int_descriptions_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Variables.int_descriptions)
}
inline void Variables::add_int_descriptions(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  int_descriptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Variables.int_descriptions)
}
inline void Variables::add_int_descriptions(const char* value, size_t size) {
  int_descriptions_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Variables.int_descriptions)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Variables::int_descriptions() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.int_descriptions)
  return int_descriptions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Variables::mutable_int_descriptions() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.int_descriptions)
  return &int_descriptions_;
}

// repeated string bool_names = 6;
inline int Variables::_internal_bool_names_size() const {
  return bool_names_.size();
}
inline int Variables::bool_names_size() const {
  return _internal_bool_names_size();
}
inline void Variables::clear_bool_names() {
  bool_names_.Clear();
}
inline std::string* Variables::add_bool_names() {
  std::string* _s = _internal_add_bool_names();
  // @@protoc_insertion_point(field_add_mutable:Messages.Variables.bool_names)
  return _s;
}
inline const std::string& Variables::_internal_bool_names(int index) const {
  return bool_names_.Get(index);
}
inline const std::string& Variables::bool_names(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.bool_names)
  return _internal_bool_names(index);
}
inline std::string* Variables::mutable_bool_names(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Variables.bool_names)
  return bool_names_.Mutable(index);
}
inline void Variables::set_bool_names(int index, const std::string& value) {
  bool_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Variables.bool_names)
}
inline void Variables::set_bool_names(int index, std::string&& value) {
  bool_names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Variables.bool_names)
}
inline void Variables::set_bool_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  bool_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Variables.bool_names)
}
inline void Variables::set_bool_names(int index, const char* value, size_t size) {
  bool_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Variables.bool_names)
}
inline std::string* Variables::_internal_add_bool_names() {
  return bool_names_.Add();
}
inline void Variables::add_bool_names(const std::string& value) {
  bool_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.bool_names)
}
inline void Variables::add_bool_names(std::string&& value) {
  bool_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Variables.bool_names)
}
inline void Variables::add_bool_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  bool_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Variables.bool_names)
}
inline void Variables::add_bool_names(const char* value, size_t size) {
  bool_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Variables.bool_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Variables::bool_names() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.bool_names)
  return bool_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Variables::mutable_bool_names() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.bool_names)
  return &bool_names_;
}

// repeated bool bool_values = 7;
inline int Variables::_internal_bool_values_size() const {
  return bool_values_.size();
}
inline int Variables::bool_values_size() const {
  return _internal_bool_values_size();
}
inline void Variables::clear_bool_values() {
  bool_values_.Clear();
}
inline bool Variables::_internal_bool_values(int index) const {
  return bool_values_.Get(index);
}
inline bool Variables::bool_values(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.bool_values)
  return _internal_bool_values(index);
}
inline void Variables::set_bool_values(int index, bool value) {
  bool_values_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Variables.bool_values)
}
inline void Variables::_internal_add_bool_values(bool value) {
  bool_values_.Add(value);
}
inline void Variables::add_bool_values(bool value) {
  _internal_add_bool_values(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.bool_values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
Variables::_internal_bool_values() const {
  return bool_values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&
Variables::bool_values() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.bool_values)
  return _internal_bool_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
Variables::_internal_mutable_bool_values() {
  return &bool_values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*
Variables::mutable_bool_values() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.bool_values)
  return _internal_mutable_bool_values();
}

// repeated string bool_descriptions = 8;
inline int Variables::_internal_bool_descriptions_size() const {
  return bool_descriptions_.size();
}
inline int Variables::bool_descriptions_size() const {
  return _internal_bool_descriptions_size();
}
inline void Variables::clear_bool_descriptions() {
  bool_descriptions_.Clear();
}
inline std::string* Variables::add_bool_descriptions() {
  std::string* _s = _internal_add_bool_descriptions();
  // @@protoc_insertion_point(field_add_mutable:Messages.Variables.bool_descriptions)
  return _s;
}
inline const std::string& Variables::_internal_bool_descriptions(int index) const {
  return bool_descriptions_.Get(index);
}
inline const std::string& Variables::bool_descriptions(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.bool_descriptions)
  return _internal_bool_descriptions(index);
}
inline std::string* Variables::mutable_bool_descriptions(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Variables.bool_descriptions)
  return bool_descriptions_.Mutable(index);
}
inline void Variables::set_bool_descriptions(int index, const std::string& value) {
  bool_descriptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Variables.bool_descriptions)
}
inline void Variables::set_bool_descriptions(int index, std::string&& value) {
  bool_descriptions_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Variables.bool_descriptions)
}
inline void Variables::set_bool_descriptions(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  bool_descriptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Variables.bool_descriptions)
}
inline void Variables::set_bool_descriptions(int index, const char* value, size_t size) {
  bool_descriptions_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Variables.bool_descriptions)
}
inline std::string* Variables::_internal_add_bool_descriptions() {
  return bool_descriptions_.Add();
}
inline void Variables::add_bool_descriptions(const std::string& value) {
  bool_descriptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.bool_descriptions)
}
inline void Variables::add_bool_descriptions(std::string&& value) {
  bool_descriptions_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Variables.bool_descriptions)
}
inline void Variables::add_bool_descriptions(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  bool_descriptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Variables.bool_descriptions)
}
inline void Variables::add_bool_descriptions(const char* value, size_t size) {
  bool_descriptions_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Variables.bool_descriptions)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Variables::bool_descriptions() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.bool_descriptions)
  return bool_descriptions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Variables::mutable_bool_descriptions() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.bool_descriptions)
  return &bool_descriptions_;
}

// repeated string double_names = 10;
inline int Variables::_internal_double_names_size() const {
  return double_names_.size();
}
inline int Variables::double_names_size() const {
  return _internal_double_names_size();
}
inline void Variables::clear_double_names() {
  double_names_.Clear();
}
inline std::string* Variables::add_double_names() {
  std::string* _s = _internal_add_double_names();
  // @@protoc_insertion_point(field_add_mutable:Messages.Variables.double_names)
  return _s;
}
inline const std::string& Variables::_internal_double_names(int index) const {
  return double_names_.Get(index);
}
inline const std::string& Variables::double_names(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.double_names)
  return _internal_double_names(index);
}
inline std::string* Variables::mutable_double_names(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Variables.double_names)
  return double_names_.Mutable(index);
}
inline void Variables::set_double_names(int index, const std::string& value) {
  double_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Variables.double_names)
}
inline void Variables::set_double_names(int index, std::string&& value) {
  double_names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Variables.double_names)
}
inline void Variables::set_double_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  double_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Variables.double_names)
}
inline void Variables::set_double_names(int index, const char* value, size_t size) {
  double_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Variables.double_names)
}
inline std::string* Variables::_internal_add_double_names() {
  return double_names_.Add();
}
inline void Variables::add_double_names(const std::string& value) {
  double_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.double_names)
}
inline void Variables::add_double_names(std::string&& value) {
  double_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Variables.double_names)
}
inline void Variables::add_double_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  double_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Variables.double_names)
}
inline void Variables::add_double_names(const char* value, size_t size) {
  double_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Variables.double_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Variables::double_names() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.double_names)
  return double_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Variables::mutable_double_names() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.double_names)
  return &double_names_;
}

// repeated double double_values = 11;
inline int Variables::_internal_double_values_size() const {
  return double_values_.size();
}
inline int Variables::double_values_size() const {
  return _internal_double_values_size();
}
inline void Variables::clear_double_values() {
  double_values_.Clear();
}
inline double Variables::_internal_double_values(int index) const {
  return double_values_.Get(index);
}
inline double Variables::double_values(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.double_values)
  return _internal_double_values(index);
}
inline void Variables::set_double_values(int index, double value) {
  double_values_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.Variables.double_values)
}
inline void Variables::_internal_add_double_values(double value) {
  double_values_.Add(value);
}
inline void Variables::add_double_values(double value) {
  _internal_add_double_values(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.double_values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Variables::_internal_double_values() const {
  return double_values_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
Variables::double_values() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.double_values)
  return _internal_double_values();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Variables::_internal_mutable_double_values() {
  return &double_values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
Variables::mutable_double_values() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.double_values)
  return _internal_mutable_double_values();
}

// repeated string double_descriptions = 12;
inline int Variables::_internal_double_descriptions_size() const {
  return double_descriptions_.size();
}
inline int Variables::double_descriptions_size() const {
  return _internal_double_descriptions_size();
}
inline void Variables::clear_double_descriptions() {
  double_descriptions_.Clear();
}
inline std::string* Variables::add_double_descriptions() {
  std::string* _s = _internal_add_double_descriptions();
  // @@protoc_insertion_point(field_add_mutable:Messages.Variables.double_descriptions)
  return _s;
}
inline const std::string& Variables::_internal_double_descriptions(int index) const {
  return double_descriptions_.Get(index);
}
inline const std::string& Variables::double_descriptions(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.double_descriptions)
  return _internal_double_descriptions(index);
}
inline std::string* Variables::mutable_double_descriptions(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Variables.double_descriptions)
  return double_descriptions_.Mutable(index);
}
inline void Variables::set_double_descriptions(int index, const std::string& value) {
  double_descriptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Variables.double_descriptions)
}
inline void Variables::set_double_descriptions(int index, std::string&& value) {
  double_descriptions_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Variables.double_descriptions)
}
inline void Variables::set_double_descriptions(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  double_descriptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Variables.double_descriptions)
}
inline void Variables::set_double_descriptions(int index, const char* value, size_t size) {
  double_descriptions_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Variables.double_descriptions)
}
inline std::string* Variables::_internal_add_double_descriptions() {
  return double_descriptions_.Add();
}
inline void Variables::add_double_descriptions(const std::string& value) {
  double_descriptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.double_descriptions)
}
inline void Variables::add_double_descriptions(std::string&& value) {
  double_descriptions_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Variables.double_descriptions)
}
inline void Variables::add_double_descriptions(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  double_descriptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Variables.double_descriptions)
}
inline void Variables::add_double_descriptions(const char* value, size_t size) {
  double_descriptions_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Variables.double_descriptions)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Variables::double_descriptions() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.double_descriptions)
  return double_descriptions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Variables::mutable_double_descriptions() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.double_descriptions)
  return &double_descriptions_;
}

// repeated string string_names = 14;
inline int Variables::_internal_string_names_size() const {
  return string_names_.size();
}
inline int Variables::string_names_size() const {
  return _internal_string_names_size();
}
inline void Variables::clear_string_names() {
  string_names_.Clear();
}
inline std::string* Variables::add_string_names() {
  std::string* _s = _internal_add_string_names();
  // @@protoc_insertion_point(field_add_mutable:Messages.Variables.string_names)
  return _s;
}
inline const std::string& Variables::_internal_string_names(int index) const {
  return string_names_.Get(index);
}
inline const std::string& Variables::string_names(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.string_names)
  return _internal_string_names(index);
}
inline std::string* Variables::mutable_string_names(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Variables.string_names)
  return string_names_.Mutable(index);
}
inline void Variables::set_string_names(int index, const std::string& value) {
  string_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Variables.string_names)
}
inline void Variables::set_string_names(int index, std::string&& value) {
  string_names_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Variables.string_names)
}
inline void Variables::set_string_names(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  string_names_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Variables.string_names)
}
inline void Variables::set_string_names(int index, const char* value, size_t size) {
  string_names_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Variables.string_names)
}
inline std::string* Variables::_internal_add_string_names() {
  return string_names_.Add();
}
inline void Variables::add_string_names(const std::string& value) {
  string_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.string_names)
}
inline void Variables::add_string_names(std::string&& value) {
  string_names_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Variables.string_names)
}
inline void Variables::add_string_names(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  string_names_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Variables.string_names)
}
inline void Variables::add_string_names(const char* value, size_t size) {
  string_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Variables.string_names)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Variables::string_names() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.string_names)
  return string_names_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Variables::mutable_string_names() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.string_names)
  return &string_names_;
}

// repeated string string_values = 15;
inline int Variables::_internal_string_values_size() const {
  return string_values_.size();
}
inline int Variables::string_values_size() const {
  return _internal_string_values_size();
}
inline void Variables::clear_string_values() {
  string_values_.Clear();
}
inline std::string* Variables::add_string_values() {
  std::string* _s = _internal_add_string_values();
  // @@protoc_insertion_point(field_add_mutable:Messages.Variables.string_values)
  return _s;
}
inline const std::string& Variables::_internal_string_values(int index) const {
  return string_values_.Get(index);
}
inline const std::string& Variables::string_values(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.string_values)
  return _internal_string_values(index);
}
inline std::string* Variables::mutable_string_values(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Variables.string_values)
  return string_values_.Mutable(index);
}
inline void Variables::set_string_values(int index, const std::string& value) {
  string_values_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Variables.string_values)
}
inline void Variables::set_string_values(int index, std::string&& value) {
  string_values_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Variables.string_values)
}
inline void Variables::set_string_values(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  string_values_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Variables.string_values)
}
inline void Variables::set_string_values(int index, const char* value, size_t size) {
  string_values_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Variables.string_values)
}
inline std::string* Variables::_internal_add_string_values() {
  return string_values_.Add();
}
inline void Variables::add_string_values(const std::string& value) {
  string_values_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.string_values)
}
inline void Variables::add_string_values(std::string&& value) {
  string_values_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Variables.string_values)
}
inline void Variables::add_string_values(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  string_values_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Variables.string_values)
}
inline void Variables::add_string_values(const char* value, size_t size) {
  string_values_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Variables.string_values)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Variables::string_values() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.string_values)
  return string_values_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Variables::mutable_string_values() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.string_values)
  return &string_values_;
}

// repeated string string_descriptions = 16;
inline int Variables::_internal_string_descriptions_size() const {
  return string_descriptions_.size();
}
inline int Variables::string_descriptions_size() const {
  return _internal_string_descriptions_size();
}
inline void Variables::clear_string_descriptions() {
  string_descriptions_.Clear();
}
inline std::string* Variables::add_string_descriptions() {
  std::string* _s = _internal_add_string_descriptions();
  // @@protoc_insertion_point(field_add_mutable:Messages.Variables.string_descriptions)
  return _s;
}
inline const std::string& Variables::_internal_string_descriptions(int index) const {
  return string_descriptions_.Get(index);
}
inline const std::string& Variables::string_descriptions(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Variables.string_descriptions)
  return _internal_string_descriptions(index);
}
inline std::string* Variables::mutable_string_descriptions(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Variables.string_descriptions)
  return string_descriptions_.Mutable(index);
}
inline void Variables::set_string_descriptions(int index, const std::string& value) {
  string_descriptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Variables.string_descriptions)
}
inline void Variables::set_string_descriptions(int index, std::string&& value) {
  string_descriptions_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Variables.string_descriptions)
}
inline void Variables::set_string_descriptions(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  string_descriptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Variables.string_descriptions)
}
inline void Variables::set_string_descriptions(int index, const char* value, size_t size) {
  string_descriptions_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Variables.string_descriptions)
}
inline std::string* Variables::_internal_add_string_descriptions() {
  return string_descriptions_.Add();
}
inline void Variables::add_string_descriptions(const std::string& value) {
  string_descriptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Variables.string_descriptions)
}
inline void Variables::add_string_descriptions(std::string&& value) {
  string_descriptions_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Variables.string_descriptions)
}
inline void Variables::add_string_descriptions(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  string_descriptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Variables.string_descriptions)
}
inline void Variables::add_string_descriptions(const char* value, size_t size) {
  string_descriptions_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Variables.string_descriptions)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Variables::string_descriptions() const {
  // @@protoc_insertion_point(field_list:Messages.Variables.string_descriptions)
  return string_descriptions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Variables::mutable_string_descriptions() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Variables.string_descriptions)
  return &string_descriptions_;
}

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

// Function

// string name = 1;
inline void Function::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& Function::name() const {
  // @@protoc_insertion_point(field_get:Messages.Function.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Function::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Function.name)
}
inline std::string* Function::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:Messages.Function.name)
  return _s;
}
inline const std::string& Function::_internal_name() const {
  return name_.Get();
}
inline void Function::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* Function::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* Function::release_name() {
  // @@protoc_insertion_point(field_release:Messages.Function.name)
  return name_.Release();
}
inline void Function::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault()) {
    name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Function.name)
}

// repeated string argument_types = 2;
inline int Function::_internal_argument_types_size() const {
  return argument_types_.size();
}
inline int Function::argument_types_size() const {
  return _internal_argument_types_size();
}
inline void Function::clear_argument_types() {
  argument_types_.Clear();
}
inline std::string* Function::add_argument_types() {
  std::string* _s = _internal_add_argument_types();
  // @@protoc_insertion_point(field_add_mutable:Messages.Function.argument_types)
  return _s;
}
inline const std::string& Function::_internal_argument_types(int index) const {
  return argument_types_.Get(index);
}
inline const std::string& Function::argument_types(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Function.argument_types)
  return _internal_argument_types(index);
}
inline std::string* Function::mutable_argument_types(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Function.argument_types)
  return argument_types_.Mutable(index);
}
inline void Function::set_argument_types(int index, const std::string& value) {
  argument_types_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Function.argument_types)
}
inline void Function::set_argument_types(int index, std::string&& value) {
  argument_types_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Function.argument_types)
}
inline void Function::set_argument_types(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  argument_types_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Function.argument_types)
}
inline void Function::set_argument_types(int index, const char* value, size_t size) {
  argument_types_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Function.argument_types)
}
inline std::string* Function::_internal_add_argument_types() {
  return argument_types_.Add();
}
inline void Function::add_argument_types(const std::string& value) {
  argument_types_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Function.argument_types)
}
inline void Function::add_argument_types(std::string&& value) {
  argument_types_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Function.argument_types)
}
inline void Function::add_argument_types(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  argument_types_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Function.argument_types)
}
inline void Function::add_argument_types(const char* value, size_t size) {
  argument_types_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Function.argument_types)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Function::argument_types() const {
  // @@protoc_insertion_point(field_list:Messages.Function.argument_types)
  return argument_types_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Function::mutable_argument_types() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Function.argument_types)
  return &argument_types_;
}

// repeated string argument_descriptions = 3;
inline int Function::_internal_argument_descriptions_size() const {
  return argument_descriptions_.size();
}
inline int Function::argument_descriptions_size() const {
  return _internal_argument_descriptions_size();
}
inline void Function::clear_argument_descriptions() {
  argument_descriptions_.Clear();
}
inline std::string* Function::add_argument_descriptions() {
  std::string* _s = _internal_add_argument_descriptions();
  // @@protoc_insertion_point(field_add_mutable:Messages.Function.argument_descriptions)
  return _s;
}
inline const std::string& Function::_internal_argument_descriptions(int index) const {
  return argument_descriptions_.Get(index);
}
inline const std::string& Function::argument_descriptions(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Function.argument_descriptions)
  return _internal_argument_descriptions(index);
}
inline std::string* Function::mutable_argument_descriptions(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Function.argument_descriptions)
  return argument_descriptions_.Mutable(index);
}
inline void Function::set_argument_descriptions(int index, const std::string& value) {
  argument_descriptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Function.argument_descriptions)
}
inline void Function::set_argument_descriptions(int index, std::string&& value) {
  argument_descriptions_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Function.argument_descriptions)
}
inline void Function::set_argument_descriptions(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  argument_descriptions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Function.argument_descriptions)
}
inline void Function::set_argument_descriptions(int index, const char* value, size_t size) {
  argument_descriptions_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Function.argument_descriptions)
}
inline std::string* Function::_internal_add_argument_descriptions() {
  return argument_descriptions_.Add();
}
inline void Function::add_argument_descriptions(const std::string& value) {
  argument_descriptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Function.argument_descriptions)
}
inline void Function::add_argument_descriptions(std::string&& value) {
  argument_descriptions_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Function.argument_descriptions)
}
inline void Function::add_argument_descriptions(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  argument_descriptions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Function.argument_descriptions)
}
inline void Function::add_argument_descriptions(const char* value, size_t size) {
  argument_descriptions_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Function.argument_descriptions)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Function::argument_descriptions() const {
  // @@protoc_insertion_point(field_list:Messages.Function.argument_descriptions)
  return argument_descriptions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Function::mutable_argument_descriptions() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Function.argument_descriptions)
  return &argument_descriptions_;
}

// repeated string inputs = 4;
inline int Function::_internal_inputs_size() const {
  return inputs_.size();
}
inline int Function::inputs_size() const {
  return _internal_inputs_size();
}
inline void Function::clear_inputs() {
  inputs_.Clear();
}
inline std::string* Function::add_inputs() {
  std::string* _s = _internal_add_inputs();
  // @@protoc_insertion_point(field_add_mutable:Messages.Function.inputs)
  return _s;
}
inline const std::string& Function::_internal_inputs(int index) const {
  return inputs_.Get(index);
}
inline const std::string& Function::inputs(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Function.inputs)
  return _internal_inputs(index);
}
inline std::string* Function::mutable_inputs(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Function.inputs)
  return inputs_.Mutable(index);
}
inline void Function::set_inputs(int index, const std::string& value) {
  inputs_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Function.inputs)
}
inline void Function::set_inputs(int index, std::string&& value) {
  inputs_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Function.inputs)
}
inline void Function::set_inputs(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  inputs_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Function.inputs)
}
inline void Function::set_inputs(int index, const char* value, size_t size) {
  inputs_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Function.inputs)
}
inline std::string* Function::_internal_add_inputs() {
  return inputs_.Add();
}
inline void Function::add_inputs(const std::string& value) {
  inputs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Function.inputs)
}
inline void Function::add_inputs(std::string&& value) {
  inputs_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Function.inputs)
}
inline void Function::add_inputs(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  inputs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Function.inputs)
}
inline void Function::add_inputs(const char* value, size_t size) {
  inputs_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Function.inputs)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Function::inputs() const {
  // @@protoc_insertion_point(field_list:Messages.Function.inputs)
  return inputs_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Function::mutable_inputs() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Function.inputs)
  return &inputs_;
}

// repeated string outputs = 5;
inline int Function::_internal_outputs_size() const {
  return outputs_.size();
}
inline int Function::outputs_size() const {
  return _internal_outputs_size();
}
inline void Function::clear_outputs() {
  outputs_.Clear();
}
inline std::string* Function::add_outputs() {
  std::string* _s = _internal_add_outputs();
  // @@protoc_insertion_point(field_add_mutable:Messages.Function.outputs)
  return _s;
}
inline const std::string& Function::_internal_outputs(int index) const {
  return outputs_.Get(index);
}
inline const std::string& Function::outputs(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Function.outputs)
  return _internal_outputs(index);
}
inline std::string* Function::mutable_outputs(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Function.outputs)
  return outputs_.Mutable(index);
}
inline void Function::set_outputs(int index, const std::string& value) {
  outputs_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Function.outputs)
}
inline void Function::set_outputs(int index, std::string&& value) {
  outputs_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Function.outputs)
}
inline void Function::set_outputs(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  outputs_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Function.outputs)
}
inline void Function::set_outputs(int index, const char* value, size_t size) {
  outputs_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Function.outputs)
}
inline std::string* Function::_internal_add_outputs() {
  return outputs_.Add();
}
inline void Function::add_outputs(const std::string& value) {
  outputs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Function.outputs)
}
inline void Function::add_outputs(std::string&& value) {
  outputs_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Function.outputs)
}
inline void Function::add_outputs(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  outputs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Function.outputs)
}
inline void Function::add_outputs(const char* value, size_t size) {
  outputs_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Function.outputs)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Function::outputs() const {
  // @@protoc_insertion_point(field_list:Messages.Function.outputs)
  return outputs_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Function::mutable_outputs() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Function.outputs)
  return &outputs_;
}

// repeated string constants = 6;
inline int Function::_internal_constants_size() const {
  return constants_.size();
}
inline int Function::constants_size() const {
  return _internal_constants_size();
}
inline void Function::clear_constants() {
  constants_.Clear();
}
inline std::string* Function::add_constants() {
  std::string* _s = _internal_add_constants();
  // @@protoc_insertion_point(field_add_mutable:Messages.Function.constants)
  return _s;
}
inline const std::string& Function::_internal_constants(int index) const {
  return constants_.Get(index);
}
inline const std::string& Function::constants(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Function.constants)
  return _internal_constants(index);
}
inline std::string* Function::mutable_constants(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Function.constants)
  return constants_.Mutable(index);
}
inline void Function::set_constants(int index, const std::string& value) {
  constants_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Function.constants)
}
inline void Function::set_constants(int index, std::string&& value) {
  constants_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Function.constants)
}
inline void Function::set_constants(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  constants_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Function.constants)
}
inline void Function::set_constants(int index, const char* value, size_t size) {
  constants_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Function.constants)
}
inline std::string* Function::_internal_add_constants() {
  return constants_.Add();
}
inline void Function::add_constants(const std::string& value) {
  constants_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Function.constants)
}
inline void Function::add_constants(std::string&& value) {
  constants_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Function.constants)
}
inline void Function::add_constants(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  constants_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Function.constants)
}
inline void Function::add_constants(const char* value, size_t size) {
  constants_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Function.constants)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Function::constants() const {
  // @@protoc_insertion_point(field_list:Messages.Function.constants)
  return constants_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Function::mutable_constants() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Function.constants)
  return &constants_;
}

// repeated string to_be_defined = 7;
inline int Function::_internal_to_be_defined_size() const {
  return to_be_defined_.size();
}
inline int Function::to_be_defined_size() const {
  return _internal_to_be_defined_size();
}
inline void Function::clear_to_be_defined() {
  to_be_defined_.Clear();
}
inline std::string* Function::add_to_be_defined() {
  std::string* _s = _internal_add_to_be_defined();
  // @@protoc_insertion_point(field_add_mutable:Messages.Function.to_be_defined)
  return _s;
}
inline const std::string& Function::_internal_to_be_defined(int index) const {
  return to_be_defined_.Get(index);
}
inline const std::string& Function::to_be_defined(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Function.to_be_defined)
  return _internal_to_be_defined(index);
}
inline std::string* Function::mutable_to_be_defined(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Function.to_be_defined)
  return to_be_defined_.Mutable(index);
}
inline void Function::set_to_be_defined(int index, const std::string& value) {
  to_be_defined_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Function.to_be_defined)
}
inline void Function::set_to_be_defined(int index, std::string&& value) {
  to_be_defined_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Function.to_be_defined)
}
inline void Function::set_to_be_defined(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  to_be_defined_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Function.to_be_defined)
}
inline void Function::set_to_be_defined(int index, const char* value, size_t size) {
  to_be_defined_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Function.to_be_defined)
}
inline std::string* Function::_internal_add_to_be_defined() {
  return to_be_defined_.Add();
}
inline void Function::add_to_be_defined(const std::string& value) {
  to_be_defined_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Function.to_be_defined)
}
inline void Function::add_to_be_defined(std::string&& value) {
  to_be_defined_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Function.to_be_defined)
}
inline void Function::add_to_be_defined(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  to_be_defined_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Function.to_be_defined)
}
inline void Function::add_to_be_defined(const char* value, size_t size) {
  to_be_defined_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Function.to_be_defined)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Function::to_be_defined() const {
  // @@protoc_insertion_point(field_list:Messages.Function.to_be_defined)
  return to_be_defined_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Function::mutable_to_be_defined() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Function.to_be_defined)
  return &to_be_defined_;
}

// repeated .Messages.Vector64 data = 8;
inline int Function::_internal_data_size() const {
  return data_.size();
}
inline int Function::data_size() const {
  return _internal_data_size();
}
inline ::Messages::Vector64* Function::mutable_data(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Function.data)
  return data_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Vector64 >*
Function::mutable_data() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Function.data)
  return &data_;
}
inline const ::Messages::Vector64& Function::_internal_data(int index) const {
  return data_.Get(index);
}
inline const ::Messages::Vector64& Function::data(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Function.data)
  return _internal_data(index);
}
inline ::Messages::Vector64* Function::_internal_add_data() {
  return data_.Add();
}
inline ::Messages::Vector64* Function::add_data() {
  ::Messages::Vector64* _add = _internal_add_data();
  // @@protoc_insertion_point(field_add:Messages.Function.data)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Vector64 >&
Function::data() const {
  // @@protoc_insertion_point(field_list:Messages.Function.data)
  return data_;
}

// bool cpu_capable = 10;
inline void Function::clear_cpu_capable() {
  cpu_capable_ = false;
}
inline bool Function::_internal_cpu_capable() const {
  return cpu_capable_;
}
inline bool Function::cpu_capable() const {
  // @@protoc_insertion_point(field_get:Messages.Function.cpu_capable)
  return _internal_cpu_capable();
}
inline void Function::_internal_set_cpu_capable(bool value) {
  
  cpu_capable_ = value;
}
inline void Function::set_cpu_capable(bool value) {
  _internal_set_cpu_capable(value);
  // @@protoc_insertion_point(field_set:Messages.Function.cpu_capable)
}

// bool gpu_capable = 11;
inline void Function::clear_gpu_capable() {
  gpu_capable_ = false;
}
inline bool Function::_internal_gpu_capable() const {
  return gpu_capable_;
}
inline bool Function::gpu_capable() const {
  // @@protoc_insertion_point(field_get:Messages.Function.gpu_capable)
  return _internal_gpu_capable();
}
inline void Function::_internal_set_gpu_capable(bool value) {
  
  gpu_capable_ = value;
}
inline void Function::set_gpu_capable(bool value) {
  _internal_set_gpu_capable(value);
  // @@protoc_insertion_point(field_set:Messages.Function.gpu_capable)
}

// bool include_as_preprocessor = 12;
inline void Function::clear_include_as_preprocessor() {
  include_as_preprocessor_ = false;
}
inline bool Function::_internal_include_as_preprocessor() const {
  return include_as_preprocessor_;
}
inline bool Function::include_as_preprocessor() const {
  // @@protoc_insertion_point(field_get:Messages.Function.include_as_preprocessor)
  return _internal_include_as_preprocessor();
}
inline void Function::_internal_set_include_as_preprocessor(bool value) {
  
  include_as_preprocessor_ = value;
}
inline void Function::set_include_as_preprocessor(bool value) {
  _internal_set_include_as_preprocessor(value);
  // @@protoc_insertion_point(field_set:Messages.Function.include_as_preprocessor)
}

// bool omit_from_main_loop = 13;
inline void Function::clear_omit_from_main_loop() {
  omit_from_main_loop_ = false;
}
inline bool Function::_internal_omit_from_main_loop() const {
  return omit_from_main_loop_;
}
inline bool Function::omit_from_main_loop() const {
  // @@protoc_insertion_point(field_get:Messages.Function.omit_from_main_loop)
  return _internal_omit_from_main_loop();
}
inline void Function::_internal_set_omit_from_main_loop(bool value) {
  
  omit_from_main_loop_ = value;
}
inline void Function::set_omit_from_main_loop(bool value) {
  _internal_set_omit_from_main_loop(value);
  // @@protoc_insertion_point(field_set:Messages.Function.omit_from_main_loop)
}

// bool include_as_postprocessor = 14;
inline void Function::clear_include_as_postprocessor() {
  include_as_postprocessor_ = false;
}
inline bool Function::_internal_include_as_postprocessor() const {
  return include_as_postprocessor_;
}
inline bool Function::include_as_postprocessor() const {
  // @@protoc_insertion_point(field_get:Messages.Function.include_as_postprocessor)
  return _internal_include_as_postprocessor();
}
inline void Function::_internal_set_include_as_postprocessor(bool value) {
  
  include_as_postprocessor_ = value;
}
inline void Function::set_include_as_postprocessor(bool value) {
  _internal_set_include_as_postprocessor(value);
  // @@protoc_insertion_point(field_set:Messages.Function.include_as_postprocessor)
}

// bool mutually_exclusive = 15;
inline void Function::clear_mutually_exclusive() {
  mutually_exclusive_ = false;
}
inline bool Function::_internal_mutually_exclusive() const {
  return mutually_exclusive_;
}
inline bool Function::mutually_exclusive() const {
  // @@protoc_insertion_point(field_get:Messages.Function.mutually_exclusive)
  return _internal_mutually_exclusive();
}
inline void Function::_internal_set_mutually_exclusive(bool value) {
  
  mutually_exclusive_ = value;
}
inline void Function::set_mutually_exclusive(bool value) {
  _internal_set_mutually_exclusive(value);
  // @@protoc_insertion_point(field_set:Messages.Function.mutually_exclusive)
}

// bool only_once = 16;
inline void Function::clear_only_once() {
  only_once_ = false;
}
inline bool Function::_internal_only_once() const {
  return only_once_;
}
inline bool Function::only_once() const {
  // @@protoc_insertion_point(field_get:Messages.Function.only_once)
  return _internal_only_once();
}
inline void Function::_internal_set_only_once(bool value) {
  
  only_once_ = value;
}
inline void Function::set_only_once(bool value) {
  _internal_set_only_once(value);
  // @@protoc_insertion_point(field_set:Messages.Function.only_once)
}

// bool push_front = 17;
inline void Function::clear_push_front() {
  push_front_ = false;
}
inline bool Function::_internal_push_front() const {
  return push_front_;
}
inline bool Function::push_front() const {
  // @@protoc_insertion_point(field_get:Messages.Function.push_front)
  return _internal_push_front();
}
inline void Function::_internal_set_push_front(bool value) {
  
  push_front_ = value;
}
inline void Function::set_push_front(bool value) {
  _internal_set_push_front(value);
  // @@protoc_insertion_point(field_set:Messages.Function.push_front)
}

// bool dont_flatten = 18;
inline void Function::clear_dont_flatten() {
  dont_flatten_ = false;
}
inline bool Function::_internal_dont_flatten() const {
  return dont_flatten_;
}
inline bool Function::dont_flatten() const {
  // @@protoc_insertion_point(field_get:Messages.Function.dont_flatten)
  return _internal_dont_flatten();
}
inline void Function::_internal_set_dont_flatten(bool value) {
  
  dont_flatten_ = value;
}
inline void Function::set_dont_flatten(bool value) {
  _internal_set_dont_flatten(value);
  // @@protoc_insertion_point(field_set:Messages.Function.dont_flatten)
}

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

// Command

// .Messages.Function function = 1;
inline bool Command::_internal_has_function() const {
  return this != internal_default_instance() && function_ != nullptr;
}
inline bool Command::has_function() const {
  return _internal_has_function();
}
inline void Command::clear_function() {
  if (GetArenaForAllocation() == nullptr && function_ != nullptr) {
    delete function_;
  }
  function_ = nullptr;
}
inline const ::Messages::Function& Command::_internal_function() const {
  const ::Messages::Function* p = function_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Function&>(
      ::Messages::_Function_default_instance_);
}
inline const ::Messages::Function& Command::function() const {
  // @@protoc_insertion_point(field_get:Messages.Command.function)
  return _internal_function();
}
inline void Command::unsafe_arena_set_allocated_function(
    ::Messages::Function* function) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(function_);
  }
  function_ = function;
  if (function) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Command.function)
}
inline ::Messages::Function* Command::release_function() {
  
  ::Messages::Function* temp = function_;
  function_ = 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 ::Messages::Function* Command::unsafe_arena_release_function() {
  // @@protoc_insertion_point(field_release:Messages.Command.function)
  
  ::Messages::Function* temp = function_;
  function_ = nullptr;
  return temp;
}
inline ::Messages::Function* Command::_internal_mutable_function() {
  
  if (function_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Function>(GetArenaForAllocation());
    function_ = p;
  }
  return function_;
}
inline ::Messages::Function* Command::mutable_function() {
  ::Messages::Function* _msg = _internal_mutable_function();
  // @@protoc_insertion_point(field_mutable:Messages.Command.function)
  return _msg;
}
inline void Command::set_allocated_function(::Messages::Function* function) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete function_;
  }
  if (function) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(function);
    if (message_arena != submessage_arena) {
      function = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, function, submessage_arena);
    }
    
  } else {
    
  }
  function_ = function;
  // @@protoc_insertion_point(field_set_allocated:Messages.Command.function)
}

// bool args_are_set = 2;
inline void Command::clear_args_are_set() {
  args_are_set_ = false;
}
inline bool Command::_internal_args_are_set() const {
  return args_are_set_;
}
inline bool Command::args_are_set() const {
  // @@protoc_insertion_point(field_get:Messages.Command.args_are_set)
  return _internal_args_are_set();
}
inline void Command::_internal_set_args_are_set(bool value) {
  
  args_are_set_ = value;
}
inline void Command::set_args_are_set(bool value) {
  _internal_set_args_are_set(value);
  // @@protoc_insertion_point(field_set:Messages.Command.args_are_set)
}

// bool is_ready = 3;
inline void Command::clear_is_ready() {
  is_ready_ = false;
}
inline bool Command::_internal_is_ready() const {
  return is_ready_;
}
inline bool Command::is_ready() const {
  // @@protoc_insertion_point(field_get:Messages.Command.is_ready)
  return _internal_is_ready();
}
inline void Command::_internal_set_is_ready(bool value) {
  
  is_ready_ = value;
}
inline void Command::set_is_ready(bool value) {
  _internal_set_is_ready(value);
  // @@protoc_insertion_point(field_set:Messages.Command.is_ready)
}

// uint64 exec_count = 4;
inline void Command::clear_exec_count() {
  exec_count_ = uint64_t{0u};
}
inline uint64_t Command::_internal_exec_count() const {
  return exec_count_;
}
inline uint64_t Command::exec_count() const {
  // @@protoc_insertion_point(field_get:Messages.Command.exec_count)
  return _internal_exec_count();
}
inline void Command::_internal_set_exec_count(uint64_t value) {
  
  exec_count_ = value;
}
inline void Command::set_exec_count(uint64_t value) {
  _internal_set_exec_count(value);
  // @@protoc_insertion_point(field_set:Messages.Command.exec_count)
}

// uint64 simd_size = 5;
inline void Command::clear_simd_size() {
  simd_size_ = uint64_t{0u};
}
inline uint64_t Command::_internal_simd_size() const {
  return simd_size_;
}
inline uint64_t Command::simd_size() const {
  // @@protoc_insertion_point(field_get:Messages.Command.simd_size)
  return _internal_simd_size();
}
inline void Command::_internal_set_simd_size(uint64_t value) {
  
  simd_size_ = value;
}
inline void Command::set_simd_size(uint64_t value) {
  _internal_set_simd_size(value);
  // @@protoc_insertion_point(field_set:Messages.Command.simd_size)
}

// uint64 version = 6;
inline void Command::clear_version() {
  version_ = uint64_t{0u};
}
inline uint64_t Command::_internal_version() const {
  return version_;
}
inline uint64_t Command::version() const {
  // @@protoc_insertion_point(field_get:Messages.Command.version)
  return _internal_version();
}
inline void Command::_internal_set_version(uint64_t value) {
  
  version_ = value;
}
inline void Command::set_version(uint64_t value) {
  _internal_set_version(value);
  // @@protoc_insertion_point(field_set:Messages.Command.version)
}

// int64 id = 7;
inline void Command::clear_id() {
  id_ = int64_t{0};
}
inline int64_t Command::_internal_id() const {
  return id_;
}
inline int64_t Command::id() const {
  // @@protoc_insertion_point(field_get:Messages.Command.id)
  return _internal_id();
}
inline void Command::_internal_set_id(int64_t value) {
  
  id_ = value;
}
inline void Command::set_id(int64_t value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:Messages.Command.id)
}

// uint64 n_kernel = 8;
inline void Command::clear_n_kernel() {
  n_kernel_ = uint64_t{0u};
}
inline uint64_t Command::_internal_n_kernel() const {
  return n_kernel_;
}
inline uint64_t Command::n_kernel() const {
  // @@protoc_insertion_point(field_get:Messages.Command.n_kernel)
  return _internal_n_kernel();
}
inline void Command::_internal_set_n_kernel(uint64_t value) {
  
  n_kernel_ = value;
}
inline void Command::set_n_kernel(uint64_t value) {
  _internal_set_n_kernel(value);
  // @@protoc_insertion_point(field_set:Messages.Command.n_kernel)
}

// float progress = 9;
inline void Command::clear_progress() {
  progress_ = 0;
}
inline float Command::_internal_progress() const {
  return progress_;
}
inline float Command::progress() const {
  // @@protoc_insertion_point(field_get:Messages.Command.progress)
  return _internal_progress();
}
inline void Command::_internal_set_progress(float value) {
  
  progress_ = value;
}
inline void Command::set_progress(float value) {
  _internal_set_progress(value);
  // @@protoc_insertion_point(field_set:Messages.Command.progress)
}

// string msg = 10;
inline void Command::clear_msg() {
  msg_.ClearToEmpty();
}
inline const std::string& Command::msg() const {
  // @@protoc_insertion_point(field_get:Messages.Command.msg)
  return _internal_msg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Command::set_msg(ArgT0&& arg0, ArgT... args) {
 
 msg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Command.msg)
}
inline std::string* Command::mutable_msg() {
  std::string* _s = _internal_mutable_msg();
  // @@protoc_insertion_point(field_mutable:Messages.Command.msg)
  return _s;
}
inline const std::string& Command::_internal_msg() const {
  return msg_.Get();
}
inline void Command::_internal_set_msg(const std::string& value) {
  
  msg_.Set(value, GetArenaForAllocation());
}
inline std::string* Command::_internal_mutable_msg() {
  
  return msg_.Mutable(GetArenaForAllocation());
}
inline std::string* Command::release_msg() {
  // @@protoc_insertion_point(field_release:Messages.Command.msg)
  return msg_.Release();
}
inline void Command::set_allocated_msg(std::string* msg) {
  if (msg != nullptr) {
    
  } else {
    
  }
  msg_.SetAllocated(msg, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (msg_.IsDefault()) {
    msg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Command.msg)
}

// .Messages.Record64 data = 12;
inline bool Command::_internal_has_data() const {
  return this != internal_default_instance() && data_ != nullptr;
}
inline bool Command::has_data() const {
  return _internal_has_data();
}
inline const ::Messages::Record64& Command::_internal_data() const {
  const ::Messages::Record64* p = data_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Record64&>(
      ::Messages::_Record64_default_instance_);
}
inline const ::Messages::Record64& Command::data() const {
  // @@protoc_insertion_point(field_get:Messages.Command.data)
  return _internal_data();
}
inline void Command::unsafe_arena_set_allocated_data(
    ::Messages::Record64* data) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(data_);
  }
  data_ = data;
  if (data) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Command.data)
}
inline ::Messages::Record64* Command::release_data() {
  
  ::Messages::Record64* temp = data_;
  data_ = 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 ::Messages::Record64* Command::unsafe_arena_release_data() {
  // @@protoc_insertion_point(field_release:Messages.Command.data)
  
  ::Messages::Record64* temp = data_;
  data_ = nullptr;
  return temp;
}
inline ::Messages::Record64* Command::_internal_mutable_data() {
  
  if (data_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Record64>(GetArenaForAllocation());
    data_ = p;
  }
  return data_;
}
inline ::Messages::Record64* Command::mutable_data() {
  ::Messages::Record64* _msg = _internal_mutable_data();
  // @@protoc_insertion_point(field_mutable:Messages.Command.data)
  return _msg;
}
inline void Command::set_allocated_data(::Messages::Record64* data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(data_);
  }
  if (data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(data));
    if (message_arena != submessage_arena) {
      data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, data, submessage_arena);
    }
    
  } else {
    
  }
  data_ = data;
  // @@protoc_insertion_point(field_set_allocated:Messages.Command.data)
}

// repeated .Messages.Command before = 13;
inline int Command::_internal_before_size() const {
  return before_.size();
}
inline int Command::before_size() const {
  return _internal_before_size();
}
inline void Command::clear_before() {
  before_.Clear();
}
inline ::Messages::Command* Command::mutable_before(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Command.before)
  return before_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >*
Command::mutable_before() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Command.before)
  return &before_;
}
inline const ::Messages::Command& Command::_internal_before(int index) const {
  return before_.Get(index);
}
inline const ::Messages::Command& Command::before(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Command.before)
  return _internal_before(index);
}
inline ::Messages::Command* Command::_internal_add_before() {
  return before_.Add();
}
inline ::Messages::Command* Command::add_before() {
  ::Messages::Command* _add = _internal_add_before();
  // @@protoc_insertion_point(field_add:Messages.Command.before)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >&
Command::before() const {
  // @@protoc_insertion_point(field_list:Messages.Command.before)
  return before_;
}

// repeated .Messages.Command after = 14;
inline int Command::_internal_after_size() const {
  return after_.size();
}
inline int Command::after_size() const {
  return _internal_after_size();
}
inline void Command::clear_after() {
  after_.Clear();
}
inline ::Messages::Command* Command::mutable_after(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Command.after)
  return after_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >*
Command::mutable_after() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Command.after)
  return &after_;
}
inline const ::Messages::Command& Command::_internal_after(int index) const {
  return after_.Get(index);
}
inline const ::Messages::Command& Command::after(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Command.after)
  return _internal_after(index);
}
inline ::Messages::Command* Command::_internal_add_after() {
  return after_.Add();
}
inline ::Messages::Command* Command::add_after() {
  ::Messages::Command* _add = _internal_add_after();
  // @@protoc_insertion_point(field_add:Messages.Command.after)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >&
Command::after() const {
  // @@protoc_insertion_point(field_list:Messages.Command.after)
  return after_;
}

// uint32 region_type = 15;
inline void Command::clear_region_type() {
  region_type_ = 0u;
}
inline uint32_t Command::_internal_region_type() const {
  return region_type_;
}
inline uint32_t Command::region_type() const {
  // @@protoc_insertion_point(field_get:Messages.Command.region_type)
  return _internal_region_type();
}
inline void Command::_internal_set_region_type(uint32_t value) {
  
  region_type_ = value;
}
inline void Command::set_region_type(uint32_t value) {
  _internal_set_region_type(value);
  // @@protoc_insertion_point(field_set:Messages.Command.region_type)
}

// int32 region_id = 16;
inline void Command::clear_region_id() {
  region_id_ = 0;
}
inline int32_t Command::_internal_region_id() const {
  return region_id_;
}
inline int32_t Command::region_id() const {
  // @@protoc_insertion_point(field_get:Messages.Command.region_id)
  return _internal_region_id();
}
inline void Command::_internal_set_region_id(int32_t value) {
  
  region_id_ = value;
}
inline void Command::set_region_id(int32_t value) {
  _internal_set_region_id(value);
  // @@protoc_insertion_point(field_set:Messages.Command.region_id)
}

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

// Script

// string name = 1;
inline void Script::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& Script::name() const {
  // @@protoc_insertion_point(field_get:Messages.Script.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Script::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Script.name)
}
inline std::string* Script::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:Messages.Script.name)
  return _s;
}
inline const std::string& Script::_internal_name() const {
  return name_.Get();
}
inline void Script::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* Script::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* Script::release_name() {
  // @@protoc_insertion_point(field_release:Messages.Script.name)
  return name_.Release();
}
inline void Script::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault()) {
    name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Script.name)
}

// string msg = 2;
inline void Script::clear_msg() {
  msg_.ClearToEmpty();
}
inline const std::string& Script::msg() const {
  // @@protoc_insertion_point(field_get:Messages.Script.msg)
  return _internal_msg();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Script::set_msg(ArgT0&& arg0, ArgT... args) {
 
 msg_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Script.msg)
}
inline std::string* Script::mutable_msg() {
  std::string* _s = _internal_mutable_msg();
  // @@protoc_insertion_point(field_mutable:Messages.Script.msg)
  return _s;
}
inline const std::string& Script::_internal_msg() const {
  return msg_.Get();
}
inline void Script::_internal_set_msg(const std::string& value) {
  
  msg_.Set(value, GetArenaForAllocation());
}
inline std::string* Script::_internal_mutable_msg() {
  
  return msg_.Mutable(GetArenaForAllocation());
}
inline std::string* Script::release_msg() {
  // @@protoc_insertion_point(field_release:Messages.Script.msg)
  return msg_.Release();
}
inline void Script::set_allocated_msg(std::string* msg) {
  if (msg != nullptr) {
    
  } else {
    
  }
  msg_.SetAllocated(msg, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (msg_.IsDefault()) {
    msg_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Script.msg)
}

// string source_code = 3;
inline void Script::clear_source_code() {
  source_code_.ClearToEmpty();
}
inline const std::string& Script::source_code() const {
  // @@protoc_insertion_point(field_get:Messages.Script.source_code)
  return _internal_source_code();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Script::set_source_code(ArgT0&& arg0, ArgT... args) {
 
 source_code_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Script.source_code)
}
inline std::string* Script::mutable_source_code() {
  std::string* _s = _internal_mutable_source_code();
  // @@protoc_insertion_point(field_mutable:Messages.Script.source_code)
  return _s;
}
inline const std::string& Script::_internal_source_code() const {
  return source_code_.Get();
}
inline void Script::_internal_set_source_code(const std::string& value) {
  
  source_code_.Set(value, GetArenaForAllocation());
}
inline std::string* Script::_internal_mutable_source_code() {
  
  return source_code_.Mutable(GetArenaForAllocation());
}
inline std::string* Script::release_source_code() {
  // @@protoc_insertion_point(field_release:Messages.Script.source_code)
  return source_code_.Release();
}
inline void Script::set_allocated_source_code(std::string* source_code) {
  if (source_code != nullptr) {
    
  } else {
    
  }
  source_code_.SetAllocated(source_code, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (source_code_.IsDefault()) {
    source_code_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Script.source_code)
}

// int64 uid = 4;
inline void Script::clear_uid() {
  uid_ = int64_t{0};
}
inline int64_t Script::_internal_uid() const {
  return uid_;
}
inline int64_t Script::uid() const {
  // @@protoc_insertion_point(field_get:Messages.Script.uid)
  return _internal_uid();
}
inline void Script::_internal_set_uid(int64_t value) {
  
  uid_ = value;
}
inline void Script::set_uid(int64_t value) {
  _internal_set_uid(value);
  // @@protoc_insertion_point(field_set:Messages.Script.uid)
}

// uint32 device = 5;
inline void Script::clear_device() {
  device_ = 0u;
}
inline uint32_t Script::_internal_device() const {
  return device_;
}
inline uint32_t Script::device() const {
  // @@protoc_insertion_point(field_get:Messages.Script.device)
  return _internal_device();
}
inline void Script::_internal_set_device(uint32_t value) {
  
  device_ = value;
}
inline void Script::set_device(uint32_t value) {
  _internal_set_device(value);
  // @@protoc_insertion_point(field_set:Messages.Script.device)
}

// uint32 status = 6;
inline void Script::clear_status() {
  status_ = 0u;
}
inline uint32_t Script::_internal_status() const {
  return status_;
}
inline uint32_t Script::status() const {
  // @@protoc_insertion_point(field_get:Messages.Script.status)
  return _internal_status();
}
inline void Script::_internal_set_status(uint32_t value) {
  
  status_ = value;
}
inline void Script::set_status(uint32_t value) {
  _internal_set_status(value);
  // @@protoc_insertion_point(field_set:Messages.Script.status)
}

// uint32 order = 7;
inline void Script::clear_order() {
  order_ = 0u;
}
inline uint32_t Script::_internal_order() const {
  return order_;
}
inline uint32_t Script::order() const {
  // @@protoc_insertion_point(field_get:Messages.Script.order)
  return _internal_order();
}
inline void Script::_internal_set_order(uint32_t value) {
  
  order_ = value;
}
inline void Script::set_order(uint32_t value) {
  _internal_set_order(value);
  // @@protoc_insertion_point(field_set:Messages.Script.order)
}

// float progress = 8;
inline void Script::clear_progress() {
  progress_ = 0;
}
inline float Script::_internal_progress() const {
  return progress_;
}
inline float Script::progress() const {
  // @@protoc_insertion_point(field_get:Messages.Script.progress)
  return _internal_progress();
}
inline void Script::_internal_set_progress(float value) {
  
  progress_ = value;
}
inline void Script::set_progress(float value) {
  _internal_set_progress(value);
  // @@protoc_insertion_point(field_set:Messages.Script.progress)
}

// .Messages.Variables variables = 10;
inline bool Script::_internal_has_variables() const {
  return this != internal_default_instance() && variables_ != nullptr;
}
inline bool Script::has_variables() const {
  return _internal_has_variables();
}
inline void Script::clear_variables() {
  if (GetArenaForAllocation() == nullptr && variables_ != nullptr) {
    delete variables_;
  }
  variables_ = nullptr;
}
inline const ::Messages::Variables& Script::_internal_variables() const {
  const ::Messages::Variables* p = variables_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Variables&>(
      ::Messages::_Variables_default_instance_);
}
inline const ::Messages::Variables& Script::variables() const {
  // @@protoc_insertion_point(field_get:Messages.Script.variables)
  return _internal_variables();
}
inline void Script::unsafe_arena_set_allocated_variables(
    ::Messages::Variables* variables) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(variables_);
  }
  variables_ = variables;
  if (variables) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Script.variables)
}
inline ::Messages::Variables* Script::release_variables() {
  
  ::Messages::Variables* temp = variables_;
  variables_ = 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 ::Messages::Variables* Script::unsafe_arena_release_variables() {
  // @@protoc_insertion_point(field_release:Messages.Script.variables)
  
  ::Messages::Variables* temp = variables_;
  variables_ = nullptr;
  return temp;
}
inline ::Messages::Variables* Script::_internal_mutable_variables() {
  
  if (variables_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Variables>(GetArenaForAllocation());
    variables_ = p;
  }
  return variables_;
}
inline ::Messages::Variables* Script::mutable_variables() {
  ::Messages::Variables* _msg = _internal_mutable_variables();
  // @@protoc_insertion_point(field_mutable:Messages.Script.variables)
  return _msg;
}
inline void Script::set_allocated_variables(::Messages::Variables* variables) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete variables_;
  }
  if (variables) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(variables);
    if (message_arena != submessage_arena) {
      variables = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, variables, submessage_arena);
    }
    
  } else {
    
  }
  variables_ = variables;
  // @@protoc_insertion_point(field_set_allocated:Messages.Script.variables)
}

// repeated .Messages.Command Sequence = 12;
inline int Script::_internal_sequence_size() const {
  return sequence_.size();
}
inline int Script::sequence_size() const {
  return _internal_sequence_size();
}
inline void Script::clear_sequence() {
  sequence_.Clear();
}
inline ::Messages::Command* Script::mutable_sequence(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Script.Sequence)
  return sequence_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >*
Script::mutable_sequence() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Script.Sequence)
  return &sequence_;
}
inline const ::Messages::Command& Script::_internal_sequence(int index) const {
  return sequence_.Get(index);
}
inline const ::Messages::Command& Script::sequence(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Script.Sequence)
  return _internal_sequence(index);
}
inline ::Messages::Command* Script::_internal_add_sequence() {
  return sequence_.Add();
}
inline ::Messages::Command* Script::add_sequence() {
  ::Messages::Command* _add = _internal_add_sequence();
  // @@protoc_insertion_point(field_add:Messages.Script.Sequence)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >&
Script::sequence() const {
  // @@protoc_insertion_point(field_list:Messages.Script.Sequence)
  return sequence_;
}

// .Messages.Script before = 14;
inline bool Script::_internal_has_before() const {
  return this != internal_default_instance() && before_ != nullptr;
}
inline bool Script::has_before() const {
  return _internal_has_before();
}
inline void Script::clear_before() {
  if (GetArenaForAllocation() == nullptr && before_ != nullptr) {
    delete before_;
  }
  before_ = nullptr;
}
inline const ::Messages::Script& Script::_internal_before() const {
  const ::Messages::Script* p = before_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Script&>(
      ::Messages::_Script_default_instance_);
}
inline const ::Messages::Script& Script::before() const {
  // @@protoc_insertion_point(field_get:Messages.Script.before)
  return _internal_before();
}
inline void Script::unsafe_arena_set_allocated_before(
    ::Messages::Script* before) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(before_);
  }
  before_ = before;
  if (before) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Script.before)
}
inline ::Messages::Script* Script::release_before() {
  
  ::Messages::Script* temp = before_;
  before_ = 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 ::Messages::Script* Script::unsafe_arena_release_before() {
  // @@protoc_insertion_point(field_release:Messages.Script.before)
  
  ::Messages::Script* temp = before_;
  before_ = nullptr;
  return temp;
}
inline ::Messages::Script* Script::_internal_mutable_before() {
  
  if (before_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Script>(GetArenaForAllocation());
    before_ = p;
  }
  return before_;
}
inline ::Messages::Script* Script::mutable_before() {
  ::Messages::Script* _msg = _internal_mutable_before();
  // @@protoc_insertion_point(field_mutable:Messages.Script.before)
  return _msg;
}
inline void Script::set_allocated_before(::Messages::Script* before) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete before_;
  }
  if (before) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(before);
    if (message_arena != submessage_arena) {
      before = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, before, submessage_arena);
    }
    
  } else {
    
  }
  before_ = before;
  // @@protoc_insertion_point(field_set_allocated:Messages.Script.before)
}

// .Messages.Script after = 15;
inline bool Script::_internal_has_after() const {
  return this != internal_default_instance() && after_ != nullptr;
}
inline bool Script::has_after() const {
  return _internal_has_after();
}
inline void Script::clear_after() {
  if (GetArenaForAllocation() == nullptr && after_ != nullptr) {
    delete after_;
  }
  after_ = nullptr;
}
inline const ::Messages::Script& Script::_internal_after() const {
  const ::Messages::Script* p = after_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Script&>(
      ::Messages::_Script_default_instance_);
}
inline const ::Messages::Script& Script::after() const {
  // @@protoc_insertion_point(field_get:Messages.Script.after)
  return _internal_after();
}
inline void Script::unsafe_arena_set_allocated_after(
    ::Messages::Script* after) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(after_);
  }
  after_ = after;
  if (after) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Script.after)
}
inline ::Messages::Script* Script::release_after() {
  
  ::Messages::Script* temp = after_;
  after_ = 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 ::Messages::Script* Script::unsafe_arena_release_after() {
  // @@protoc_insertion_point(field_release:Messages.Script.after)
  
  ::Messages::Script* temp = after_;
  after_ = nullptr;
  return temp;
}
inline ::Messages::Script* Script::_internal_mutable_after() {
  
  if (after_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Script>(GetArenaForAllocation());
    after_ = p;
  }
  return after_;
}
inline ::Messages::Script* Script::mutable_after() {
  ::Messages::Script* _msg = _internal_mutable_after();
  // @@protoc_insertion_point(field_mutable:Messages.Script.after)
  return _msg;
}
inline void Script::set_allocated_after(::Messages::Script* after) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete after_;
  }
  if (after) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(after);
    if (message_arena != submessage_arena) {
      after = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, after, submessage_arena);
    }
    
  } else {
    
  }
  after_ = after;
  // @@protoc_insertion_point(field_set_allocated:Messages.Script.after)
}

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

// Model

// string name = 1;
inline void Model::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& Model::name() const {
  // @@protoc_insertion_point(field_get:Messages.Model.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Model::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Model.name)
}
inline std::string* Model::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:Messages.Model.name)
  return _s;
}
inline const std::string& Model::_internal_name() const {
  return name_.Get();
}
inline void Model::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* Model::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* Model::release_name() {
  // @@protoc_insertion_point(field_release:Messages.Model.name)
  return name_.Release();
}
inline void Model::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault()) {
    name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Model.name)
}

// repeated string dofs = 3;
inline int Model::_internal_dofs_size() const {
  return dofs_.size();
}
inline int Model::dofs_size() const {
  return _internal_dofs_size();
}
inline void Model::clear_dofs() {
  dofs_.Clear();
}
inline std::string* Model::add_dofs() {
  std::string* _s = _internal_add_dofs();
  // @@protoc_insertion_point(field_add_mutable:Messages.Model.dofs)
  return _s;
}
inline const std::string& Model::_internal_dofs(int index) const {
  return dofs_.Get(index);
}
inline const std::string& Model::dofs(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Model.dofs)
  return _internal_dofs(index);
}
inline std::string* Model::mutable_dofs(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Model.dofs)
  return dofs_.Mutable(index);
}
inline void Model::set_dofs(int index, const std::string& value) {
  dofs_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Model.dofs)
}
inline void Model::set_dofs(int index, std::string&& value) {
  dofs_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Model.dofs)
}
inline void Model::set_dofs(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  dofs_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Model.dofs)
}
inline void Model::set_dofs(int index, const char* value, size_t size) {
  dofs_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Model.dofs)
}
inline std::string* Model::_internal_add_dofs() {
  return dofs_.Add();
}
inline void Model::add_dofs(const std::string& value) {
  dofs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Model.dofs)
}
inline void Model::add_dofs(std::string&& value) {
  dofs_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Model.dofs)
}
inline void Model::add_dofs(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  dofs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Model.dofs)
}
inline void Model::add_dofs(const char* value, size_t size) {
  dofs_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Model.dofs)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Model::dofs() const {
  // @@protoc_insertion_point(field_list:Messages.Model.dofs)
  return dofs_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Model::mutable_dofs() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Model.dofs)
  return &dofs_;
}

// repeated string algorithms = 4;
inline int Model::_internal_algorithms_size() const {
  return algorithms_.size();
}
inline int Model::algorithms_size() const {
  return _internal_algorithms_size();
}
inline void Model::clear_algorithms() {
  algorithms_.Clear();
}
inline std::string* Model::add_algorithms() {
  std::string* _s = _internal_add_algorithms();
  // @@protoc_insertion_point(field_add_mutable:Messages.Model.algorithms)
  return _s;
}
inline const std::string& Model::_internal_algorithms(int index) const {
  return algorithms_.Get(index);
}
inline const std::string& Model::algorithms(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Model.algorithms)
  return _internal_algorithms(index);
}
inline std::string* Model::mutable_algorithms(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Model.algorithms)
  return algorithms_.Mutable(index);
}
inline void Model::set_algorithms(int index, const std::string& value) {
  algorithms_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Model.algorithms)
}
inline void Model::set_algorithms(int index, std::string&& value) {
  algorithms_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Model.algorithms)
}
inline void Model::set_algorithms(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  algorithms_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Model.algorithms)
}
inline void Model::set_algorithms(int index, const char* value, size_t size) {
  algorithms_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Model.algorithms)
}
inline std::string* Model::_internal_add_algorithms() {
  return algorithms_.Add();
}
inline void Model::add_algorithms(const std::string& value) {
  algorithms_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Model.algorithms)
}
inline void Model::add_algorithms(std::string&& value) {
  algorithms_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Model.algorithms)
}
inline void Model::add_algorithms(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  algorithms_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Model.algorithms)
}
inline void Model::add_algorithms(const char* value, size_t size) {
  algorithms_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Model.algorithms)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Model::algorithms() const {
  // @@protoc_insertion_point(field_list:Messages.Model.algorithms)
  return algorithms_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Model::mutable_algorithms() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Model.algorithms)
  return &algorithms_;
}

// repeated string available_outputs = 5;
inline int Model::_internal_available_outputs_size() const {
  return available_outputs_.size();
}
inline int Model::available_outputs_size() const {
  return _internal_available_outputs_size();
}
inline void Model::clear_available_outputs() {
  available_outputs_.Clear();
}
inline std::string* Model::add_available_outputs() {
  std::string* _s = _internal_add_available_outputs();
  // @@protoc_insertion_point(field_add_mutable:Messages.Model.available_outputs)
  return _s;
}
inline const std::string& Model::_internal_available_outputs(int index) const {
  return available_outputs_.Get(index);
}
inline const std::string& Model::available_outputs(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Model.available_outputs)
  return _internal_available_outputs(index);
}
inline std::string* Model::mutable_available_outputs(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Model.available_outputs)
  return available_outputs_.Mutable(index);
}
inline void Model::set_available_outputs(int index, const std::string& value) {
  available_outputs_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Model.available_outputs)
}
inline void Model::set_available_outputs(int index, std::string&& value) {
  available_outputs_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Model.available_outputs)
}
inline void Model::set_available_outputs(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  available_outputs_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Model.available_outputs)
}
inline void Model::set_available_outputs(int index, const char* value, size_t size) {
  available_outputs_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Model.available_outputs)
}
inline std::string* Model::_internal_add_available_outputs() {
  return available_outputs_.Add();
}
inline void Model::add_available_outputs(const std::string& value) {
  available_outputs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Model.available_outputs)
}
inline void Model::add_available_outputs(std::string&& value) {
  available_outputs_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Model.available_outputs)
}
inline void Model::add_available_outputs(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  available_outputs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Model.available_outputs)
}
inline void Model::add_available_outputs(const char* value, size_t size) {
  available_outputs_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Model.available_outputs)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Model::available_outputs() const {
  // @@protoc_insertion_point(field_list:Messages.Model.available_outputs)
  return available_outputs_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Model::mutable_available_outputs() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Model.available_outputs)
  return &available_outputs_;
}

// repeated string extra_properties = 6;
inline int Model::_internal_extra_properties_size() const {
  return extra_properties_.size();
}
inline int Model::extra_properties_size() const {
  return _internal_extra_properties_size();
}
inline void Model::clear_extra_properties() {
  extra_properties_.Clear();
}
inline std::string* Model::add_extra_properties() {
  std::string* _s = _internal_add_extra_properties();
  // @@protoc_insertion_point(field_add_mutable:Messages.Model.extra_properties)
  return _s;
}
inline const std::string& Model::_internal_extra_properties(int index) const {
  return extra_properties_.Get(index);
}
inline const std::string& Model::extra_properties(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Model.extra_properties)
  return _internal_extra_properties(index);
}
inline std::string* Model::mutable_extra_properties(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Model.extra_properties)
  return extra_properties_.Mutable(index);
}
inline void Model::set_extra_properties(int index, const std::string& value) {
  extra_properties_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Model.extra_properties)
}
inline void Model::set_extra_properties(int index, std::string&& value) {
  extra_properties_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Model.extra_properties)
}
inline void Model::set_extra_properties(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  extra_properties_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Model.extra_properties)
}
inline void Model::set_extra_properties(int index, const char* value, size_t size) {
  extra_properties_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Model.extra_properties)
}
inline std::string* Model::_internal_add_extra_properties() {
  return extra_properties_.Add();
}
inline void Model::add_extra_properties(const std::string& value) {
  extra_properties_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Model.extra_properties)
}
inline void Model::add_extra_properties(std::string&& value) {
  extra_properties_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Model.extra_properties)
}
inline void Model::add_extra_properties(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  extra_properties_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Model.extra_properties)
}
inline void Model::add_extra_properties(const char* value, size_t size) {
  extra_properties_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Model.extra_properties)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Model::extra_properties() const {
  // @@protoc_insertion_point(field_list:Messages.Model.extra_properties)
  return extra_properties_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Model::mutable_extra_properties() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Model.extra_properties)
  return &extra_properties_;
}

// repeated string compatible_conditions = 7;
inline int Model::_internal_compatible_conditions_size() const {
  return compatible_conditions_.size();
}
inline int Model::compatible_conditions_size() const {
  return _internal_compatible_conditions_size();
}
inline void Model::clear_compatible_conditions() {
  compatible_conditions_.Clear();
}
inline std::string* Model::add_compatible_conditions() {
  std::string* _s = _internal_add_compatible_conditions();
  // @@protoc_insertion_point(field_add_mutable:Messages.Model.compatible_conditions)
  return _s;
}
inline const std::string& Model::_internal_compatible_conditions(int index) const {
  return compatible_conditions_.Get(index);
}
inline const std::string& Model::compatible_conditions(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Model.compatible_conditions)
  return _internal_compatible_conditions(index);
}
inline std::string* Model::mutable_compatible_conditions(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Model.compatible_conditions)
  return compatible_conditions_.Mutable(index);
}
inline void Model::set_compatible_conditions(int index, const std::string& value) {
  compatible_conditions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Model.compatible_conditions)
}
inline void Model::set_compatible_conditions(int index, std::string&& value) {
  compatible_conditions_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Model.compatible_conditions)
}
inline void Model::set_compatible_conditions(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  compatible_conditions_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Model.compatible_conditions)
}
inline void Model::set_compatible_conditions(int index, const char* value, size_t size) {
  compatible_conditions_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Model.compatible_conditions)
}
inline std::string* Model::_internal_add_compatible_conditions() {
  return compatible_conditions_.Add();
}
inline void Model::add_compatible_conditions(const std::string& value) {
  compatible_conditions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Model.compatible_conditions)
}
inline void Model::add_compatible_conditions(std::string&& value) {
  compatible_conditions_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Model.compatible_conditions)
}
inline void Model::add_compatible_conditions(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  compatible_conditions_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Model.compatible_conditions)
}
inline void Model::add_compatible_conditions(const char* value, size_t size) {
  compatible_conditions_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Model.compatible_conditions)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Model::compatible_conditions() const {
  // @@protoc_insertion_point(field_list:Messages.Model.compatible_conditions)
  return compatible_conditions_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Model::mutable_compatible_conditions() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Model.compatible_conditions)
  return &compatible_conditions_;
}

// repeated .Messages.Model sub_models = 9;
inline int Model::_internal_sub_models_size() const {
  return sub_models_.size();
}
inline int Model::sub_models_size() const {
  return _internal_sub_models_size();
}
inline void Model::clear_sub_models() {
  sub_models_.Clear();
}
inline ::Messages::Model* Model::mutable_sub_models(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Model.sub_models)
  return sub_models_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Model >*
Model::mutable_sub_models() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Model.sub_models)
  return &sub_models_;
}
inline const ::Messages::Model& Model::_internal_sub_models(int index) const {
  return sub_models_.Get(index);
}
inline const ::Messages::Model& Model::sub_models(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Model.sub_models)
  return _internal_sub_models(index);
}
inline ::Messages::Model* Model::_internal_add_sub_models() {
  return sub_models_.Add();
}
inline ::Messages::Model* Model::add_sub_models() {
  ::Messages::Model* _add = _internal_add_sub_models();
  // @@protoc_insertion_point(field_add:Messages.Model.sub_models)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Model >&
Model::sub_models() const {
  // @@protoc_insertion_point(field_list:Messages.Model.sub_models)
  return sub_models_;
}

// .Messages.Record64 default_data = 10;
inline bool Model::_internal_has_default_data() const {
  return this != internal_default_instance() && default_data_ != nullptr;
}
inline bool Model::has_default_data() const {
  return _internal_has_default_data();
}
inline const ::Messages::Record64& Model::_internal_default_data() const {
  const ::Messages::Record64* p = default_data_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Record64&>(
      ::Messages::_Record64_default_instance_);
}
inline const ::Messages::Record64& Model::default_data() const {
  // @@protoc_insertion_point(field_get:Messages.Model.default_data)
  return _internal_default_data();
}
inline void Model::unsafe_arena_set_allocated_default_data(
    ::Messages::Record64* default_data) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(default_data_);
  }
  default_data_ = default_data;
  if (default_data) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Model.default_data)
}
inline ::Messages::Record64* Model::release_default_data() {
  
  ::Messages::Record64* temp = default_data_;
  default_data_ = 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 ::Messages::Record64* Model::unsafe_arena_release_default_data() {
  // @@protoc_insertion_point(field_release:Messages.Model.default_data)
  
  ::Messages::Record64* temp = default_data_;
  default_data_ = nullptr;
  return temp;
}
inline ::Messages::Record64* Model::_internal_mutable_default_data() {
  
  if (default_data_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Record64>(GetArenaForAllocation());
    default_data_ = p;
  }
  return default_data_;
}
inline ::Messages::Record64* Model::mutable_default_data() {
  ::Messages::Record64* _msg = _internal_mutable_default_data();
  // @@protoc_insertion_point(field_mutable:Messages.Model.default_data)
  return _msg;
}
inline void Model::set_allocated_default_data(::Messages::Record64* default_data) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(default_data_);
  }
  if (default_data) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(default_data));
    if (message_arena != submessage_arena) {
      default_data = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, default_data, submessage_arena);
    }
    
  } else {
    
  }
  default_data_ = default_data;
  // @@protoc_insertion_point(field_set_allocated:Messages.Model.default_data)
}

// repeated .Messages.Rule rules = 11;
inline int Model::_internal_rules_size() const {
  return rules_.size();
}
inline int Model::rules_size() const {
  return _internal_rules_size();
}
inline ::Messages::Rule* Model::mutable_rules(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Model.rules)
  return rules_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >*
Model::mutable_rules() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Model.rules)
  return &rules_;
}
inline const ::Messages::Rule& Model::_internal_rules(int index) const {
  return rules_.Get(index);
}
inline const ::Messages::Rule& Model::rules(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Model.rules)
  return _internal_rules(index);
}
inline ::Messages::Rule* Model::_internal_add_rules() {
  return rules_.Add();
}
inline ::Messages::Rule* Model::add_rules() {
  ::Messages::Rule* _add = _internal_add_rules();
  // @@protoc_insertion_point(field_add:Messages.Model.rules)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >&
Model::rules() const {
  // @@protoc_insertion_point(field_list:Messages.Model.rules)
  return rules_;
}

// repeated .Messages.Rule mutex_stack = 12;
inline int Model::_internal_mutex_stack_size() const {
  return mutex_stack_.size();
}
inline int Model::mutex_stack_size() const {
  return _internal_mutex_stack_size();
}
inline ::Messages::Rule* Model::mutable_mutex_stack(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Model.mutex_stack)
  return mutex_stack_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >*
Model::mutable_mutex_stack() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Model.mutex_stack)
  return &mutex_stack_;
}
inline const ::Messages::Rule& Model::_internal_mutex_stack(int index) const {
  return mutex_stack_.Get(index);
}
inline const ::Messages::Rule& Model::mutex_stack(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Model.mutex_stack)
  return _internal_mutex_stack(index);
}
inline ::Messages::Rule* Model::_internal_add_mutex_stack() {
  return mutex_stack_.Add();
}
inline ::Messages::Rule* Model::add_mutex_stack() {
  ::Messages::Rule* _add = _internal_add_mutex_stack();
  // @@protoc_insertion_point(field_add:Messages.Model.mutex_stack)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Rule >&
Model::mutex_stack() const {
  // @@protoc_insertion_point(field_list:Messages.Model.mutex_stack)
  return mutex_stack_;
}

// .Messages.SparseMatrix markov_matrix = 15;
inline bool Model::_internal_has_markov_matrix() const {
  return this != internal_default_instance() && markov_matrix_ != nullptr;
}
inline bool Model::has_markov_matrix() const {
  return _internal_has_markov_matrix();
}
inline const ::Messages::SparseMatrix& Model::_internal_markov_matrix() const {
  const ::Messages::SparseMatrix* p = markov_matrix_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::SparseMatrix&>(
      ::Messages::_SparseMatrix_default_instance_);
}
inline const ::Messages::SparseMatrix& Model::markov_matrix() const {
  // @@protoc_insertion_point(field_get:Messages.Model.markov_matrix)
  return _internal_markov_matrix();
}
inline void Model::unsafe_arena_set_allocated_markov_matrix(
    ::Messages::SparseMatrix* markov_matrix) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(markov_matrix_);
  }
  markov_matrix_ = markov_matrix;
  if (markov_matrix) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Model.markov_matrix)
}
inline ::Messages::SparseMatrix* Model::release_markov_matrix() {
  
  ::Messages::SparseMatrix* temp = markov_matrix_;
  markov_matrix_ = 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 ::Messages::SparseMatrix* Model::unsafe_arena_release_markov_matrix() {
  // @@protoc_insertion_point(field_release:Messages.Model.markov_matrix)
  
  ::Messages::SparseMatrix* temp = markov_matrix_;
  markov_matrix_ = nullptr;
  return temp;
}
inline ::Messages::SparseMatrix* Model::_internal_mutable_markov_matrix() {
  
  if (markov_matrix_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::SparseMatrix>(GetArenaForAllocation());
    markov_matrix_ = p;
  }
  return markov_matrix_;
}
inline ::Messages::SparseMatrix* Model::mutable_markov_matrix() {
  ::Messages::SparseMatrix* _msg = _internal_mutable_markov_matrix();
  // @@protoc_insertion_point(field_mutable:Messages.Model.markov_matrix)
  return _msg;
}
inline void Model::set_allocated_markov_matrix(::Messages::SparseMatrix* markov_matrix) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(markov_matrix_);
  }
  if (markov_matrix) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(markov_matrix));
    if (message_arena != submessage_arena) {
      markov_matrix = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, markov_matrix, submessage_arena);
    }
    
  } else {
    
  }
  markov_matrix_ = markov_matrix;
  // @@protoc_insertion_point(field_set_allocated:Messages.Model.markov_matrix)
}

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

// Coupling

// string source_system = 1;
inline void Coupling::clear_source_system() {
  source_system_.ClearToEmpty();
}
inline const std::string& Coupling::source_system() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.source_system)
  return _internal_source_system();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Coupling::set_source_system(ArgT0&& arg0, ArgT... args) {
 
 source_system_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Coupling.source_system)
}
inline std::string* Coupling::mutable_source_system() {
  std::string* _s = _internal_mutable_source_system();
  // @@protoc_insertion_point(field_mutable:Messages.Coupling.source_system)
  return _s;
}
inline const std::string& Coupling::_internal_source_system() const {
  return source_system_.Get();
}
inline void Coupling::_internal_set_source_system(const std::string& value) {
  
  source_system_.Set(value, GetArenaForAllocation());
}
inline std::string* Coupling::_internal_mutable_source_system() {
  
  return source_system_.Mutable(GetArenaForAllocation());
}
inline std::string* Coupling::release_source_system() {
  // @@protoc_insertion_point(field_release:Messages.Coupling.source_system)
  return source_system_.Release();
}
inline void Coupling::set_allocated_source_system(std::string* source_system) {
  if (source_system != nullptr) {
    
  } else {
    
  }
  source_system_.SetAllocated(source_system, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (source_system_.IsDefault()) {
    source_system_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Coupling.source_system)
}

// string target_system = 2;
inline void Coupling::clear_target_system() {
  target_system_.ClearToEmpty();
}
inline const std::string& Coupling::target_system() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.target_system)
  return _internal_target_system();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Coupling::set_target_system(ArgT0&& arg0, ArgT... args) {
 
 target_system_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Coupling.target_system)
}
inline std::string* Coupling::mutable_target_system() {
  std::string* _s = _internal_mutable_target_system();
  // @@protoc_insertion_point(field_mutable:Messages.Coupling.target_system)
  return _s;
}
inline const std::string& Coupling::_internal_target_system() const {
  return target_system_.Get();
}
inline void Coupling::_internal_set_target_system(const std::string& value) {
  
  target_system_.Set(value, GetArenaForAllocation());
}
inline std::string* Coupling::_internal_mutable_target_system() {
  
  return target_system_.Mutable(GetArenaForAllocation());
}
inline std::string* Coupling::release_target_system() {
  // @@protoc_insertion_point(field_release:Messages.Coupling.target_system)
  return target_system_.Release();
}
inline void Coupling::set_allocated_target_system(std::string* target_system) {
  if (target_system != nullptr) {
    
  } else {
    
  }
  target_system_.SetAllocated(target_system, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (target_system_.IsDefault()) {
    target_system_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Coupling.target_system)
}

// int64 source_uid = 3;
inline void Coupling::clear_source_uid() {
  source_uid_ = int64_t{0};
}
inline int64_t Coupling::_internal_source_uid() const {
  return source_uid_;
}
inline int64_t Coupling::source_uid() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.source_uid)
  return _internal_source_uid();
}
inline void Coupling::_internal_set_source_uid(int64_t value) {
  
  source_uid_ = value;
}
inline void Coupling::set_source_uid(int64_t value) {
  _internal_set_source_uid(value);
  // @@protoc_insertion_point(field_set:Messages.Coupling.source_uid)
}

// int64 target_uid = 4;
inline void Coupling::clear_target_uid() {
  target_uid_ = int64_t{0};
}
inline int64_t Coupling::_internal_target_uid() const {
  return target_uid_;
}
inline int64_t Coupling::target_uid() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.target_uid)
  return _internal_target_uid();
}
inline void Coupling::_internal_set_target_uid(int64_t value) {
  
  target_uid_ = value;
}
inline void Coupling::set_target_uid(int64_t value) {
  _internal_set_target_uid(value);
  // @@protoc_insertion_point(field_set:Messages.Coupling.target_uid)
}

// .Messages.Zone source_region = 5;
inline bool Coupling::_internal_has_source_region() const {
  return this != internal_default_instance() && source_region_ != nullptr;
}
inline bool Coupling::has_source_region() const {
  return _internal_has_source_region();
}
inline const ::Messages::Zone& Coupling::_internal_source_region() const {
  const ::Messages::Zone* p = source_region_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Zone&>(
      ::Messages::_Zone_default_instance_);
}
inline const ::Messages::Zone& Coupling::source_region() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.source_region)
  return _internal_source_region();
}
inline void Coupling::unsafe_arena_set_allocated_source_region(
    ::Messages::Zone* source_region) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_region_);
  }
  source_region_ = source_region;
  if (source_region) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Coupling.source_region)
}
inline ::Messages::Zone* Coupling::release_source_region() {
  
  ::Messages::Zone* temp = source_region_;
  source_region_ = 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 ::Messages::Zone* Coupling::unsafe_arena_release_source_region() {
  // @@protoc_insertion_point(field_release:Messages.Coupling.source_region)
  
  ::Messages::Zone* temp = source_region_;
  source_region_ = nullptr;
  return temp;
}
inline ::Messages::Zone* Coupling::_internal_mutable_source_region() {
  
  if (source_region_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Zone>(GetArenaForAllocation());
    source_region_ = p;
  }
  return source_region_;
}
inline ::Messages::Zone* Coupling::mutable_source_region() {
  ::Messages::Zone* _msg = _internal_mutable_source_region();
  // @@protoc_insertion_point(field_mutable:Messages.Coupling.source_region)
  return _msg;
}
inline void Coupling::set_allocated_source_region(::Messages::Zone* source_region) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_region_);
  }
  if (source_region) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(source_region));
    if (message_arena != submessage_arena) {
      source_region = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, source_region, submessage_arena);
    }
    
  } else {
    
  }
  source_region_ = source_region;
  // @@protoc_insertion_point(field_set_allocated:Messages.Coupling.source_region)
}

// .Messages.Zone target_region = 6;
inline bool Coupling::_internal_has_target_region() const {
  return this != internal_default_instance() && target_region_ != nullptr;
}
inline bool Coupling::has_target_region() const {
  return _internal_has_target_region();
}
inline const ::Messages::Zone& Coupling::_internal_target_region() const {
  const ::Messages::Zone* p = target_region_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Zone&>(
      ::Messages::_Zone_default_instance_);
}
inline const ::Messages::Zone& Coupling::target_region() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.target_region)
  return _internal_target_region();
}
inline void Coupling::unsafe_arena_set_allocated_target_region(
    ::Messages::Zone* target_region) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(target_region_);
  }
  target_region_ = target_region;
  if (target_region) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Coupling.target_region)
}
inline ::Messages::Zone* Coupling::release_target_region() {
  
  ::Messages::Zone* temp = target_region_;
  target_region_ = 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 ::Messages::Zone* Coupling::unsafe_arena_release_target_region() {
  // @@protoc_insertion_point(field_release:Messages.Coupling.target_region)
  
  ::Messages::Zone* temp = target_region_;
  target_region_ = nullptr;
  return temp;
}
inline ::Messages::Zone* Coupling::_internal_mutable_target_region() {
  
  if (target_region_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Zone>(GetArenaForAllocation());
    target_region_ = p;
  }
  return target_region_;
}
inline ::Messages::Zone* Coupling::mutable_target_region() {
  ::Messages::Zone* _msg = _internal_mutable_target_region();
  // @@protoc_insertion_point(field_mutable:Messages.Coupling.target_region)
  return _msg;
}
inline void Coupling::set_allocated_target_region(::Messages::Zone* target_region) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(target_region_);
  }
  if (target_region) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(target_region));
    if (message_arena != submessage_arena) {
      target_region = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, target_region, submessage_arena);
    }
    
  } else {
    
  }
  target_region_ = target_region;
  // @@protoc_insertion_point(field_set_allocated:Messages.Coupling.target_region)
}

// uint32 sampling_mode = 9;
inline void Coupling::clear_sampling_mode() {
  sampling_mode_ = 0u;
}
inline uint32_t Coupling::_internal_sampling_mode() const {
  return sampling_mode_;
}
inline uint32_t Coupling::sampling_mode() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.sampling_mode)
  return _internal_sampling_mode();
}
inline void Coupling::_internal_set_sampling_mode(uint32_t value) {
  
  sampling_mode_ = value;
}
inline void Coupling::set_sampling_mode(uint32_t value) {
  _internal_set_sampling_mode(value);
  // @@protoc_insertion_point(field_set:Messages.Coupling.sampling_mode)
}

// string name = 10;
inline void Coupling::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& Coupling::name() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.name)
  return _internal_name();
}
template <typename ArgT0, typename... ArgT>
inline PROTOBUF_ALWAYS_INLINE
void Coupling::set_name(ArgT0&& arg0, ArgT... args) {
 
 name_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
  // @@protoc_insertion_point(field_set:Messages.Coupling.name)
}
inline std::string* Coupling::mutable_name() {
  std::string* _s = _internal_mutable_name();
  // @@protoc_insertion_point(field_mutable:Messages.Coupling.name)
  return _s;
}
inline const std::string& Coupling::_internal_name() const {
  return name_.Get();
}
inline void Coupling::_internal_set_name(const std::string& value) {
  
  name_.Set(value, GetArenaForAllocation());
}
inline std::string* Coupling::_internal_mutable_name() {
  
  return name_.Mutable(GetArenaForAllocation());
}
inline std::string* Coupling::release_name() {
  // @@protoc_insertion_point(field_release:Messages.Coupling.name)
  return name_.Release();
}
inline void Coupling::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(name, GetArenaForAllocation());
#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
  if (name_.IsDefault()) {
    name_.Set("", GetArenaForAllocation());
  }
#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
  // @@protoc_insertion_point(field_set_allocated:Messages.Coupling.name)
}

// repeated string dofs = 11;
inline int Coupling::_internal_dofs_size() const {
  return dofs_.size();
}
inline int Coupling::dofs_size() const {
  return _internal_dofs_size();
}
inline void Coupling::clear_dofs() {
  dofs_.Clear();
}
inline std::string* Coupling::add_dofs() {
  std::string* _s = _internal_add_dofs();
  // @@protoc_insertion_point(field_add_mutable:Messages.Coupling.dofs)
  return _s;
}
inline const std::string& Coupling::_internal_dofs(int index) const {
  return dofs_.Get(index);
}
inline const std::string& Coupling::dofs(int index) const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.dofs)
  return _internal_dofs(index);
}
inline std::string* Coupling::mutable_dofs(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.Coupling.dofs)
  return dofs_.Mutable(index);
}
inline void Coupling::set_dofs(int index, const std::string& value) {
  dofs_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.Coupling.dofs)
}
inline void Coupling::set_dofs(int index, std::string&& value) {
  dofs_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.Coupling.dofs)
}
inline void Coupling::set_dofs(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  dofs_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.Coupling.dofs)
}
inline void Coupling::set_dofs(int index, const char* value, size_t size) {
  dofs_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.Coupling.dofs)
}
inline std::string* Coupling::_internal_add_dofs() {
  return dofs_.Add();
}
inline void Coupling::add_dofs(const std::string& value) {
  dofs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.Coupling.dofs)
}
inline void Coupling::add_dofs(std::string&& value) {
  dofs_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.Coupling.dofs)
}
inline void Coupling::add_dofs(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  dofs_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.Coupling.dofs)
}
inline void Coupling::add_dofs(const char* value, size_t size) {
  dofs_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.Coupling.dofs)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
Coupling::dofs() const {
  // @@protoc_insertion_point(field_list:Messages.Coupling.dofs)
  return dofs_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
Coupling::mutable_dofs() {
  // @@protoc_insertion_point(field_mutable_list:Messages.Coupling.dofs)
  return &dofs_;
}

// .Messages.Representation representation = 12;
inline bool Coupling::_internal_has_representation() const {
  return this != internal_default_instance() && representation_ != nullptr;
}
inline bool Coupling::has_representation() const {
  return _internal_has_representation();
}
inline const ::Messages::Representation& Coupling::_internal_representation() const {
  const ::Messages::Representation* p = representation_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Representation&>(
      ::Messages::_Representation_default_instance_);
}
inline const ::Messages::Representation& Coupling::representation() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.representation)
  return _internal_representation();
}
inline void Coupling::unsafe_arena_set_allocated_representation(
    ::Messages::Representation* representation) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(representation_);
  }
  representation_ = representation;
  if (representation) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.Coupling.representation)
}
inline ::Messages::Representation* Coupling::release_representation() {
  
  ::Messages::Representation* temp = representation_;
  representation_ = 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 ::Messages::Representation* Coupling::unsafe_arena_release_representation() {
  // @@protoc_insertion_point(field_release:Messages.Coupling.representation)
  
  ::Messages::Representation* temp = representation_;
  representation_ = nullptr;
  return temp;
}
inline ::Messages::Representation* Coupling::_internal_mutable_representation() {
  
  if (representation_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Representation>(GetArenaForAllocation());
    representation_ = p;
  }
  return representation_;
}
inline ::Messages::Representation* Coupling::mutable_representation() {
  ::Messages::Representation* _msg = _internal_mutable_representation();
  // @@protoc_insertion_point(field_mutable:Messages.Coupling.representation)
  return _msg;
}
inline void Coupling::set_allocated_representation(::Messages::Representation* representation) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(representation_);
  }
  if (representation) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(representation));
    if (message_arena != submessage_arena) {
      representation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, representation, submessage_arena);
    }
    
  } else {
    
  }
  representation_ = representation;
  // @@protoc_insertion_point(field_set_allocated:Messages.Coupling.representation)
}

// bool enabled = 13;
inline void Coupling::clear_enabled() {
  enabled_ = false;
}
inline bool Coupling::_internal_enabled() const {
  return enabled_;
}
inline bool Coupling::enabled() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.enabled)
  return _internal_enabled();
}
inline void Coupling::_internal_set_enabled(bool value) {
  
  enabled_ = value;
}
inline void Coupling::set_enabled(bool value) {
  _internal_set_enabled(value);
  // @@protoc_insertion_point(field_set:Messages.Coupling.enabled)
}

// bool forward = 14;
inline void Coupling::clear_forward() {
  forward_ = false;
}
inline bool Coupling::_internal_forward() const {
  return forward_;
}
inline bool Coupling::forward() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.forward)
  return _internal_forward();
}
inline void Coupling::_internal_set_forward(bool value) {
  
  forward_ = value;
}
inline void Coupling::set_forward(bool value) {
  _internal_set_forward(value);
  // @@protoc_insertion_point(field_set:Messages.Coupling.forward)
}

// bool reverse = 15;
inline void Coupling::clear_reverse() {
  reverse_ = false;
}
inline bool Coupling::_internal_reverse() const {
  return reverse_;
}
inline bool Coupling::reverse() const {
  // @@protoc_insertion_point(field_get:Messages.Coupling.reverse)
  return _internal_reverse();
}
inline void Coupling::_internal_set_reverse(bool value) {
  
  reverse_ = value;
}
inline void Coupling::set_reverse(bool value) {
  _internal_set_reverse(value);
  // @@protoc_insertion_point(field_set:Messages.Coupling.reverse)
}

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

// System

// .Messages.Meta meta = 1;
inline bool System::_internal_has_meta() const {
  return this != internal_default_instance() && meta_ != nullptr;
}
inline bool System::has_meta() const {
  return _internal_has_meta();
}
inline const ::Messages::Meta& System::_internal_meta() const {
  const ::Messages::Meta* p = meta_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Meta&>(
      ::Messages::_Meta_default_instance_);
}
inline const ::Messages::Meta& System::meta() const {
  // @@protoc_insertion_point(field_get:Messages.System.meta)
  return _internal_meta();
}
inline void System::unsafe_arena_set_allocated_meta(
    ::Messages::Meta* meta) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(meta_);
  }
  meta_ = meta;
  if (meta) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.System.meta)
}
inline ::Messages::Meta* System::release_meta() {
  
  ::Messages::Meta* temp = meta_;
  meta_ = 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 ::Messages::Meta* System::unsafe_arena_release_meta() {
  // @@protoc_insertion_point(field_release:Messages.System.meta)
  
  ::Messages::Meta* temp = meta_;
  meta_ = nullptr;
  return temp;
}
inline ::Messages::Meta* System::_internal_mutable_meta() {
  
  if (meta_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Meta>(GetArenaForAllocation());
    meta_ = p;
  }
  return meta_;
}
inline ::Messages::Meta* System::mutable_meta() {
  ::Messages::Meta* _msg = _internal_mutable_meta();
  // @@protoc_insertion_point(field_mutable:Messages.System.meta)
  return _msg;
}
inline void System::set_allocated_meta(::Messages::Meta* meta) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(meta_);
  }
  if (meta) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(meta));
    if (message_arena != submessage_arena) {
      meta = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, meta, submessage_arena);
    }
    
  } else {
    
  }
  meta_ = meta;
  // @@protoc_insertion_point(field_set_allocated:Messages.System.meta)
}

// repeated .Messages.Script script = 2;
inline int System::_internal_script_size() const {
  return script_.size();
}
inline int System::script_size() const {
  return _internal_script_size();
}
inline void System::clear_script() {
  script_.Clear();
}
inline ::Messages::Script* System::mutable_script(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.System.script)
  return script_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Script >*
System::mutable_script() {
  // @@protoc_insertion_point(field_mutable_list:Messages.System.script)
  return &script_;
}
inline const ::Messages::Script& System::_internal_script(int index) const {
  return script_.Get(index);
}
inline const ::Messages::Script& System::script(int index) const {
  // @@protoc_insertion_point(field_get:Messages.System.script)
  return _internal_script(index);
}
inline ::Messages::Script* System::_internal_add_script() {
  return script_.Add();
}
inline ::Messages::Script* System::add_script() {
  ::Messages::Script* _add = _internal_add_script();
  // @@protoc_insertion_point(field_add:Messages.System.script)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Script >&
System::script() const {
  // @@protoc_insertion_point(field_list:Messages.System.script)
  return script_;
}

// repeated double local_transform = 3;
inline int System::_internal_local_transform_size() const {
  return local_transform_.size();
}
inline int System::local_transform_size() const {
  return _internal_local_transform_size();
}
inline void System::clear_local_transform() {
  local_transform_.Clear();
}
inline double System::_internal_local_transform(int index) const {
  return local_transform_.Get(index);
}
inline double System::local_transform(int index) const {
  // @@protoc_insertion_point(field_get:Messages.System.local_transform)
  return _internal_local_transform(index);
}
inline void System::set_local_transform(int index, double value) {
  local_transform_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.System.local_transform)
}
inline void System::_internal_add_local_transform(double value) {
  local_transform_.Add(value);
}
inline void System::add_local_transform(double value) {
  _internal_add_local_transform(value);
  // @@protoc_insertion_point(field_add:Messages.System.local_transform)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
System::_internal_local_transform() const {
  return local_transform_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
System::local_transform() const {
  // @@protoc_insertion_point(field_list:Messages.System.local_transform)
  return _internal_local_transform();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
System::_internal_mutable_local_transform() {
  return &local_transform_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
System::mutable_local_transform() {
  // @@protoc_insertion_point(field_mutable_list:Messages.System.local_transform)
  return _internal_mutable_local_transform();
}

// repeated double local_rate = 4;
inline int System::_internal_local_rate_size() const {
  return local_rate_.size();
}
inline int System::local_rate_size() const {
  return _internal_local_rate_size();
}
inline void System::clear_local_rate() {
  local_rate_.Clear();
}
inline double System::_internal_local_rate(int index) const {
  return local_rate_.Get(index);
}
inline double System::local_rate(int index) const {
  // @@protoc_insertion_point(field_get:Messages.System.local_rate)
  return _internal_local_rate(index);
}
inline void System::set_local_rate(int index, double value) {
  local_rate_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.System.local_rate)
}
inline void System::_internal_add_local_rate(double value) {
  local_rate_.Add(value);
}
inline void System::add_local_rate(double value) {
  _internal_add_local_rate(value);
  // @@protoc_insertion_point(field_add:Messages.System.local_rate)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
System::_internal_local_rate() const {
  return local_rate_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
System::local_rate() const {
  // @@protoc_insertion_point(field_list:Messages.System.local_rate)
  return _internal_local_rate();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
System::_internal_mutable_local_rate() {
  return &local_rate_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
System::mutable_local_rate() {
  // @@protoc_insertion_point(field_mutable_list:Messages.System.local_rate)
  return _internal_mutable_local_rate();
}

// repeated double local_accel = 5;
inline int System::_internal_local_accel_size() const {
  return local_accel_.size();
}
inline int System::local_accel_size() const {
  return _internal_local_accel_size();
}
inline void System::clear_local_accel() {
  local_accel_.Clear();
}
inline double System::_internal_local_accel(int index) const {
  return local_accel_.Get(index);
}
inline double System::local_accel(int index) const {
  // @@protoc_insertion_point(field_get:Messages.System.local_accel)
  return _internal_local_accel(index);
}
inline void System::set_local_accel(int index, double value) {
  local_accel_.Set(index, value);
  // @@protoc_insertion_point(field_set:Messages.System.local_accel)
}
inline void System::_internal_add_local_accel(double value) {
  local_accel_.Add(value);
}
inline void System::add_local_accel(double value) {
  _internal_add_local_accel(value);
  // @@protoc_insertion_point(field_add:Messages.System.local_accel)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
System::_internal_local_accel() const {
  return local_accel_;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >&
System::local_accel() const {
  // @@protoc_insertion_point(field_list:Messages.System.local_accel)
  return _internal_local_accel();
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
System::_internal_mutable_local_accel() {
  return &local_accel_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< double >*
System::mutable_local_accel() {
  // @@protoc_insertion_point(field_mutable_list:Messages.System.local_accel)
  return _internal_mutable_local_accel();
}

// repeated string children = 6;
inline int System::_internal_children_size() const {
  return children_.size();
}
inline int System::children_size() const {
  return _internal_children_size();
}
inline void System::clear_children() {
  children_.Clear();
}
inline std::string* System::add_children() {
  std::string* _s = _internal_add_children();
  // @@protoc_insertion_point(field_add_mutable:Messages.System.children)
  return _s;
}
inline const std::string& System::_internal_children(int index) const {
  return children_.Get(index);
}
inline const std::string& System::children(int index) const {
  // @@protoc_insertion_point(field_get:Messages.System.children)
  return _internal_children(index);
}
inline std::string* System::mutable_children(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.System.children)
  return children_.Mutable(index);
}
inline void System::set_children(int index, const std::string& value) {
  children_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.System.children)
}
inline void System::set_children(int index, std::string&& value) {
  children_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.System.children)
}
inline void System::set_children(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  children_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.System.children)
}
inline void System::set_children(int index, const char* value, size_t size) {
  children_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.System.children)
}
inline std::string* System::_internal_add_children() {
  return children_.Add();
}
inline void System::add_children(const std::string& value) {
  children_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.System.children)
}
inline void System::add_children(std::string&& value) {
  children_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.System.children)
}
inline void System::add_children(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  children_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.System.children)
}
inline void System::add_children(const char* value, size_t size) {
  children_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.System.children)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
System::children() const {
  // @@protoc_insertion_point(field_list:Messages.System.children)
  return children_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
System::mutable_children() {
  // @@protoc_insertion_point(field_mutable_list:Messages.System.children)
  return &children_;
}

// repeated string referenced_files = 7;
inline int System::_internal_referenced_files_size() const {
  return referenced_files_.size();
}
inline int System::referenced_files_size() const {
  return _internal_referenced_files_size();
}
inline void System::clear_referenced_files() {
  referenced_files_.Clear();
}
inline std::string* System::add_referenced_files() {
  std::string* _s = _internal_add_referenced_files();
  // @@protoc_insertion_point(field_add_mutable:Messages.System.referenced_files)
  return _s;
}
inline const std::string& System::_internal_referenced_files(int index) const {
  return referenced_files_.Get(index);
}
inline const std::string& System::referenced_files(int index) const {
  // @@protoc_insertion_point(field_get:Messages.System.referenced_files)
  return _internal_referenced_files(index);
}
inline std::string* System::mutable_referenced_files(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.System.referenced_files)
  return referenced_files_.Mutable(index);
}
inline void System::set_referenced_files(int index, const std::string& value) {
  referenced_files_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.System.referenced_files)
}
inline void System::set_referenced_files(int index, std::string&& value) {
  referenced_files_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.System.referenced_files)
}
inline void System::set_referenced_files(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  referenced_files_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.System.referenced_files)
}
inline void System::set_referenced_files(int index, const char* value, size_t size) {
  referenced_files_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.System.referenced_files)
}
inline std::string* System::_internal_add_referenced_files() {
  return referenced_files_.Add();
}
inline void System::add_referenced_files(const std::string& value) {
  referenced_files_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.System.referenced_files)
}
inline void System::add_referenced_files(std::string&& value) {
  referenced_files_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.System.referenced_files)
}
inline void System::add_referenced_files(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  referenced_files_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.System.referenced_files)
}
inline void System::add_referenced_files(const char* value, size_t size) {
  referenced_files_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.System.referenced_files)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
System::referenced_files() const {
  // @@protoc_insertion_point(field_list:Messages.System.referenced_files)
  return referenced_files_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
System::mutable_referenced_files() {
  // @@protoc_insertion_point(field_mutable_list:Messages.System.referenced_files)
  return &referenced_files_;
}

// repeated .Messages.File embedded_files = 8;
inline int System::_internal_embedded_files_size() const {
  return embedded_files_.size();
}
inline int System::embedded_files_size() const {
  return _internal_embedded_files_size();
}
inline ::Messages::File* System::mutable_embedded_files(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.System.embedded_files)
  return embedded_files_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::File >*
System::mutable_embedded_files() {
  // @@protoc_insertion_point(field_mutable_list:Messages.System.embedded_files)
  return &embedded_files_;
}
inline const ::Messages::File& System::_internal_embedded_files(int index) const {
  return embedded_files_.Get(index);
}
inline const ::Messages::File& System::embedded_files(int index) const {
  // @@protoc_insertion_point(field_get:Messages.System.embedded_files)
  return _internal_embedded_files(index);
}
inline ::Messages::File* System::_internal_add_embedded_files() {
  return embedded_files_.Add();
}
inline ::Messages::File* System::add_embedded_files() {
  ::Messages::File* _add = _internal_add_embedded_files();
  // @@protoc_insertion_point(field_add:Messages.System.embedded_files)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::File >&
System::embedded_files() const {
  // @@protoc_insertion_point(field_list:Messages.System.embedded_files)
  return embedded_files_;
}

// repeated string notes = 9;
inline int System::_internal_notes_size() const {
  return notes_.size();
}
inline int System::notes_size() const {
  return _internal_notes_size();
}
inline void System::clear_notes() {
  notes_.Clear();
}
inline std::string* System::add_notes() {
  std::string* _s = _internal_add_notes();
  // @@protoc_insertion_point(field_add_mutable:Messages.System.notes)
  return _s;
}
inline const std::string& System::_internal_notes(int index) const {
  return notes_.Get(index);
}
inline const std::string& System::notes(int index) const {
  // @@protoc_insertion_point(field_get:Messages.System.notes)
  return _internal_notes(index);
}
inline std::string* System::mutable_notes(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.System.notes)
  return notes_.Mutable(index);
}
inline void System::set_notes(int index, const std::string& value) {
  notes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set:Messages.System.notes)
}
inline void System::set_notes(int index, std::string&& value) {
  notes_.Mutable(index)->assign(std::move(value));
  // @@protoc_insertion_point(field_set:Messages.System.notes)
}
inline void System::set_notes(int index, const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  notes_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:Messages.System.notes)
}
inline void System::set_notes(int index, const char* value, size_t size) {
  notes_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:Messages.System.notes)
}
inline std::string* System::_internal_add_notes() {
  return notes_.Add();
}
inline void System::add_notes(const std::string& value) {
  notes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:Messages.System.notes)
}
inline void System::add_notes(std::string&& value) {
  notes_.Add(std::move(value));
  // @@protoc_insertion_point(field_add:Messages.System.notes)
}
inline void System::add_notes(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  notes_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:Messages.System.notes)
}
inline void System::add_notes(const char* value, size_t size) {
  notes_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:Messages.System.notes)
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
System::notes() const {
  // @@protoc_insertion_point(field_list:Messages.System.notes)
  return notes_;
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
System::mutable_notes() {
  // @@protoc_insertion_point(field_mutable_list:Messages.System.notes)
  return &notes_;
}

// repeated .Messages.Coupling couplings = 10;
inline int System::_internal_couplings_size() const {
  return couplings_.size();
}
inline int System::couplings_size() const {
  return _internal_couplings_size();
}
inline void System::clear_couplings() {
  couplings_.Clear();
}
inline ::Messages::Coupling* System::mutable_couplings(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.System.couplings)
  return couplings_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Coupling >*
System::mutable_couplings() {
  // @@protoc_insertion_point(field_mutable_list:Messages.System.couplings)
  return &couplings_;
}
inline const ::Messages::Coupling& System::_internal_couplings(int index) const {
  return couplings_.Get(index);
}
inline const ::Messages::Coupling& System::couplings(int index) const {
  // @@protoc_insertion_point(field_get:Messages.System.couplings)
  return _internal_couplings(index);
}
inline ::Messages::Coupling* System::_internal_add_couplings() {
  return couplings_.Add();
}
inline ::Messages::Coupling* System::add_couplings() {
  ::Messages::Coupling* _add = _internal_add_couplings();
  // @@protoc_insertion_point(field_add:Messages.System.couplings)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Coupling >&
System::couplings() const {
  // @@protoc_insertion_point(field_list:Messages.System.couplings)
  return couplings_;
}

// repeated .Messages.Model models = 11;
inline int System::_internal_models_size() const {
  return models_.size();
}
inline int System::models_size() const {
  return _internal_models_size();
}
inline void System::clear_models() {
  models_.Clear();
}
inline ::Messages::Model* System::mutable_models(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.System.models)
  return models_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Model >*
System::mutable_models() {
  // @@protoc_insertion_point(field_mutable_list:Messages.System.models)
  return &models_;
}
inline const ::Messages::Model& System::_internal_models(int index) const {
  return models_.Get(index);
}
inline const ::Messages::Model& System::models(int index) const {
  // @@protoc_insertion_point(field_get:Messages.System.models)
  return _internal_models(index);
}
inline ::Messages::Model* System::_internal_add_models() {
  return models_.Add();
}
inline ::Messages::Model* System::add_models() {
  ::Messages::Model* _add = _internal_add_models();
  // @@protoc_insertion_point(field_add:Messages.System.models)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Model >&
System::models() const {
  // @@protoc_insertion_point(field_list:Messages.System.models)
  return models_;
}

// .Messages.Record64 physical_constants = 12;
inline bool System::_internal_has_physical_constants() const {
  return this != internal_default_instance() && physical_constants_ != nullptr;
}
inline bool System::has_physical_constants() const {
  return _internal_has_physical_constants();
}
inline const ::Messages::Record64& System::_internal_physical_constants() const {
  const ::Messages::Record64* p = physical_constants_;
  return p != nullptr ? *p : reinterpret_cast<const ::Messages::Record64&>(
      ::Messages::_Record64_default_instance_);
}
inline const ::Messages::Record64& System::physical_constants() const {
  // @@protoc_insertion_point(field_get:Messages.System.physical_constants)
  return _internal_physical_constants();
}
inline void System::unsafe_arena_set_allocated_physical_constants(
    ::Messages::Record64* physical_constants) {
  if (GetArenaForAllocation() == nullptr) {
    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(physical_constants_);
  }
  physical_constants_ = physical_constants;
  if (physical_constants) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:Messages.System.physical_constants)
}
inline ::Messages::Record64* System::release_physical_constants() {
  
  ::Messages::Record64* temp = physical_constants_;
  physical_constants_ = 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 ::Messages::Record64* System::unsafe_arena_release_physical_constants() {
  // @@protoc_insertion_point(field_release:Messages.System.physical_constants)
  
  ::Messages::Record64* temp = physical_constants_;
  physical_constants_ = nullptr;
  return temp;
}
inline ::Messages::Record64* System::_internal_mutable_physical_constants() {
  
  if (physical_constants_ == nullptr) {
    auto* p = CreateMaybeMessage<::Messages::Record64>(GetArenaForAllocation());
    physical_constants_ = p;
  }
  return physical_constants_;
}
inline ::Messages::Record64* System::mutable_physical_constants() {
  ::Messages::Record64* _msg = _internal_mutable_physical_constants();
  // @@protoc_insertion_point(field_mutable:Messages.System.physical_constants)
  return _msg;
}
inline void System::set_allocated_physical_constants(::Messages::Record64* physical_constants) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(physical_constants_);
  }
  if (physical_constants) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
        ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(
                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(physical_constants));
    if (message_arena != submessage_arena) {
      physical_constants = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, physical_constants, submessage_arena);
    }
    
  } else {
    
  }
  physical_constants_ = physical_constants;
  // @@protoc_insertion_point(field_set_allocated:Messages.System.physical_constants)
}

// repeated .Messages.Command conditions = 13;
inline int System::_internal_conditions_size() const {
  return conditions_.size();
}
inline int System::conditions_size() const {
  return _internal_conditions_size();
}
inline void System::clear_conditions() {
  conditions_.Clear();
}
inline ::Messages::Command* System::mutable_conditions(int index) {
  // @@protoc_insertion_point(field_mutable:Messages.System.conditions)
  return conditions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >*
System::mutable_conditions() {
  // @@protoc_insertion_point(field_mutable_list:Messages.System.conditions)
  return &conditions_;
}
inline const ::Messages::Command& System::_internal_conditions(int index) const {
  return conditions_.Get(index);
}
inline const ::Messages::Command& System::conditions(int index) const {
  // @@protoc_insertion_point(field_get:Messages.System.conditions)
  return _internal_conditions(index);
}
inline ::Messages::Command* System::_internal_add_conditions() {
  return conditions_.Add();
}
inline ::Messages::Command* System::add_conditions() {
  ::Messages::Command* _add = _internal_add_conditions();
  // @@protoc_insertion_point(field_add:Messages.System.conditions)
  return _add;
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::Messages::Command >&
System::conditions() const {
  // @@protoc_insertion_point(field_list:Messages.System.conditions)
  return conditions_;
}

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace Messages

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_concept_2eproto
