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

// source: iobuf.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_iobuf_2eproto

#define GOOGLE_PROTOBUF_INCLUDED_iobuf_2eproto

#include <limits>

#include <string>

#include <google/protobuf/port_def.inc>

#if PROTOBUF_VERSION < 3021000

#error This file was generated by a newer version of protoc which is

#error incompatible with your Protocol Buffer headers. Please update

#error your headers.

#endif

#if 3021012 < 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/generated_enum_reflection.h>

#include <google/protobuf/unknown_field_set.h>

// @@protoc_insertion_point(includes)

#include <google/protobuf/port_def.inc>

#define PROTOBUF_INTERNAL_EXPORT_iobuf_2eproto

PROTOBUF_NAMESPACE_OPEN

namespace internal {

class AnyMetadata;

}  // namespace internal

PROTOBUF_NAMESPACE_CLOSE

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

struct TableStruct_iobuf_2eproto {

  static const uint32_t offsets[];

};

extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_iobuf_2eproto;

namespace proto {

class Misc;

struct MiscDefaultTypeInternal;

extern MiscDefaultTypeInternal _Misc_default_instance_;

}  // namespace proto

PROTOBUF_NAMESPACE_OPEN

template<> ::proto::Misc* Arena::CreateMaybeMessage<::proto::Misc>(Arena*);

PROTOBUF_NAMESPACE_CLOSE

namespace proto {

enum CompressType : int {

  CompressTypeNone = 0,

  CompressTypeGzip = 1,

  CompressTypeZlib = 2,

  CompressTypeSnappy = 3,

