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

// source: iobuf.proto

#include "iobuf.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>

#include <google/protobuf/stubs/port.h>

#include <google/protobuf/io/coded_stream.h>

#include <google/protobuf/wire_format_lite_inl.h>

#include <google/protobuf/descriptor.h>

#include <google/protobuf/generated_message_reflection.h>

#include <google/protobuf/reflection_ops.h>

#include <google/protobuf/wire_format.h>

// This is a temporary google only hack

#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS

#include "third_party/protobuf/version.h"

#endif

// @@protoc_insertion_point(includes)

namespace proto {

class MiscDefaultTypeInternal {

 public:

  ::google::protobuf::internal::ExplicitlyConstructed<Misc>

      _instance;

} _Misc_default_instance_;

}  // namespace proto

namespace protobuf_iobuf_2eproto {

static void InitDefaultsMisc() {

  GOOGLE_PROTOBUF_VERIFY_VERSION;

  {

    void* ptr = &::proto::_Misc_default_instance_;

    new (ptr) ::proto::Misc();

    ::google::protobuf::internal::OnShutdownDestroyMessage(ptr);

  }

  ::proto::Misc::InitAsDefaultInstance();

}

::google::protobuf::internal::SCCInfo<0> scc_info_Misc =

    {{ATOMIC_VAR_INIT(::google::protobuf::internal::SCCInfoBase::kUninitialized), 0, InitDefaultsMisc}, {}};

void InitDefaults() {

  ::google::protobuf::internal::InitSCC(&scc_info_Misc.base);

}

::google::protobuf::Metadata file_level_metadata[1];

const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[1];

const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, _has_bits_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, _internal_metadata_),

  ~0u,  // no _extensions_

  ~0u,  // no _oneof_case_

  ~0u,  // no _weak_field_map_

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, required_enum_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, optional_enum_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, repeated_enum_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, required_uint64_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, optional_uint64_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, repeated_uint64_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, required_string_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, optional_string_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, repeated_string_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, required_bool_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, optional_bool_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, repeated_bool_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, required_int32_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, optional_int32_),

  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::proto::Misc, repeated_int32_),

  2,

  3,

  ~0u,

  4,

  5,

  ~0u,

  0,

  1,

  ~0u,

  6,

  7,

  ~0u,

  8,

  9,

  ~0u,

};

static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {

  { 0, 20, sizeof(::proto::Misc)},

};

static ::google::protobuf::Message const * const file_default_instances[] = {

  reinterpret_cast<const ::google::protobuf::Message*>(&::proto::_Misc_default_instance_),

};

void protobuf_AssignDescriptors() {

  AddDescriptors();

  AssignDescriptors(

      "iobuf.proto", schemas, file_default_instances, TableStruct::offsets,

      file_level_metadata, file_level_enum_descriptors, NULL);

}

void protobuf_AssignDescriptorsOnce() {

  static ::google::protobuf::internal::once_flag once;

  ::google::protobuf::internal::call_once(once, protobuf_AssignDescriptors);

}

void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD;

void protobuf_RegisterTypes(const ::std::string&) {

  protobuf_AssignDescriptorsOnce();

  ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 1);

}