  CompressTypeLZ4 = 4

};

bool CompressType_IsValid(int value);

constexpr CompressType CompressType_MIN = CompressTypeNone;

constexpr CompressType CompressType_MAX = CompressTypeLZ4;

constexpr int CompressType_ARRAYSIZE = CompressType_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CompressType_descriptor();

template<typename T>

inline const std::string& CompressType_Name(T enum_t_value) {

  static_assert(::std::is_same<T, CompressType>::value ||

    ::std::is_integral<T>::value,

    "Incorrect type passed to function CompressType_Name.");

  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(

    CompressType_descriptor(), enum_t_value);

}

inline bool CompressType_Parse(

    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CompressType* value) {

  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CompressType>(

    CompressType_descriptor(), name, value);

}

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

class Misc final :

    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.Misc) */ {

 public:

  inline Misc() : Misc(nullptr) {}

  ~Misc() override;

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

  Misc(const Misc& from);

  Misc(Misc&& from) noexcept

    : Misc() {

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

  }

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

    CopyFrom(from);

    return *this;

  }

  inline Misc& operator=(Misc&& from) noexcept {

    if (this == &from) return *this;

    if (GetOwningArena() == from.GetOwningArena()

  #ifdef PROTOBUF_FORCE_COPY_IN_MOVE

        && GetOwningArena() != nullptr

  #endif  // !PROTOBUF_FORCE_COPY_IN_MOVE

    ) {

      InternalSwap(&from);

    } else {

      CopyFrom(from);

    }

    return *this;

  }

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

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

  }

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

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

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {

    return GetDescriptor();

  }

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {

    return default_instance().GetMetadata().descriptor;

  }

  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {

    return default_instance().GetMetadata().reflection;

  }

  static const Misc& default_instance() {

    return *internal_default_instance();

  }

  static inline const Misc* internal_default_instance() {

    return reinterpret_cast<const Misc*>(

               &_Misc_default_instance_);

  }

  static constexpr int kIndexInFileMessages =

    0;

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

    a.Swap(&b);

  }

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

    if (other == this) return;

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

    InternalSwap(other);

  }

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

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

    return CreateMaybeMessage<Misc>(arena);

  }

  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;

  void CopyFrom(const Misc& from);

  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;

  void MergeFrom( const Misc& from) {

    Misc::MergeImpl(*this, from);

  }

  private:

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

  public:

  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;

  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;

  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;

  uint8_t* _InternalSerialize(

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

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

  private:

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

  void SharedDtor();

  void SetCachedSize(int size) const final;

  void InternalSwap(Misc* other);

  private:

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

  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {

    return "proto.Misc";

  }

  protected:

  explicit Misc(::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 {

    kRepeatedEnumFieldNumber = 3,

    kRepeatedUint64FieldNumber = 6,

    kRepeatedStringFieldNumber = 9,

    kRepeatedBoolFieldNumber = 12,

    kRepeatedInt32FieldNumber = 15,

    kRequiredStringFieldNumber = 7,

    kOptionalStringFieldNumber = 8,

    kRequiredEnumFieldNumber = 1,

    kOptionalEnumFieldNumber = 2,

    kRequiredUint64FieldNumber = 4,

    kOptionalUint64FieldNumber = 5,

    kRequiredBoolFieldNumber = 10,

    kOptionalBoolFieldNumber = 11,

    kRequiredInt32FieldNumber = 13,

    kOptionalInt32FieldNumber = 14,

  };

  // repeated .proto.CompressType repeated_enum = 3;

  int repeated_enum_size() const;

  private:

  int _internal_repeated_enum_size() const;

  public:

  void clear_repeated_enum();

  private:

  ::proto::CompressType _internal_repeated_enum(int index) const;

  void _internal_add_repeated_enum(::proto::CompressType value);

  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_repeated_enum();

  public:

  ::proto::CompressType repeated_enum(int index) const;

  void set_repeated_enum(int index, ::proto::CompressType value);

  void add_repeated_enum(::proto::CompressType value);

  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& repeated_enum() const;

  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_repeated_enum();

  // repeated uint64 repeated_uint64 = 6;

  int repeated_uint64_size() const;

  private:

  int _internal_repeated_uint64_size() const;

  public:

  void clear_repeated_uint64();

  private:

  uint64_t _internal_repeated_uint64(int index) const;

  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&

      _internal_repeated_uint64() const;

  void _internal_add_repeated_uint64(uint64_t value);

  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*

      _internal_mutable_repeated_uint64();

  public:

  uint64_t repeated_uint64(int index) const;

  void set_repeated_uint64(int index, uint64_t value);

  void add_repeated_uint64(uint64_t value);

  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&

      repeated_uint64() const;

  ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*

      mutable_repeated_uint64();

  // repeated string repeated_string = 9;

  int repeated_string_size() const;

  private:

  int _internal_repeated_string_size() const;

  public:

  void clear_repeated_string();

  const std::string& repeated_string(int index) const;

  std::string* mutable_repeated_string(int index);

  void set_repeated_string(int index, const std::string& value);

  void set_repeated_string(int index, std::string&& value);

  void set_repeated_string(int index, const char* value);

  void set_repeated_string(int index, const char* value, size_t size);

  std::string* add_repeated_string();

  void add_repeated_string(const std::string& value);

  void add_repeated_string(std::string&& value);

  void add_repeated_string(const char* value);

  void add_repeated_string(const char* value, size_t size);

  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& repeated_string() const;

  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_repeated_string();

  private:

  const std::string& _internal_repeated_string(int index) const;

  std::string* _internal_add_repeated_string();

  public:

  // repeated bool repeated_bool = 12;

  int repeated_bool_size() const;

  private:

  int _internal_repeated_bool_size() const;

  public:

  void clear_repeated_bool();

  private:

  bool _internal_repeated_bool(int index) const;

  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&

      _internal_repeated_bool() const;

  void _internal_add_repeated_bool(bool value);

  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*

      _internal_mutable_repeated_bool();

  public:

  bool repeated_bool(int index) const;

  void set_repeated_bool(int index, bool value);

  void add_repeated_bool(bool value);

  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >&

      repeated_bool() const;

  ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool >*

      mutable_repeated_bool();

  // repeated int32 repeated_int32 = 15;

  int repeated_int32_size() const;

  private:

  int _internal_repeated_int32_size() const;

  public:

  void clear_repeated_int32();

  private:

  int32_t _internal_repeated_int32(int index) const;

  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&

      _internal_repeated_int32() const;

  void _internal_add_repeated_int32(int32_t value);

  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*

      _internal_mutable_repeated_int32();

  public:

  int32_t repeated_int32(int index) const;

  void set_repeated_int32(int index, int32_t value);

  void add_repeated_int32(int32_t value);

  const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >&

      repeated_int32() const;

  ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t >*

      mutable_repeated_int32();

  // required string required_string = 7;

  bool has_required_string() const;

  private:

  bool _internal_has_required_string() const;

  public:

  void clear_required_string();

  const std::string& required_string() const;

  template <typename ArgT0 = const std::string&, typename... ArgT>

  void set_required_string(ArgT0&& arg0, ArgT... args);

  std::string* mutable_required_string();

  PROTOBUF_NODISCARD std::string* release_required_string();

  void set_allocated_required_string(std::string* required_string);

  private:

  const std::string& _internal_required_string() const;

  inline PROTOBUF_ALWAYS_INLINE void _internal_set_required_string(const std::string& value);

  std::string* _internal_mutable_required_string();

  public:

  // optional string optional_string = 8;

  bool has_optional_string() const;

  private:

  bool _internal_has_optional_string() const;

  public:

  void clear_optional_string();

  const std::string& optional_string() const;

  template <typename ArgT0 = const std::string&, typename... ArgT>

  void set_optional_string(ArgT0&& arg0, ArgT... args);

  std::string* mutable_optional_string();

  PROTOBUF_NODISCARD std::string* release_optional_string();

  void set_allocated_optional_string(std::string* optional_string);

  private:

  const std::string& _internal_optional_string() const;

  inline PROTOBUF_ALWAYS_INLINE void _internal_set_optional_string(const std::string& value);

  std::string* _internal_mutable_optional_string();

  public:

  // required .proto.CompressType required_enum = 1;

  bool has_required_enum() const;

  private:

  bool _internal_has_required_enum() const;

  public:

  void clear_required_enum();

  ::proto::CompressType required_enum() const;

  void set_required_enum(::proto::CompressType value);

  private:

  ::proto::CompressType _internal_required_enum() const;

  void _internal_set_required_enum(::proto::CompressType value);

  public:

  // optional .proto.CompressType optional_enum = 2;

  bool has_optional_enum() const;

  private:

  bool _internal_has_optional_enum() const;

  public:

  void clear_optional_enum();

  ::proto::CompressType optional_enum() const;

  void set_optional_enum(::proto::CompressType value);

  private:

  ::proto::CompressType _internal_optional_enum() const;

  void _internal_set_optional_enum(::proto::CompressType value);

  public:

  // required uint64 required_uint64 = 4;

  bool has_required_uint64() const;

  private:

  bool _internal_has_required_uint64() const;

  public:

  void clear_required_uint64();

  uint64_t required_uint64() const;

  void set_required_uint64(uint64_t value);

  private:

  uint64_t _internal_required_uint64() const;

  void _internal_set_required_uint64(uint64_t value);

  public:

  // optional uint64 optional_uint64 = 5;

  bool has_optional_uint64() const;

  private:

  bool _internal_has_optional_uint64() const;

  public:

  void clear_optional_uint64();

  uint64_t optional_uint64() const;

  void set_optional_uint64(uint64_t value);

  private:

  uint64_t _internal_optional_uint64() const;

  void _internal_set_optional_uint64(uint64_t value);

  public:

  // required bool required_bool = 10;

  bool has_required_bool() const;

  private:

  bool _internal_has_required_bool() const;

  public:

  void clear_required_bool();

  bool required_bool() const;

  void set_required_bool(bool value);

  private:

  bool _internal_required_bool() const;

  void _internal_set_required_bool(bool value);

  public:

  // optional bool optional_bool = 11;

  bool has_optional_bool() const;

  private:

  bool _internal_has_optional_bool() const;

  public:

  void clear_optional_bool();

  bool optional_bool() const;

  void set_optional_bool(bool value);

  private:

  bool _internal_optional_bool() const;

  void _internal_set_optional_bool(bool value);

  public:

  // required int32 required_int32 = 13;

  bool has_required_int32() const;

  private:

  bool _internal_has_required_int32() const;

  public:

  void clear_required_int32();

  int32_t required_int32() const;

  void set_required_int32(int32_t value);

  private:

  int32_t _internal_required_int32() const;

  void _internal_set_required_int32(int32_t value);

  public:

  // optional int32 optional_int32 = 14;

  bool has_optional_int32() const;

  private:

  bool _internal_has_optional_int32() const;

  public:

  void clear_optional_int32();

  int32_t optional_int32() const;

  void set_optional_int32(int32_t value);

  private:

  int32_t _internal_optional_int32() const;

  void _internal_set_optional_int32(int32_t value);

  public:

  // @@protoc_insertion_point(class_scope:proto.Misc)

 private:

  class _Internal;

  // helper for ByteSizeLong()

  size_t RequiredFieldsByteSizeFallback() const;

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

  typedef void InternalArenaConstructable_;

  typedef void DestructorSkippable_;

  struct Impl_ {

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

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

    ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> repeated_enum_;

    ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t > repeated_uint64_;

    ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> repeated_string_;

    ::PROTOBUF_NAMESPACE_ID::RepeatedField< bool > repeated_bool_;

    ::PROTOBUF_NAMESPACE_ID::RepeatedField< int32_t > repeated_int32_;

    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr required_string_;

    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr optional_string_;

    int required_enum_;

    int optional_enum_;

    uint64_t required_uint64_;

    uint64_t optional_uint64_;

    bool required_bool_;

    bool optional_bool_;

    int32_t required_int32_;

    int32_t optional_int32_;

  };

  union { Impl_ _impl_; };

  friend struct ::TableStruct_iobuf_2eproto;

};

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

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

#ifdef __GNUC__

  #pragma GCC diagnostic push

  #pragma GCC diagnostic ignored "-Wstrict-aliasing"

#endif  // __GNUC__

// Misc

// required .proto.CompressType required_enum = 1;

inline bool Misc::_internal_has_required_enum() const {

  bool value = (_impl_._has_bits_[0] & 0x00000004u) != 0;

  return value;

}

inline bool Misc::has_required_enum() const {

  return _internal_has_required_enum();

}

inline void Misc::clear_required_enum() {

  _impl_.required_enum_ = 0;

  _impl_._has_bits_[0] &= ~0x00000004u;

}

inline ::proto::CompressType Misc::_internal_required_enum() const {

  return static_cast< ::proto::CompressType >(_impl_.required_enum_);

}

inline ::proto::CompressType Misc::required_enum() const {

  // @@protoc_insertion_point(field_get:proto.Misc.required_enum)

  return _internal_required_enum();

}

inline void Misc::_internal_set_required_enum(::proto::CompressType value) {

  assert(::proto::CompressType_IsValid(value));

  _impl_._has_bits_[0] |= 0x00000004u;

  _impl_.required_enum_ = value;

}

inline void Misc::set_required_enum(::proto::CompressType value) {

  _internal_set_required_enum(value);

  // @@protoc_insertion_point(field_set:proto.Misc.required_enum)

}

// optional .proto.CompressType optional_enum = 2;

inline bool Misc::_internal_has_optional_enum() const {

  bool value = (_impl_._has_bits_[0] & 0x00000008u) != 0;

  return value;

}

inline bool Misc::has_optional_enum() const {

  return _internal_has_optional_enum();

}

inline void Misc::clear_optional_enum() {

  _impl_.optional_enum_ = 0;

  _impl_._has_bits_[0] &= ~0x00000008u;

}

inline ::proto::CompressType Misc::_internal_optional_enum() const {

  return static_cast< ::proto::CompressType >(_impl_.optional_enum_);

}

inline ::proto::CompressType Misc::optional_enum() const {

  // @@protoc_insertion_point(field_get:proto.Misc.optional_enum)

  return _internal_optional_enum();

}

inline void Misc::_internal_set_optional_enum(::proto::CompressType value) {

  assert(::proto::CompressType_IsValid(value));

  _impl_._has_bits_[0] |= 0x00000008u;

  _impl_.optional_enum_ = value;

}

inline void Misc::set_optional_enum(::proto::CompressType value) {

  _internal_set_optional_enum(value);

  // @@protoc_insertion_point(field_set:proto.Misc.optional_enum)

}

// repeated .proto.CompressType repeated_enum = 3;

inline int Misc::_internal_repeated_enum_size() const {

  return _impl_.repeated_enum_.size();

}

inline int Misc::repeated_enum_size() const {

  return _internal_repeated_enum_size();

}

inline void Misc::clear_repeated_enum() {

  _impl_.repeated_enum_.Clear();

}

inline ::proto::CompressType Misc::_internal_repeated_enum(int index) const {

  return static_cast< ::proto::CompressType >(_impl_.repeated_enum_.Get(index));

}

inline ::proto::CompressType Misc::repeated_enum(int index) const {

  // @@protoc_insertion_point(field_get:proto.Misc.repeated_enum)

  return _internal_repeated_enum(index);

}

inline void Misc::set_repeated_enum(int index, ::proto::CompressType value) {

  assert(::proto::CompressType_IsValid(value));

  _impl_.repeated_enum_.Set(index, value);

  // @@protoc_insertion_point(field_set:proto.Misc.repeated_enum)

}

inline void Misc::_internal_add_repeated_enum(::proto::CompressType value) {

  assert(::proto::CompressType_IsValid(value));

  _impl_.repeated_enum_.Add(value);

}

inline void Misc::add_repeated_enum(::proto::CompressType value) {

  _internal_add_repeated_enum(value);

  // @@protoc_insertion_point(field_add:proto.Misc.repeated_enum)

}

inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&

Misc::repeated_enum() const {

  // @@protoc_insertion_point(field_list:proto.Misc.repeated_enum)

  return _impl_.repeated_enum_;

}

inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*

Misc::_internal_mutable_repeated_enum() {

  return &_impl_.repeated_enum_;

}

inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*

Misc::mutable_repeated_enum() {

  // @@protoc_insertion_point(field_mutable_list:proto.Misc.repeated_enum)

  return _internal_mutable_repeated_enum();

}

// required uint64 required_uint64 = 4;

inline bool Misc::_internal_has_required_uint64() const {

  bool value = (_impl_._has_bits_[0] & 0x00000010u) != 0;

  return value;

}

inline bool Misc::has_required_uint64() const {

  return _internal_has_required_uint64();

}

inline void Misc::clear_required_uint64() {

  _impl_.required_uint64_ = uint64_t{0u};

  _impl_._has_bits_[0] &= ~0x00000010u;

}

inline uint64_t Misc::_internal_required_uint64() const {

  return _impl_.required_uint64_;

}

inline uint64_t Misc::required_uint64() const {

  // @@protoc_insertion_point(field_get:proto.Misc.required_uint64)

  return _internal_required_uint64();

}

inline void Misc::_internal_set_required_uint64(uint64_t value) {

  _impl_._has_bits_[0] |= 0x00000010u;

  _impl_.required_uint64_ = value;

}

inline void Misc::set_required_uint64(uint64_t value) {

  _internal_set_required_uint64(value);

  // @@protoc_insertion_point(field_set:proto.Misc.required_uint64)

}

// optional uint64 optional_uint64 = 5;

inline bool Misc::_internal_has_optional_uint64() const {

  bool value = (_impl_._has_bits_[0] & 0x00000020u) != 0;

  return value;

}

inline bool Misc::has_optional_uint64() const {

  return _internal_has_optional_uint64();

}

inline void Misc::clear_optional_uint64() {

  _impl_.optional_uint64_ = uint64_t{0u};

  _impl_._has_bits_[0] &= ~0x00000020u;

}

inline uint64_t Misc::_internal_optional_uint64() const {

  return _impl_.optional_uint64_;

}

inline uint64_t Misc::optional_uint64() const {

  // @@protoc_insertion_point(field_get:proto.Misc.optional_uint64)

  return _internal_optional_uint64();

}

inline void Misc::_internal_set_optional_uint64(uint64_t value) {

  _impl_._has_bits_[0] |= 0x00000020u;

  _impl_.optional_uint64_ = value;

}

inline void Misc::set_optional_uint64(uint64_t value) {

  _internal_set_optional_uint64(value);

  // @@protoc_insertion_point(field_set:proto.Misc.optional_uint64)

}

// repeated uint64 repeated_uint64 = 6;

inline int Misc::_internal_repeated_uint64_size() const {

  return _impl_.repeated_uint64_.size();

}

inline int Misc::repeated_uint64_size() const {

  return _internal_repeated_uint64_size();

}

inline void Misc::clear_repeated_uint64() {

  _impl_.repeated_uint64_.Clear();

}

inline uint64_t Misc::_internal_repeated_uint64(int index) const {

  return _impl_.repeated_uint64_.Get(index);

}

inline uint64_t Misc::repeated_uint64(int index) const {

  // @@protoc_insertion_point(field_get:proto.Misc.repeated_uint64)

  return _internal_repeated_uint64(index);

}

inline void Misc::set_repeated_uint64(int index, uint64_t value) {

  _impl_.repeated_uint64_.Set(index, value);

  // @@protoc_insertion_point(field_set:proto.Misc.repeated_uint64)

}

inline void Misc::_internal_add_repeated_uint64(uint64_t value) {

  _impl_.repeated_uint64_.Add(value);

}

inline void Misc::add_repeated_uint64(uint64_t value) {

  _internal_add_repeated_uint64(value);

  // @@protoc_insertion_point(field_add:proto.Misc.repeated_uint64)

}

inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&

Misc::_internal_repeated_uint64() const {

  return _impl_.repeated_uint64_;

}

inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >&

Misc::repeated_uint64() const {

  // @@protoc_insertion_point(field_list:proto.Misc.repeated_uint64)

  return _internal_repeated_uint64();

}

inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*

Misc::_internal_mutable_repeated_uint64() {

  return &_impl_.repeated_uint64_;

}

inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint64_t >*

Misc::mutable_repeated_uint64() {

  // @@protoc_insertion_point(field_mutable_list:proto.Misc.repeated_uint64)

  return _internal_mutable_repeated_uint64();

}

// required string required_string = 7;

inline bool Misc::_internal_has_required_string() const {

  bool value = (_impl_._has_bits_[0] & 0x00000001u) != 0;

  return value;

}

inline bool Misc::has_required_string() const {

  return _internal_has_required_string();

}

inline void Misc::clear_required_string() {

  _impl_.required_string_.ClearToEmpty();

  _impl_._has_bits_[0] &= ~0x00000001u;

}

inline const std::string& Misc::required_string() const {

  // @@protoc_insertion_point(field_get:proto.Misc.required_string)

  return _internal_required_string();

}

template <typename ArgT0, typename... ArgT>

inline PROTOBUF_ALWAYS_INLINE

void Misc::set_required_string(ArgT0&& arg0, ArgT... args) {

 _impl_._has_bits_[0] |= 0x00000001u;

 _impl_.required_string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());

  // @@protoc_insertion_point(field_set:proto.Misc.required_string)

}

inline std::string* Misc::mutable_required_string() {

  std::string* _s = _internal_mutable_required_string();

  // @@protoc_insertion_point(field_mutable:proto.Misc.required_string)

  return _s;

}

inline const std::string& Misc::_internal_required_string() const {

  return _impl_.required_string_.Get();

}

inline void Misc::_internal_set_required_string(const std::string& value) {

  _impl_._has_bits_[0] |= 0x00000001u;

  _impl_.required_string_.Set(value, GetArenaForAllocation());

}

inline std::string* Misc::_internal_mutable_required_string() {

  _impl_._has_bits_[0] |= 0x00000001u;

  return _impl_.required_string_.Mutable(GetArenaForAllocation());

}

inline std::string* Misc::release_required_string() {

  // @@protoc_insertion_point(field_release:proto.Misc.required_string)

  if (!_internal_has_required_string()) {

    return nullptr;

  }

  _impl_._has_bits_[0] &= ~0x00000001u;

  auto* p = _impl_.required_string_.Release();

#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING

  if (_impl_.required_string_.IsDefault()) {

    _impl_.required_string_.Set("", GetArenaForAllocation());

  }

#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING

  return p;

}

inline void Misc::set_allocated_required_string(std::string* required_string) {

  if (required_string != nullptr) {

    _impl_._has_bits_[0] |= 0x00000001u;

  } else {

    _impl_._has_bits_[0] &= ~0x00000001u;

  }

  _impl_.required_string_.SetAllocated(required_string, GetArenaForAllocation());

#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING

  if (_impl_.required_string_.IsDefault()) {

    _impl_.required_string_.Set("", GetArenaForAllocation());

  }

#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING

  // @@protoc_insertion_point(field_set_allocated:proto.Misc.required_string)

}