void AddDescriptorsImpl() {

  InitDefaults();

  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {

      "\n\013iobuf.proto\022\005proto\"\255\003\n\004Misc\022*\n\rrequire"

      "d_enum\030\001 \002(\0162\023.proto.CompressType\022*\n\ropt"

      "ional_enum\030\002 \001(\0162\023.proto.CompressType\022*\n"

      "\rrepeated_enum\030\003 \003(\0162\023.proto.CompressTyp"

      "e\022\027\n\017required_uint64\030\004 \002(\004\022\027\n\017optional_u"

      "int64\030\005 \001(\004\022\027\n\017repeated_uint64\030\006 \003(\004\022\027\n\017"

      "required_string\030\007 \002(\t\022\027\n\017optional_string"

      "\030\010 \001(\t\022\027\n\017repeated_string\030\t \003(\t\022\025\n\rrequi"

      "red_bool\030\n \002(\010\022\025\n\roptional_bool\030\013 \001(\010\022\025\n"

      "\rrepeated_bool\030\014 \003(\010\022\026\n\016required_int32\030\r"

      " \002(\005\022\026\n\016optional_int32\030\016 \001(\005\022\026\n\016repeated"

      "_int32\030\017 \003(\005*}\n\014CompressType\022\024\n\020Compress"

      "TypeNone\020\000\022\024\n\020CompressTypeGzip\020\001\022\024\n\020Comp"

      "ressTypeZlib\020\002\022\026\n\022CompressTypeSnappy\020\003\022\023"

      "\n\017CompressTypeLZ4\020\004"

  };

  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(

      descriptor, 579);

  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(

    "iobuf.proto", &protobuf_RegisterTypes);

}

void AddDescriptors() {

  static ::google::protobuf::internal::once_flag once;

  ::google::protobuf::internal::call_once(once, AddDescriptorsImpl);

}

// Force AddDescriptors() to be called at dynamic initialization time.

struct StaticDescriptorInitializer {

  StaticDescriptorInitializer() {

    AddDescriptors();

  }

} static_descriptor_initializer;

}  // namespace protobuf_iobuf_2eproto

namespace proto {

const ::google::protobuf::EnumDescriptor* CompressType_descriptor() {

  protobuf_iobuf_2eproto::protobuf_AssignDescriptorsOnce();

  return protobuf_iobuf_2eproto::file_level_enum_descriptors[0];

}

bool CompressType_IsValid(int value) {

  switch (value) {

    case 0:

    case 1:

    case 2:

    case 3:

    case 4:

      return true;

    default:

      return false;

  }

}

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

void Misc::InitAsDefaultInstance() {

}

#if !defined(_MSC_VER) || _MSC_VER >= 1900

const int Misc::kRequiredEnumFieldNumber;

const int Misc::kOptionalEnumFieldNumber;

const int Misc::kRepeatedEnumFieldNumber;

const int Misc::kRequiredUint64FieldNumber;

const int Misc::kOptionalUint64FieldNumber;

const int Misc::kRepeatedUint64FieldNumber;

const int Misc::kRequiredStringFieldNumber;

const int Misc::kOptionalStringFieldNumber;

const int Misc::kRepeatedStringFieldNumber;

const int Misc::kRequiredBoolFieldNumber;

const int Misc::kOptionalBoolFieldNumber;

const int Misc::kRepeatedBoolFieldNumber;

const int Misc::kRequiredInt32FieldNumber;

const int Misc::kOptionalInt32FieldNumber;

const int Misc::kRepeatedInt32FieldNumber;

#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

Misc::Misc()

  : ::google::protobuf::Message(), _internal_metadata_(NULL) {

  ::google::protobuf::internal::InitSCC(

      &protobuf_iobuf_2eproto::scc_info_Misc.base);

  SharedCtor();

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

}

Misc::Misc(const Misc& from)

  : ::google::protobuf::Message(),

      _internal_metadata_(NULL),

      _has_bits_(from._has_bits_),

      repeated_enum_(from.repeated_enum_),

      repeated_uint64_(from.repeated_uint64_),

      repeated_string_(from.repeated_string_),

      repeated_bool_(from.repeated_bool_),

      repeated_int32_(from.repeated_int32_) {

  _internal_metadata_.MergeFrom(from._internal_metadata_);

  required_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());

  if (from.has_required_string()) {

    required_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.required_string_);

  }

  optional_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());

  if (from.has_optional_string()) {

    optional_string_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.optional_string_);

  }

  ::memcpy(&required_enum_, &from.required_enum_,

    static_cast<size_t>(reinterpret_cast<char*>(&optional_int32_) -

    reinterpret_cast<char*>(&required_enum_)) + sizeof(optional_int32_));

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

}

void Misc::SharedCtor() {

  required_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());

  optional_string_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());

  ::memset(&required_enum_, 0, static_cast<size_t>(

      reinterpret_cast<char*>(&optional_int32_) -

      reinterpret_cast<char*>(&required_enum_)) + sizeof(optional_int32_));

}

Misc::~Misc() {

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

  SharedDtor();

}

void Misc::SharedDtor() {

  required_string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());

  optional_string_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());

}

void Misc::SetCachedSize(int size) const {

  _cached_size_.Set(size);

}

const ::google::protobuf::Descriptor* Misc::descriptor() {

  ::protobuf_iobuf_2eproto::protobuf_AssignDescriptorsOnce();

  return ::protobuf_iobuf_2eproto::file_level_metadata[kIndexInFileMessages].descriptor;

}

const Misc& Misc::default_instance() {

  ::google::protobuf::internal::InitSCC(&protobuf_iobuf_2eproto::scc_info_Misc.base);

  return *internal_default_instance();

}

void Misc::Clear() {

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

  ::google::protobuf::uint32 cached_has_bits = 0;

  // Prevent compiler warnings about cached_has_bits being unused

  (void) cached_has_bits;

  repeated_enum_.Clear();

  repeated_uint64_.Clear();

  repeated_string_.Clear();

  repeated_bool_.Clear();

  repeated_int32_.Clear();

  cached_has_bits = _has_bits_[0];

  if (cached_has_bits & 3u) {

    if (cached_has_bits & 0x00000001u) {

      required_string_.ClearNonDefaultToEmptyNoArena();

    }

    if (cached_has_bits & 0x00000002u) {

      optional_string_.ClearNonDefaultToEmptyNoArena();

    }

  }

  if (cached_has_bits & 252u) {

    ::memset(&required_enum_, 0, static_cast<size_t>(

        reinterpret_cast<char*>(&optional_bool_) -

        reinterpret_cast<char*>(&required_enum_)) + sizeof(optional_bool_));

  }

  if (cached_has_bits & 768u) {

    ::memset(&required_int32_, 0, static_cast<size_t>(

        reinterpret_cast<char*>(&optional_int32_) -

        reinterpret_cast<char*>(&required_int32_)) + sizeof(optional_int32_));

  }

  _has_bits_.Clear();

  _internal_metadata_.Clear();

}