// optional string optional_string = 8;

inline bool Misc::_internal_has_optional_string() const {

  bool value = (_impl_._has_bits_[0] & 0x00000002u) != 0;

  return value;

}

inline bool Misc::has_optional_string() const {

  return _internal_has_optional_string();

}

inline void Misc::clear_optional_string() {

  _impl_.optional_string_.ClearToEmpty();

  _impl_._has_bits_[0] &= ~0x00000002u;

}

inline const std::string& Misc::optional_string() const {

  // @@protoc_insertion_point(field_get:proto.Misc.optional_string)

  return _internal_optional_string();

}

template <typename ArgT0, typename... ArgT>

inline PROTOBUF_ALWAYS_INLINE

void Misc::set_optional_string(ArgT0&& arg0, ArgT... args) {

 _impl_._has_bits_[0] |= 0x00000002u;

 _impl_.optional_string_.Set(static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());

  // @@protoc_insertion_point(field_set:proto.Misc.optional_string)

}

inline std::string* Misc::mutable_optional_string() {

  std::string* _s = _internal_mutable_optional_string();

  // @@protoc_insertion_point(field_mutable:proto.Misc.optional_string)

  return _s;

}

inline const std::string& Misc::_internal_optional_string() const {

  return _impl_.optional_string_.Get();

}