bool Misc::MergePartialFromCodedStream(

    ::google::protobuf::io::CodedInputStream* input) {

#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure

  ::google::protobuf::uint32 tag;

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

  for (;;) {

    ::std::pair<::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u);

    tag = p.first;

    if (!p.second) goto handle_unusual;

    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {

      // required .proto.CompressType required_enum = 1;

      case 1: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) {

          int value;

          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<

                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(

                 input, &value)));

          if (::proto::CompressType_IsValid(value)) {

            set_required_enum(static_cast< ::proto::CompressType >(value));

          } else {

            mutable_unknown_fields()->AddVarint(

                1, static_cast< ::google::protobuf::uint64>(value));

          }

        } else {

          goto handle_unusual;

        }

        break;

      }

      // optional .proto.CompressType optional_enum = 2;

      case 2: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) {

          int value;

          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<

                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(

                 input, &value)));

          if (::proto::CompressType_IsValid(value)) {

            set_optional_enum(static_cast< ::proto::CompressType >(value));

          } else {

            mutable_unknown_fields()->AddVarint(

                2, static_cast< ::google::protobuf::uint64>(value));

          }

        } else {

          goto handle_unusual;

        }

        break;

      }

      // repeated .proto.CompressType repeated_enum = 3;

      case 3: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) {

          int value;

          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<

                   int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(

                 input, &value)));

          if (::proto::CompressType_IsValid(value)) {

            add_repeated_enum(static_cast< ::proto::CompressType >(value));

          } else {

            mutable_unknown_fields()->AddVarint(

                3, static_cast< ::google::protobuf::uint64>(value));

          }

        } else if (

            static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) {

          DO_((::google::protobuf::internal::WireFormat::ReadPackedEnumPreserveUnknowns(

                 input,

                 3,

                 ::proto::CompressType_IsValid,

                 mutable_unknown_fields(),

                 this->mutable_repeated_enum())));

        } else {

          goto handle_unusual;

        }

        break;

      }

      // required uint64 required_uint64 = 4;

      case 4: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) {

          set_has_required_uint64();

          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<

                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(

                 input, &required_uint64_)));

        } else {

          goto handle_unusual;

        }

        break;

      }

      // optional uint64 optional_uint64 = 5;

      case 5: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) {

          set_has_optional_uint64();

          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<

                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(

                 input, &optional_uint64_)));

        } else {

          goto handle_unusual;

        }

        break;

      }

      // repeated uint64 repeated_uint64 = 6;

      case 6: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) {

          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<

                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(

                 1, 48u, input, this->mutable_repeated_uint64())));

        } else if (

            static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) {

          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<

                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(

                 input, this->mutable_repeated_uint64())));

        } else {

          goto handle_unusual;

        }

        break;

      }

      // required string required_string = 7;

      case 7: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) {

          DO_(::google::protobuf::internal::WireFormatLite::ReadString(

                input, this->mutable_required_string()));

          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(

            this->required_string().data(), static_cast<int>(this->required_string().length()),

            ::google::protobuf::internal::WireFormat::PARSE,

            "proto.Misc.required_string");

        } else {

          goto handle_unusual;

        }

        break;

      }

      // optional string optional_string = 8;

      case 8: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) {

          DO_(::google::protobuf::internal::WireFormatLite::ReadString(

                input, this->mutable_optional_string()));

          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(

            this->optional_string().data(), static_cast<int>(this->optional_string().length()),

            ::google::protobuf::internal::WireFormat::PARSE,

            "proto.Misc.optional_string");

        } else {

          goto handle_unusual;

        }

        break;

      }

      // repeated string repeated_string = 9;

      case 9: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) {

          DO_(::google::protobuf::internal::WireFormatLite::ReadString(

                input, this->add_repeated_string()));

          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(

            this->repeated_string(this->repeated_string_size() - 1).data(),

            static_cast<int>(this->repeated_string(this->repeated_string_size() - 1).length()),

            ::google::protobuf::internal::WireFormat::PARSE,

            "proto.Misc.repeated_string");

        } else {

          goto handle_unusual;

        }

        break;

      }

      // required bool required_bool = 10;

      case 10: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) {

          set_has_required_bool();

          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<

                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(

                 input, &required_bool_)));

        } else {

          goto handle_unusual;

        }

        break;

      }

      // optional bool optional_bool = 11;

      case 11: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(88u /* 88 & 0xFF */)) {

          set_has_optional_bool();

          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<

                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(

                 input, &optional_bool_)));

        } else {

          goto handle_unusual;

        }

        break;

      }

      // repeated bool repeated_bool = 12;

      case 12: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(96u /* 96 & 0xFF */)) {

          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<

                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(

                 1, 96u, input, this->mutable_repeated_bool())));

        } else if (

            static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(98u /* 98 & 0xFF */)) {

          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<

                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(

                 input, this->mutable_repeated_bool())));

        } else {

          goto handle_unusual;

        }

        break;

      }

      // required int32 required_int32 = 13;

      case 13: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(104u /* 104 & 0xFF */)) {

          set_has_required_int32();

          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<

                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(

                 input, &required_int32_)));

        } else {

          goto handle_unusual;

        }

        break;

      }

      // optional int32 optional_int32 = 14;

      case 14: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(112u /* 112 & 0xFF */)) {

          set_has_optional_int32();

          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<

                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(

                 input, &optional_int32_)));

        } else {

          goto handle_unusual;

        }

        break;

      }

      // repeated int32 repeated_int32 = 15;

      case 15: {

        if (static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(120u /* 120 & 0xFF */)) {

          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<

                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(

                 1, 120u, input, this->mutable_repeated_int32())));

        } else if (

            static_cast< ::google::protobuf::uint8>(tag) ==

            static_cast< ::google::protobuf::uint8>(122u /* 122 & 0xFF */)) {

          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<

                   ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>(

                 input, this->mutable_repeated_int32())));

        } else {

          goto handle_unusual;

        }

        break;

      }

      default: {

      handle_unusual:

        if (tag == 0) {

          goto success;

        }

        DO_(::google::protobuf::internal::WireFormat::SkipField(

              input, tag, _internal_metadata_.mutable_unknown_fields()));

        break;

      }

    }

  }