inline void Misc::_internal_set_optional_string(const std::string& value) {

  _impl_._has_bits_[0] |= 0x00000002u;

  _impl_.optional_string_.Set(value, GetArenaForAllocation());

}

inline std::string* Misc::_internal_mutable_optional_string() {

  _impl_._has_bits_[0] |= 0x00000002u;

  return _impl_.optional_string_.Mutable(GetArenaForAllocation());

}

inline std::string* Misc::release_optional_string() {

  // @@protoc_insertion_point(field_release:proto.Misc.optional_string)

  if (!_internal_has_optional_string()) {

    return nullptr;

  }

  _impl_._has_bits_[0] &= ~0x00000002u;

  auto* p = _impl_.optional_string_.Release();

#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING

  if (_impl_.optional_string_.IsDefault()) {

    _impl_.optional_string_.Set("", GetArenaForAllocation());

  }

#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING

  return p;

}

inline void Misc::set_allocated_optional_string(std::string* optional_string) {

  if (optional_string != nullptr) {

    _impl_._has_bits_[0] |= 0x00000002u;

  } else {

    _impl_._has_bits_[0] &= ~0x00000002u;

  }

  _impl_.optional_string_.SetAllocated(optional_string, GetArenaForAllocation());

#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING

  if (_impl_.optional_string_.IsDefault()) {

    _impl_.optional_string_.Set("", GetArenaForAllocation());

  }

#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING

  // @@protoc_insertion_point(field_set_allocated:proto.Misc.optional_string)

}

// repeated string repeated_string = 9;

inline int Misc::_internal_repeated_string_size() const {

  return _impl_.repeated_string_.size();

}

inline int Misc::repeated_string_size() const {

  return _internal_repeated_string_size();

}

inline void Misc::clear_repeated_string() {

  _impl_.repeated_string_.Clear();

}

inline std::string* Misc::add_repeated_string() {

  std::string* _s = _internal_add_repeated_string();

  // @@protoc_insertion_point(field_add_mutable:proto.Misc.repeated_string)

  return _s;

}

inline const std::string& Misc::_internal_repeated_string(int index) const {

  return _impl_.repeated_string_.Get(index);

}

inline const std::string& Misc::repeated_string(int index) const {

  // @@protoc_insertion_point(field_get:proto.Misc.repeated_string)

  return _internal_repeated_string(index);

}

inline std::string* Misc::mutable_repeated_string(int index) {

  // @@protoc_insertion_point(field_mutable:proto.Misc.repeated_string)

  return _impl_.repeated_string_.Mutable(index);

}

inline void Misc::set_repeated_string(int index, const std::string& value) {

  _impl_.repeated_string_.Mutable(index)->assign(value);

  // @@protoc_insertion_point(field_set:proto.Misc.repeated_string)

}

inline void Misc::set_repeated_string(int index, std::string&& value) {

  _impl_.repeated_string_.Mutable(index)->assign(std::move(value));

  // @@protoc_insertion_point(field_set:proto.Misc.repeated_string)

}