success:

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

  return true;

failure:

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

  return false;

#undef DO_

}

void Misc::SerializeWithCachedSizes(

    ::google::protobuf::io::CodedOutputStream* output) const {

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

  ::google::protobuf::uint32 cached_has_bits = 0;

  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];

  // required .proto.CompressType required_enum = 1;

  if (cached_has_bits & 0x00000004u) {

    ::google::protobuf::internal::WireFormatLite::WriteEnum(

      1, this->required_enum(), output);

  }

  // optional .proto.CompressType optional_enum = 2;

  if (cached_has_bits & 0x00000008u) {

    ::google::protobuf::internal::WireFormatLite::WriteEnum(

      2, this->optional_enum(), output);

  }

  // repeated .proto.CompressType repeated_enum = 3;

  for (int i = 0, n = this->repeated_enum_size(); i < n; i++) {

    ::google::protobuf::internal::WireFormatLite::WriteEnum(

      3, this->repeated_enum(i), output);

  }

  // required uint64 required_uint64 = 4;

  if (cached_has_bits & 0x00000010u) {

    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->required_uint64(), output);

  }

  // optional uint64 optional_uint64 = 5;

  if (cached_has_bits & 0x00000020u) {

    ::google::protobuf::internal::WireFormatLite::WriteUInt64(5, this->optional_uint64(), output);

  }

  // repeated uint64 repeated_uint64 = 6;

  for (int i = 0, n = this->repeated_uint64_size(); i < n; i++) {

    ::google::protobuf::internal::WireFormatLite::WriteUInt64(

      6, this->repeated_uint64(i), output);

  }

  // required string required_string = 7;

  if (cached_has_bits & 0x00000001u) {

    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(

      this->required_string().data(), static_cast<int>(this->required_string().length()),

      ::google::protobuf::internal::WireFormat::SERIALIZE,

      "proto.Misc.required_string");

    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(

      7, this->required_string(), output);

  }

  // optional string optional_string = 8;

  if (cached_has_bits & 0x00000002u) {

    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(

      this->optional_string().data(), static_cast<int>(this->optional_string().length()),

      ::google::protobuf::internal::WireFormat::SERIALIZE,

      "proto.Misc.optional_string");

    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(

      8, this->optional_string(), output);

  }

  // repeated string repeated_string = 9;

  for (int i = 0, n = this->repeated_string_size(); i < n; i++) {

    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(

      this->repeated_string(i).data(), static_cast<int>(this->repeated_string(i).length()),

      ::google::protobuf::internal::WireFormat::SERIALIZE,

      "proto.Misc.repeated_string");

    ::google::protobuf::internal::WireFormatLite::WriteString(

      9, this->repeated_string(i), output);

  }

  // required bool required_bool = 10;

  if (cached_has_bits & 0x00000040u) {

    ::google::protobuf::internal::WireFormatLite::WriteBool(10, this->required_bool(), output);

  }

  // optional bool optional_bool = 11;

  if (cached_has_bits & 0x00000080u) {

    ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->optional_bool(), output);

  }

  // repeated bool repeated_bool = 12;

  for (int i = 0, n = this->repeated_bool_size(); i < n; i++) {

    ::google::protobuf::internal::WireFormatLite::WriteBool(

      12, this->repeated_bool(i), output);

  }

  // required int32 required_int32 = 13;

  if (cached_has_bits & 0x00000100u) {

    ::google::protobuf::internal::WireFormatLite::WriteInt32(13, this->required_int32(), output);

  }

  // optional int32 optional_int32 = 14;

  if (cached_has_bits & 0x00000200u) {

    ::google::protobuf::internal::WireFormatLite::WriteInt32(14, this->optional_int32(), output);

  }

  // repeated int32 repeated_int32 = 15;

  for (int i = 0, n = this->repeated_int32_size(); i < n; i++) {

    ::google::protobuf::internal::WireFormatLite::WriteInt32(

      15, this->repeated_int32(i), output);

  }

  if (_internal_metadata_.have_unknown_fields()) {

    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(

        _internal_metadata_.unknown_fields(), output);

  }

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

}