inline void Misc::set_repeated_string(int index, const char* value) {

  GOOGLE_DCHECK(value != nullptr);

  _impl_.repeated_string_.Mutable(index)->assign(value);

  // @@protoc_insertion_point(field_set_char:proto.Misc.repeated_string)

}

inline void Misc::set_repeated_string(int index, const char* value, size_t size) {

  _impl_.repeated_string_.Mutable(index)->assign(

    reinterpret_cast<const char*>(value), size);

  // @@protoc_insertion_point(field_set_pointer:proto.Misc.repeated_string)

}

inline std::string* Misc::_internal_add_repeated_string() {

  return _impl_.repeated_string_.Add();

}

inline void Misc::add_repeated_string(const std::string& value) {

  _impl_.repeated_string_.Add()->assign(value);

  // @@protoc_insertion_point(field_add:proto.Misc.repeated_string)

}

inline void Misc::add_repeated_string(std::string&& value) {

  _impl_.repeated_string_.Add(std::move(value));

  // @@protoc_insertion_point(field_add:proto.Misc.repeated_string)

}

inline void Misc::add_repeated_string(const char* value) {

  GOOGLE_DCHECK(value != nullptr);

  _impl_.repeated_string_.Add()->assign(value);

  // @@protoc_insertion_point(field_add_char:proto.Misc.repeated_string)

}