::google::protobuf::uint8* Misc::InternalSerializeWithCachedSizesToArray(

    bool deterministic, ::google::protobuf::uint8* target) const {

  (void)deterministic; // Unused

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

  ::google::protobuf::uint32 cached_has_bits = 0;

  (void) cached_has_bits;

  cached_has_bits = _has_bits_[0];

  // required .proto.CompressType required_enum = 1;

  if (cached_has_bits & 0x00000004u) {

    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(

      1, this->required_enum(), target);

  }

  // optional .proto.CompressType optional_enum = 2;

  if (cached_has_bits & 0x00000008u) {

    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(

      2, this->optional_enum(), target);

  }

  // repeated .proto.CompressType repeated_enum = 3;

  target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(

    3, this->repeated_enum_, target);

  // required uint64 required_uint64 = 4;

  if (cached_has_bits & 0x00000010u) {

    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->required_uint64(), target);

  }

  // optional uint64 optional_uint64 = 5;

  if (cached_has_bits & 0x00000020u) {

    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(5, this->optional_uint64(), target);

  }

  // repeated uint64 repeated_uint64 = 6;

  target = ::google::protobuf::internal::WireFormatLite::

    WriteUInt64ToArray(6, this->repeated_uint64_, target);

  // required string required_string = 7;

  if (cached_has_bits & 0x00000001u) {

    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(

      this->required_string().data(), static_cast<int>(this->required_string().length()),

      ::google::protobuf::internal::WireFormat::SERIALIZE,

      "proto.Misc.required_string");

    target =

      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(

        7, this->required_string(), target);

  }

  // optional string optional_string = 8;

  if (cached_has_bits & 0x00000002u) {

    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(

      this->optional_string().data(), static_cast<int>(this->optional_string().length()),

      ::google::protobuf::internal::WireFormat::SERIALIZE,

      "proto.Misc.optional_string");

    target =

      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(

        8, this->optional_string(), target);

  }

  // repeated string repeated_string = 9;

  for (int i = 0, n = this->repeated_string_size(); i < n; i++) {

    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(

      this->repeated_string(i).data(), static_cast<int>(this->repeated_string(i).length()),

      ::google::protobuf::internal::WireFormat::SERIALIZE,

      "proto.Misc.repeated_string");

    target = ::google::protobuf::internal::WireFormatLite::

      WriteStringToArray(9, this->repeated_string(i), target);

  }

  // required bool required_bool = 10;

  if (cached_has_bits & 0x00000040u) {

    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(10, this->required_bool(), target);

  }

  // optional bool optional_bool = 11;

  if (cached_has_bits & 0x00000080u) {

    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->optional_bool(), target);

  }

  // repeated bool repeated_bool = 12;

  target = ::google::protobuf::internal::WireFormatLite::

    WriteBoolToArray(12, this->repeated_bool_, target);

  // required int32 required_int32 = 13;

  if (cached_has_bits & 0x00000100u) {

    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(13, this->required_int32(), target);

  }

  // optional int32 optional_int32 = 14;

  if (cached_has_bits & 0x00000200u) {

    target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(14, this->optional_int32(), target);

  }

  // repeated int32 repeated_int32 = 15;

  target = ::google::protobuf::internal::WireFormatLite::

    WriteInt32ToArray(15, this->repeated_int32_, target);

  if (_internal_metadata_.have_unknown_fields()) {

    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(

        _internal_metadata_.unknown_fields(), target);

  }

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

  return target;

}

size_t Misc::RequiredFieldsByteSizeFallback() const {

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

  size_t total_size = 0;

  if (has_required_string()) {

    // required string required_string = 7;

    total_size += 1 +

      ::google::protobuf::internal::WireFormatLite::StringSize(

        this->required_string());

  }

  if (has_required_enum()) {

    // required .proto.CompressType required_enum = 1;

    total_size += 1 +

      ::google::protobuf::internal::WireFormatLite::EnumSize(this->required_enum());

  }

  if (has_required_uint64()) {

    // required uint64 required_uint64 = 4;

    total_size += 1 +

      ::google::protobuf::internal::WireFormatLite::UInt64Size(

        this->required_uint64());

  }

  if (has_required_bool()) {

    // required bool required_bool = 10;

    total_size += 1 + 1;

  }

  if (has_required_int32()) {

    // required int32 required_int32 = 13;

    total_size += 1 +

      ::google::protobuf::internal::WireFormatLite::Int32Size(

        this->required_int32());

  }

  return total_size;

}

size_t Misc::ByteSizeLong() const {

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

  size_t total_size = 0;

  if (_internal_metadata_.have_unknown_fields()) {

    total_size +=

      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(

        _internal_metadata_.unknown_fields());

  }

  if (((_has_bits_[0] & 0x00000155) ^ 0x00000155) == 0) {  // All required fields are present.

    // required string required_string = 7;

    total_size += 1 +

      ::google::protobuf::internal::WireFormatLite::StringSize(

        this->required_string());

    // required .proto.CompressType required_enum = 1;

    total_size += 1 +

      ::google::protobuf::internal::WireFormatLite::EnumSize(this->required_enum());

    // required uint64 required_uint64 = 4;

    total_size += 1 +

      ::google::protobuf::internal::WireFormatLite::UInt64Size(

        this->required_uint64());

    // required bool required_bool = 10;

    total_size += 1 + 1;

    // required int32 required_int32 = 13;

    total_size += 1 +

      ::google::protobuf::internal::WireFormatLite::Int32Size(

        this->required_int32());

  } else {

    total_size += RequiredFieldsByteSizeFallback();

  }

  // repeated .proto.CompressType repeated_enum = 3;

  {

    size_t data_size = 0;

    unsigned int count = static_cast<unsigned int>(this->repeated_enum_size());for (unsigned int i = 0; i < count; i++) {

      data_size += ::google::protobuf::internal::WireFormatLite::EnumSize(

        this->repeated_enum(static_cast<int>(i)));

    }

    total_size += (1UL * count) + data_size;

  }

  // repeated uint64 repeated_uint64 = 6;

  {

    size_t data_size = ::google::protobuf::internal::WireFormatLite::

      UInt64Size(this->repeated_uint64_);

    total_size += 1 *

                  ::google::protobuf::internal::FromIntSize(this->repeated_uint64_size());

    total_size += data_size;

  }

  // repeated string repeated_string = 9;

  total_size += 1 *

      ::google::protobuf::internal::FromIntSize(this->repeated_string_size());

  for (int i = 0, n = this->repeated_string_size(); i < n; i++) {

    total_size += ::google::protobuf::internal::WireFormatLite::StringSize(

      this->repeated_string(i));

  }

  // repeated bool repeated_bool = 12;

  {

    unsigned int count = static_cast<unsigned int>(this->repeated_bool_size());

    size_t data_size = 1UL * count;

    total_size += 1 *

                  ::google::protobuf::internal::FromIntSize(this->repeated_bool_size());

    total_size += data_size;

  }

  // repeated int32 repeated_int32 = 15;