inline void Misc::add_repeated_string(const char* value, size_t size) {

  _impl_.repeated_string_.Add()->assign(reinterpret_cast<const char*>(value), size);

  // @@protoc_insertion_point(field_add_pointer:proto.Misc.repeated_string)

}

inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&

Misc::repeated_string() const {

  // @@protoc_insertion_point(field_list:proto.Misc.repeated_string)

  return _impl_.repeated_string_;

}

inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*

Misc::mutable_repeated_string() {

  // @@protoc_insertion_point(field_mutable_list:proto.Misc.repeated_string)

  return &_impl_.repeated_string_;

}

// required bool required_bool = 10;

inline bool Misc::_internal_has_required_bool() const {

  bool value = (_impl_._has_bits_[0] & 0x00000040u) != 0;

  return value;

}

inline bool Misc::has_required_bool() const {

  return _internal_has_required_bool();

}

inline void Misc::clear_required_bool() {

  _impl_.required_bool_ = false;

  _impl_._has_bits_[0] &= ~0x00000040u;

}

inline bool Misc::_internal_required_bool() const {

  return _impl_.required_bool_;

}

inline bool Misc::required_bool() const {

  // @@protoc_insertion_point(field_get:proto.Misc.required_bool)

  return _internal_required_bool();

}

inline void Misc::_internal_set_required_bool(bool value) {

  _impl_._has_bits_[0] |= 0x00000040u;

  _impl_.required_bool_ = value;

}

inline void Misc::set_required_bool(bool value) {

  _internal_set_required_bool(value);

  // @@protoc_insertion_point(field_set:proto.Misc.required_bool)

}

// optional bool optional_bool = 11;

inline bool Misc::_internal_has_optional_bool() const {

  bool value = (_impl_._has_bits_[0] & 0x00000080u) != 0;

  return value;

}

inline bool Misc::has_optional_bool() const {

  return _internal_has_optional_bool();

}

inline void Misc::clear_optional_bool() {

  _impl_.optional_bool_ = false;

  _impl_._has_bits_[0] &= ~0x00000080u;

}

inline bool Misc::_internal_optional_bool() const {

  return _impl_.optional_bool_;

}

inline bool Misc::optional_bool() const {

  // @@protoc_insertion_point(field_get:proto.Misc.optional_bool)

  return _internal_optional_bool();

}

inline void Misc::_internal_set_optional_bool(bool value) {

  _impl_._has_bits_[0] |= 0x00000080u;

  _impl_.optional_bool_ = value;

}

inline void Misc::set_optional_bool(bool value) {

  _internal_set_optional_bool(value);

  // @@protoc_insertion_point(field_set:proto.Misc.optional_bool)

}

// repeated bool repeated_bool = 12;

inline int Misc::_internal_repeated_bool_size() const {