// Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

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

#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
#include "cube.pb.h"

#include <algorithm>

#include <google/protobuf/stubs/common.h>
#include <google/protobuf/stubs/port.h>
#include <google/protobuf/stubs/once.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>
// @@protoc_insertion_point(includes)

namespace rec {
namespace mcube {

namespace {

const ::google::protobuf::Descriptor* DictRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DictRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* DictValue_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DictValue_reflection_ = NULL;
const ::google::protobuf::Descriptor* DictResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  DictResponse_reflection_ = NULL;
const ::google::protobuf::Descriptor* ParallelDictRequest_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ParallelDictRequest_reflection_ = NULL;
const ::google::protobuf::Descriptor* ParallelDictResponse_descriptor_ = NULL;
const ::google::protobuf::internal::GeneratedMessageReflection*
  ParallelDictResponse_reflection_ = NULL;
const ::google::protobuf::ServiceDescriptor* DictService_descriptor_ = NULL;

}  // namespace


void protobuf_AssignDesc_cube_2eproto() GOOGLE_ATTRIBUTE_COLD;
void protobuf_AssignDesc_cube_2eproto() {
  protobuf_AddDesc_cube_2eproto();
  const ::google::protobuf::FileDescriptor* file =
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
      "cube.proto");
  GOOGLE_CHECK(file != NULL);
  DictRequest_descriptor_ = file->message_type(0);
  static const int DictRequest_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictRequest, keys_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictRequest, version_required_),
  };
  DictRequest_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      DictRequest_descriptor_,
      DictRequest::internal_default_instance(),
      DictRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictRequest, _has_bits_),
      -1,
      -1,
      sizeof(DictRequest),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictRequest, _internal_metadata_));
  DictValue_descriptor_ = file->message_type(1);
  static const int DictValue_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictValue, status_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictValue, value_),
  };
  DictValue_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      DictValue_descriptor_,
      DictValue::internal_default_instance(),
      DictValue_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictValue, _has_bits_),
      -1,
      -1,
      sizeof(DictValue),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictValue, _internal_metadata_));
  DictResponse_descriptor_ = file->message_type(2);
  static const int DictResponse_offsets_[2] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictResponse, values_),
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictResponse, version_),
  };
  DictResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      DictResponse_descriptor_,
      DictResponse::internal_default_instance(),
      DictResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictResponse, _has_bits_),
      -1,
      -1,
      sizeof(DictResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DictResponse, _internal_metadata_));
  ParallelDictRequest_descriptor_ = file->message_type(3);
  static const int ParallelDictRequest_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParallelDictRequest, requests_),
  };
  ParallelDictRequest_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      ParallelDictRequest_descriptor_,
      ParallelDictRequest::internal_default_instance(),
      ParallelDictRequest_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParallelDictRequest, _has_bits_),
      -1,
      -1,
      sizeof(ParallelDictRequest),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParallelDictRequest, _internal_metadata_));
  ParallelDictResponse_descriptor_ = file->message_type(4);
  static const int ParallelDictResponse_offsets_[1] = {
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParallelDictResponse, responses_),
  };
  ParallelDictResponse_reflection_ =
    ::google::protobuf::internal::GeneratedMessageReflection::NewGeneratedMessageReflection(
      ParallelDictResponse_descriptor_,
      ParallelDictResponse::internal_default_instance(),
      ParallelDictResponse_offsets_,
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParallelDictResponse, _has_bits_),
      -1,
      -1,
      sizeof(ParallelDictResponse),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ParallelDictResponse, _internal_metadata_));
  DictService_descriptor_ = file->service(0);
}

namespace {

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
void protobuf_AssignDescriptorsOnce() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                 &protobuf_AssignDesc_cube_2eproto);
}

void protobuf_RegisterTypes(const ::std::string&) GOOGLE_ATTRIBUTE_COLD;
void protobuf_RegisterTypes(const ::std::string&) {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      DictRequest_descriptor_, DictRequest::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      DictValue_descriptor_, DictValue::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      DictResponse_descriptor_, DictResponse::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ParallelDictRequest_descriptor_, ParallelDictRequest::internal_default_instance());
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ParallelDictResponse_descriptor_, ParallelDictResponse::internal_default_instance());
}

}  // namespace

void protobuf_ShutdownFile_cube_2eproto() {
  DictRequest_default_instance_.Shutdown();
  delete DictRequest_reflection_;
  DictValue_default_instance_.Shutdown();
  delete DictValue_reflection_;
  DictResponse_default_instance_.Shutdown();
  delete DictResponse_reflection_;
  ParallelDictRequest_default_instance_.Shutdown();
  delete ParallelDictRequest_reflection_;
  ParallelDictResponse_default_instance_.Shutdown();
  delete ParallelDictResponse_reflection_;
}

void protobuf_InitDefaults_cube_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  DictRequest_default_instance_.DefaultConstruct();
  ::google::protobuf::internal::GetEmptyString();
  DictValue_default_instance_.DefaultConstruct();
  ::google::protobuf::internal::GetEmptyString();
  DictResponse_default_instance_.DefaultConstruct();
  ParallelDictRequest_default_instance_.DefaultConstruct();
  ParallelDictResponse_default_instance_.DefaultConstruct();
  DictRequest_default_instance_.get_mutable()->InitAsDefaultInstance();
  DictValue_default_instance_.get_mutable()->InitAsDefaultInstance();
  DictResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
  ParallelDictRequest_default_instance_.get_mutable()->InitAsDefaultInstance();
  ParallelDictResponse_default_instance_.get_mutable()->InitAsDefaultInstance();
}

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_InitDefaults_cube_2eproto_once_);
void protobuf_InitDefaults_cube_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_InitDefaults_cube_2eproto_once_,
                 &protobuf_InitDefaults_cube_2eproto_impl);
}
void protobuf_AddDesc_cube_2eproto_impl() {
  GOOGLE_PROTOBUF_VERIFY_VERSION;

  protobuf_InitDefaults_cube_2eproto();
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
    "\n\ncube.proto\022\trec.mcube\"<\n\013DictRequest\022\014"
    "\n\004keys\030\001 \003(\004\022\037\n\020version_required\030\002 \001(\010:\005"
    "false\"*\n\tDictValue\022\016\n\006status\030\001 \002(\r\022\r\n\005va"
    "lue\030\002 \002(\014\"E\n\014DictResponse\022$\n\006values\030\001 \003("
    "\0132\024.rec.mcube.DictValue\022\017\n\007version\030\002 \001(\t"
    "\"\?\n\023ParallelDictRequest\022(\n\010requests\030\002 \003("
    "\0132\026.rec.mcube.DictRequest\"B\n\024ParallelDic"
    "tResponse\022*\n\tresponses\030\001 \003(\0132\027.rec.mcube"
    ".DictResponse2\230\001\n\013DictService\0227\n\004seek\022\026."
    "rec.mcube.DictRequest\032\027.rec.mcube.DictRe"
    "sponse\022P\n\rparallel_seek\022\036.rec.mcube.Para"
    "llelDictRequest\032\037.rec.mcube.ParallelDict"
    "ResponseB\003\200\001\001", 493);
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "cube.proto", &protobuf_RegisterTypes);
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_cube_2eproto);
}

GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AddDesc_cube_2eproto_once_);
void protobuf_AddDesc_cube_2eproto() {
  ::google::protobuf::GoogleOnceInit(&protobuf_AddDesc_cube_2eproto_once_,
                 &protobuf_AddDesc_cube_2eproto_impl);
}
// Force AddDescriptors() to be called at static initialization time.
struct StaticDescriptorInitializer_cube_2eproto {
  StaticDescriptorInitializer_cube_2eproto() {
    protobuf_AddDesc_cube_2eproto();
  }
} static_descriptor_initializer_cube_2eproto_;

namespace {

static void MergeFromFail(int line) GOOGLE_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_NORETURN;
static void MergeFromFail(int line) {
  ::google::protobuf::internal::MergeFromFail(__FILE__, line);
}

}  // namespace


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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DictRequest::kKeysFieldNumber;
const int DictRequest::kVersionRequiredFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DictRequest::DictRequest()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_cube_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:rec.mcube.DictRequest)
}

void DictRequest::InitAsDefaultInstance() {
}

DictRequest::DictRequest(const DictRequest& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:rec.mcube.DictRequest)
}

void DictRequest::SharedCtor() {
  _cached_size_ = 0;
  version_required_ = false;
}

DictRequest::~DictRequest() {
  // @@protoc_insertion_point(destructor:rec.mcube.DictRequest)
  SharedDtor();
}

void DictRequest::SharedDtor() {
}

void DictRequest::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DictRequest::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DictRequest_descriptor_;
}

const DictRequest& DictRequest::default_instance() {
  protobuf_InitDefaults_cube_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<DictRequest> DictRequest_default_instance_;

DictRequest* DictRequest::New(::google::protobuf::Arena* arena) const {
  DictRequest* n = new DictRequest;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DictRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:rec.mcube.DictRequest)
  version_required_ = false;
  keys_.Clear();
  _has_bits_.Clear();
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool DictRequest::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:rec.mcube.DictRequest)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated uint64 keys = 1;
      case 1: {
        if (tag == 8) {
         parse_keys:
          DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 1, 8, input, this->mutable_keys())));
        } else if (tag == 10) {
          DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
                   ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
                 input, this->mutable_keys())));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(8)) goto parse_keys;
        if (input->ExpectTag(16)) goto parse_version_required;
        break;
      }

      // optional bool version_required = 2 [default = false];
      case 2: {
        if (tag == 16) {
         parse_version_required:
          set_has_version_required();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
                 input, &version_required_)));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:rec.mcube.DictRequest)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:rec.mcube.DictRequest)
  return false;
#undef DO_
}

void DictRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:rec.mcube.DictRequest)
  // repeated uint64 keys = 1;
  for (int i = 0; i < this->keys_size(); i++) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(
      1, this->keys(i), output);
  }

  // optional bool version_required = 2 [default = false];
  if (has_version_required()) {
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->version_required(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:rec.mcube.DictRequest)
}

::google::protobuf::uint8* DictRequest::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:rec.mcube.DictRequest)
  // repeated uint64 keys = 1;
  for (int i = 0; i < this->keys_size(); i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      WriteUInt64ToArray(1, this->keys(i), target);
  }

  // optional bool version_required = 2 [default = false];
  if (has_version_required()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->version_required(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:rec.mcube.DictRequest)
  return target;
}

size_t DictRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:rec.mcube.DictRequest)
  size_t total_size = 0;

  // optional bool version_required = 2 [default = false];
  if (has_version_required()) {
    total_size += 1 + 1;
  }

  // repeated uint64 keys = 1;
  {
    size_t data_size = 0;
    unsigned int count = this->keys_size();
    for (unsigned int i = 0; i < count; i++) {
      data_size += ::google::protobuf::internal::WireFormatLite::
        UInt64Size(this->keys(i));
    }
    total_size += 1 *
                  ::google::protobuf::internal::FromIntSize(this->keys_size());
    total_size += data_size;
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DictRequest::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:rec.mcube.DictRequest)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const DictRequest* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DictRequest>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:rec.mcube.DictRequest)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:rec.mcube.DictRequest)
    UnsafeMergeFrom(*source);
  }
}

void DictRequest::MergeFrom(const DictRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:rec.mcube.DictRequest)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void DictRequest::UnsafeMergeFrom(const DictRequest& from) {
  GOOGLE_DCHECK(&from != this);
  keys_.UnsafeMergeFrom(from.keys_);
  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    if (from.has_version_required()) {
      set_version_required(from.version_required());
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata(
      from.unknown_fields(), &_internal_metadata_);
  }
}

void DictRequest::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:rec.mcube.DictRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DictRequest::CopyFrom(const DictRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:rec.mcube.DictRequest)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool DictRequest::IsInitialized() const {

  return true;
}

void DictRequest::Swap(DictRequest* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DictRequest::InternalSwap(DictRequest* other) {
  keys_.UnsafeArenaSwap(&other->keys_);
  std::swap(version_required_, other->version_required_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata DictRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DictRequest_descriptor_;
  metadata.reflection = DictRequest_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DictRequest

// repeated uint64 keys = 1;
int DictRequest::keys_size() const {
  return keys_.size();
}
void DictRequest::clear_keys() {
  keys_.Clear();
}
::google::protobuf::uint64 DictRequest::keys(int index) const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictRequest.keys)
  return keys_.Get(index);
}
void DictRequest::set_keys(int index, ::google::protobuf::uint64 value) {
  keys_.Set(index, value);
  // @@protoc_insertion_point(field_set:rec.mcube.DictRequest.keys)
}
void DictRequest::add_keys(::google::protobuf::uint64 value) {
  keys_.Add(value);
  // @@protoc_insertion_point(field_add:rec.mcube.DictRequest.keys)
}
const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
DictRequest::keys() const {
  // @@protoc_insertion_point(field_list:rec.mcube.DictRequest.keys)
  return keys_;
}
::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
DictRequest::mutable_keys() {
  // @@protoc_insertion_point(field_mutable_list:rec.mcube.DictRequest.keys)
  return &keys_;
}

// optional bool version_required = 2 [default = false];
bool DictRequest::has_version_required() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DictRequest::set_has_version_required() {
  _has_bits_[0] |= 0x00000002u;
}
void DictRequest::clear_has_version_required() {
  _has_bits_[0] &= ~0x00000002u;
}
void DictRequest::clear_version_required() {
  version_required_ = false;
  clear_has_version_required();
}
bool DictRequest::version_required() const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictRequest.version_required)
  return version_required_;
}
void DictRequest::set_version_required(bool value) {
  set_has_version_required();
  version_required_ = value;
  // @@protoc_insertion_point(field_set:rec.mcube.DictRequest.version_required)
}

inline const DictRequest* DictRequest::internal_default_instance() {
  return &DictRequest_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DictValue::kStatusFieldNumber;
const int DictValue::kValueFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DictValue::DictValue()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_cube_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:rec.mcube.DictValue)
}

void DictValue::InitAsDefaultInstance() {
}

DictValue::DictValue(const DictValue& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:rec.mcube.DictValue)
}

void DictValue::SharedCtor() {
  _cached_size_ = 0;
  value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  status_ = 0u;
}

DictValue::~DictValue() {
  // @@protoc_insertion_point(destructor:rec.mcube.DictValue)
  SharedDtor();
}

void DictValue::SharedDtor() {
  value_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void DictValue::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DictValue::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DictValue_descriptor_;
}

const DictValue& DictValue::default_instance() {
  protobuf_InitDefaults_cube_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<DictValue> DictValue_default_instance_;

DictValue* DictValue::New(::google::protobuf::Arena* arena) const {
  DictValue* n = new DictValue;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DictValue::Clear() {
// @@protoc_insertion_point(message_clear_start:rec.mcube.DictValue)
  if (_has_bits_[0 / 32] & 3u) {
    status_ = 0u;
    if (has_value()) {
      value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    }
  }
  _has_bits_.Clear();
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool DictValue::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:rec.mcube.DictValue)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // required uint32 status = 1;
      case 1: {
        if (tag == 8) {
          set_has_status();
          DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
                   ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
                 input, &status_)));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_value;
        break;
      }

      // required bytes value = 2;
      case 2: {
        if (tag == 18) {
         parse_value:
          DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
                input, this->mutable_value()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:rec.mcube.DictValue)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:rec.mcube.DictValue)
  return false;
#undef DO_
}

void DictValue::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:rec.mcube.DictValue)
  // required uint32 status = 1;
  if (has_status()) {
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->status(), output);
  }

  // required bytes value = 2;
  if (has_value()) {
    ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased(
      2, this->value(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:rec.mcube.DictValue)
}

::google::protobuf::uint8* DictValue::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:rec.mcube.DictValue)
  // required uint32 status = 1;
  if (has_status()) {
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->status(), target);
  }

  // required bytes value = 2;
  if (has_value()) {
    target =
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
        2, this->value(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:rec.mcube.DictValue)
  return target;
}

size_t DictValue::RequiredFieldsByteSizeFallback() const {
// @@protoc_insertion_point(required_fields_byte_size_fallback_start:rec.mcube.DictValue)
  size_t total_size = 0;

  if (has_status()) {
    // required uint32 status = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->status());
  }

  if (has_value()) {
    // required bytes value = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->value());
  }

  return total_size;
}
size_t DictValue::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:rec.mcube.DictValue)
  size_t total_size = 0;

  if (((_has_bits_[0] & 0x00000003) ^ 0x00000003) == 0) {  // All required fields are present.
    // required uint32 status = 1;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::UInt32Size(
        this->status());

    // required bytes value = 2;
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::BytesSize(
        this->value());

  } else {
    total_size += RequiredFieldsByteSizeFallback();
  }
  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DictValue::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:rec.mcube.DictValue)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const DictValue* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DictValue>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:rec.mcube.DictValue)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:rec.mcube.DictValue)
    UnsafeMergeFrom(*source);
  }
}

void DictValue::MergeFrom(const DictValue& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:rec.mcube.DictValue)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void DictValue::UnsafeMergeFrom(const DictValue& from) {
  GOOGLE_DCHECK(&from != this);
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
    if (from.has_status()) {
      set_status(from.status());
    }
    if (from.has_value()) {
      set_has_value();
      value_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.value_);
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata(
      from.unknown_fields(), &_internal_metadata_);
  }
}

void DictValue::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:rec.mcube.DictValue)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DictValue::CopyFrom(const DictValue& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:rec.mcube.DictValue)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool DictValue::IsInitialized() const {
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;

  return true;
}

void DictValue::Swap(DictValue* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DictValue::InternalSwap(DictValue* other) {
  std::swap(status_, other->status_);
  value_.Swap(&other->value_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata DictValue::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DictValue_descriptor_;
  metadata.reflection = DictValue_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DictValue

// required uint32 status = 1;
bool DictValue::has_status() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
void DictValue::set_has_status() {
  _has_bits_[0] |= 0x00000001u;
}
void DictValue::clear_has_status() {
  _has_bits_[0] &= ~0x00000001u;
}
void DictValue::clear_status() {
  status_ = 0u;
  clear_has_status();
}
::google::protobuf::uint32 DictValue::status() const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictValue.status)
  return status_;
}
void DictValue::set_status(::google::protobuf::uint32 value) {
  set_has_status();
  status_ = value;
  // @@protoc_insertion_point(field_set:rec.mcube.DictValue.status)
}

// required bytes value = 2;
bool DictValue::has_value() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DictValue::set_has_value() {
  _has_bits_[0] |= 0x00000002u;
}
void DictValue::clear_has_value() {
  _has_bits_[0] &= ~0x00000002u;
}
void DictValue::clear_value() {
  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_value();
}
const ::std::string& DictValue::value() const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictValue.value)
  return value_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DictValue::set_value(const ::std::string& value) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rec.mcube.DictValue.value)
}
void DictValue::set_value(const char* value) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rec.mcube.DictValue.value)
}
void DictValue::set_value(const void* value, size_t size) {
  set_has_value();
  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rec.mcube.DictValue.value)
}
::std::string* DictValue::mutable_value() {
  set_has_value();
  // @@protoc_insertion_point(field_mutable:rec.mcube.DictValue.value)
  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DictValue::release_value() {
  // @@protoc_insertion_point(field_release:rec.mcube.DictValue.value)
  clear_has_value();
  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DictValue::set_allocated_value(::std::string* value) {
  if (value != NULL) {
    set_has_value();
  } else {
    clear_has_value();
  }
  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set_allocated:rec.mcube.DictValue.value)
}

inline const DictValue* DictValue::internal_default_instance() {
  return &DictValue_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int DictResponse::kValuesFieldNumber;
const int DictResponse::kVersionFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

DictResponse::DictResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_cube_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:rec.mcube.DictResponse)
}

void DictResponse::InitAsDefaultInstance() {
}

DictResponse::DictResponse(const DictResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:rec.mcube.DictResponse)
}

void DictResponse::SharedCtor() {
  _cached_size_ = 0;
  version_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

DictResponse::~DictResponse() {
  // @@protoc_insertion_point(destructor:rec.mcube.DictResponse)
  SharedDtor();
}

void DictResponse::SharedDtor() {
  version_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}

void DictResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* DictResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DictResponse_descriptor_;
}

const DictResponse& DictResponse::default_instance() {
  protobuf_InitDefaults_cube_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<DictResponse> DictResponse_default_instance_;

DictResponse* DictResponse::New(::google::protobuf::Arena* arena) const {
  DictResponse* n = new DictResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void DictResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:rec.mcube.DictResponse)
  if (has_version()) {
    version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  values_.Clear();
  _has_bits_.Clear();
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool DictResponse::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:rec.mcube.DictResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .rec.mcube.DictValue values = 1;
      case 1: {
        if (tag == 10) {
          DO_(input->IncrementRecursionDepth());
         parse_loop_values:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth(
                input, add_values()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_loop_values;
        input->UnsafeDecrementRecursionDepth();
        if (input->ExpectTag(18)) goto parse_version;
        break;
      }

      // optional string version = 2;
      case 2: {
        if (tag == 18) {
         parse_version:
          DO_(::google::protobuf::internal::WireFormatLite::ReadString(
                input, this->mutable_version()));
          ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
            this->version().data(), this->version().length(),
            ::google::protobuf::internal::WireFormat::PARSE,
            "rec.mcube.DictResponse.version");
        } else {
          goto handle_unusual;
        }
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:rec.mcube.DictResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:rec.mcube.DictResponse)
  return false;
#undef DO_
}

void DictResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:rec.mcube.DictResponse)
  // repeated .rec.mcube.DictValue values = 1;
  for (unsigned int i = 0, n = this->values_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->values(i), output);
  }

  // optional string version = 2;
  if (has_version()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->version().data(), this->version().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "rec.mcube.DictResponse.version");
    ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased(
      2, this->version(), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:rec.mcube.DictResponse)
}

::google::protobuf::uint8* DictResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:rec.mcube.DictResponse)
  // repeated .rec.mcube.DictValue values = 1;
  for (unsigned int i = 0, n = this->values_size(); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageNoVirtualToArray(
        1, this->values(i), false, target);
  }

  // optional string version = 2;
  if (has_version()) {
    ::google::protobuf::internal::WireFormat::VerifyUTF8StringNamedField(
      this->version().data(), this->version().length(),
      ::google::protobuf::internal::WireFormat::SERIALIZE,
      "rec.mcube.DictResponse.version");
    target =
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
        2, this->version(), target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:rec.mcube.DictResponse)
  return target;
}

size_t DictResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:rec.mcube.DictResponse)
  size_t total_size = 0;

  // optional string version = 2;
  if (has_version()) {
    total_size += 1 +
      ::google::protobuf::internal::WireFormatLite::StringSize(
        this->version());
  }

  // repeated .rec.mcube.DictValue values = 1;
  {
    unsigned int count = this->values_size();
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->values(i));
    }
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void DictResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:rec.mcube.DictResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const DictResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const DictResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:rec.mcube.DictResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:rec.mcube.DictResponse)
    UnsafeMergeFrom(*source);
  }
}

void DictResponse::MergeFrom(const DictResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:rec.mcube.DictResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void DictResponse::UnsafeMergeFrom(const DictResponse& from) {
  GOOGLE_DCHECK(&from != this);
  values_.MergeFrom(from.values_);
  if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
    if (from.has_version()) {
      set_has_version();
      version_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.version_);
    }
  }
  if (from._internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata(
      from.unknown_fields(), &_internal_metadata_);
  }
}

void DictResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:rec.mcube.DictResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void DictResponse::CopyFrom(const DictResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:rec.mcube.DictResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool DictResponse::IsInitialized() const {

  if (!::google::protobuf::internal::AllAreInitialized(this->values())) return false;
  return true;
}

void DictResponse::Swap(DictResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void DictResponse::InternalSwap(DictResponse* other) {
  values_.UnsafeArenaSwap(&other->values_);
  version_.Swap(&other->version_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata DictResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = DictResponse_descriptor_;
  metadata.reflection = DictResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// DictResponse

// repeated .rec.mcube.DictValue values = 1;
int DictResponse::values_size() const {
  return values_.size();
}
void DictResponse::clear_values() {
  values_.Clear();
}
const ::rec::mcube::DictValue& DictResponse::values(int index) const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictResponse.values)
  return values_.Get(index);
}
::rec::mcube::DictValue* DictResponse::mutable_values(int index) {
  // @@protoc_insertion_point(field_mutable:rec.mcube.DictResponse.values)
  return values_.Mutable(index);
}
::rec::mcube::DictValue* DictResponse::add_values() {
  // @@protoc_insertion_point(field_add:rec.mcube.DictResponse.values)
  return values_.Add();
}
::google::protobuf::RepeatedPtrField< ::rec::mcube::DictValue >*
DictResponse::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:rec.mcube.DictResponse.values)
  return &values_;
}
const ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictValue >&
DictResponse::values() const {
  // @@protoc_insertion_point(field_list:rec.mcube.DictResponse.values)
  return values_;
}

// optional string version = 2;
bool DictResponse::has_version() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
void DictResponse::set_has_version() {
  _has_bits_[0] |= 0x00000002u;
}
void DictResponse::clear_has_version() {
  _has_bits_[0] &= ~0x00000002u;
}
void DictResponse::clear_version() {
  version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  clear_has_version();
}
const ::std::string& DictResponse::version() const {
  // @@protoc_insertion_point(field_get:rec.mcube.DictResponse.version)
  return version_.GetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DictResponse::set_version(const ::std::string& value) {
  set_has_version();
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:rec.mcube.DictResponse.version)
}
void DictResponse::set_version(const char* value) {
  set_has_version();
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:rec.mcube.DictResponse.version)
}
void DictResponse::set_version(const char* value, size_t size) {
  set_has_version();
  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:rec.mcube.DictResponse.version)
}
::std::string* DictResponse::mutable_version() {
  set_has_version();
  // @@protoc_insertion_point(field_mutable:rec.mcube.DictResponse.version)
  return version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
::std::string* DictResponse::release_version() {
  // @@protoc_insertion_point(field_release:rec.mcube.DictResponse.version)
  clear_has_version();
  return version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
void DictResponse::set_allocated_version(::std::string* version) {
  if (version != NULL) {
    set_has_version();
  } else {
    clear_has_version();
  }
  version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), version);
  // @@protoc_insertion_point(field_set_allocated:rec.mcube.DictResponse.version)
}

inline const DictResponse* DictResponse::internal_default_instance() {
  return &DictResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ParallelDictRequest::kRequestsFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ParallelDictRequest::ParallelDictRequest()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_cube_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:rec.mcube.ParallelDictRequest)
}

void ParallelDictRequest::InitAsDefaultInstance() {
}

ParallelDictRequest::ParallelDictRequest(const ParallelDictRequest& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:rec.mcube.ParallelDictRequest)
}

void ParallelDictRequest::SharedCtor() {
  _cached_size_ = 0;
}

ParallelDictRequest::~ParallelDictRequest() {
  // @@protoc_insertion_point(destructor:rec.mcube.ParallelDictRequest)
  SharedDtor();
}

void ParallelDictRequest::SharedDtor() {
}

void ParallelDictRequest::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ParallelDictRequest::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ParallelDictRequest_descriptor_;
}

const ParallelDictRequest& ParallelDictRequest::default_instance() {
  protobuf_InitDefaults_cube_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<ParallelDictRequest> ParallelDictRequest_default_instance_;

ParallelDictRequest* ParallelDictRequest::New(::google::protobuf::Arena* arena) const {
  ParallelDictRequest* n = new ParallelDictRequest;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ParallelDictRequest::Clear() {
// @@protoc_insertion_point(message_clear_start:rec.mcube.ParallelDictRequest)
  requests_.Clear();
  _has_bits_.Clear();
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool ParallelDictRequest::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:rec.mcube.ParallelDictRequest)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .rec.mcube.DictRequest requests = 2;
      case 2: {
        if (tag == 18) {
          DO_(input->IncrementRecursionDepth());
         parse_loop_requests:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth(
                input, add_requests()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(18)) goto parse_loop_requests;
        input->UnsafeDecrementRecursionDepth();
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:rec.mcube.ParallelDictRequest)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:rec.mcube.ParallelDictRequest)
  return false;
#undef DO_
}

void ParallelDictRequest::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:rec.mcube.ParallelDictRequest)
  // repeated .rec.mcube.DictRequest requests = 2;
  for (unsigned int i = 0, n = this->requests_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      2, this->requests(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:rec.mcube.ParallelDictRequest)
}

::google::protobuf::uint8* ParallelDictRequest::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:rec.mcube.ParallelDictRequest)
  // repeated .rec.mcube.DictRequest requests = 2;
  for (unsigned int i = 0, n = this->requests_size(); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageNoVirtualToArray(
        2, this->requests(i), false, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:rec.mcube.ParallelDictRequest)
  return target;
}

size_t ParallelDictRequest::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:rec.mcube.ParallelDictRequest)
  size_t total_size = 0;

  // repeated .rec.mcube.DictRequest requests = 2;
  {
    unsigned int count = this->requests_size();
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->requests(i));
    }
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ParallelDictRequest::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:rec.mcube.ParallelDictRequest)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const ParallelDictRequest* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ParallelDictRequest>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:rec.mcube.ParallelDictRequest)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:rec.mcube.ParallelDictRequest)
    UnsafeMergeFrom(*source);
  }
}

void ParallelDictRequest::MergeFrom(const ParallelDictRequest& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:rec.mcube.ParallelDictRequest)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void ParallelDictRequest::UnsafeMergeFrom(const ParallelDictRequest& from) {
  GOOGLE_DCHECK(&from != this);
  requests_.MergeFrom(from.requests_);
  if (from._internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata(
      from.unknown_fields(), &_internal_metadata_);
  }
}

void ParallelDictRequest::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:rec.mcube.ParallelDictRequest)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ParallelDictRequest::CopyFrom(const ParallelDictRequest& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:rec.mcube.ParallelDictRequest)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool ParallelDictRequest::IsInitialized() const {

  return true;
}

void ParallelDictRequest::Swap(ParallelDictRequest* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ParallelDictRequest::InternalSwap(ParallelDictRequest* other) {
  requests_.UnsafeArenaSwap(&other->requests_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ParallelDictRequest::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ParallelDictRequest_descriptor_;
  metadata.reflection = ParallelDictRequest_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ParallelDictRequest

// repeated .rec.mcube.DictRequest requests = 2;
int ParallelDictRequest::requests_size() const {
  return requests_.size();
}
void ParallelDictRequest::clear_requests() {
  requests_.Clear();
}
const ::rec::mcube::DictRequest& ParallelDictRequest::requests(int index) const {
  // @@protoc_insertion_point(field_get:rec.mcube.ParallelDictRequest.requests)
  return requests_.Get(index);
}
::rec::mcube::DictRequest* ParallelDictRequest::mutable_requests(int index) {
  // @@protoc_insertion_point(field_mutable:rec.mcube.ParallelDictRequest.requests)
  return requests_.Mutable(index);
}
::rec::mcube::DictRequest* ParallelDictRequest::add_requests() {
  // @@protoc_insertion_point(field_add:rec.mcube.ParallelDictRequest.requests)
  return requests_.Add();
}
::google::protobuf::RepeatedPtrField< ::rec::mcube::DictRequest >*
ParallelDictRequest::mutable_requests() {
  // @@protoc_insertion_point(field_mutable_list:rec.mcube.ParallelDictRequest.requests)
  return &requests_;
}
const ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictRequest >&
ParallelDictRequest::requests() const {
  // @@protoc_insertion_point(field_list:rec.mcube.ParallelDictRequest.requests)
  return requests_;
}

inline const ParallelDictRequest* ParallelDictRequest::internal_default_instance() {
  return &ParallelDictRequest_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

#if !defined(_MSC_VER) || _MSC_VER >= 1900
const int ParallelDictResponse::kResponsesFieldNumber;
#endif  // !defined(_MSC_VER) || _MSC_VER >= 1900

ParallelDictResponse::ParallelDictResponse()
  : ::google::protobuf::Message(), _internal_metadata_(NULL) {
  if (this != internal_default_instance()) protobuf_InitDefaults_cube_2eproto();
  SharedCtor();
  // @@protoc_insertion_point(constructor:rec.mcube.ParallelDictResponse)
}

void ParallelDictResponse::InitAsDefaultInstance() {
}

ParallelDictResponse::ParallelDictResponse(const ParallelDictResponse& from)
  : ::google::protobuf::Message(),
    _internal_metadata_(NULL) {
  SharedCtor();
  UnsafeMergeFrom(from);
  // @@protoc_insertion_point(copy_constructor:rec.mcube.ParallelDictResponse)
}

void ParallelDictResponse::SharedCtor() {
  _cached_size_ = 0;
}

ParallelDictResponse::~ParallelDictResponse() {
  // @@protoc_insertion_point(destructor:rec.mcube.ParallelDictResponse)
  SharedDtor();
}

void ParallelDictResponse::SharedDtor() {
}

void ParallelDictResponse::SetCachedSize(int size) const {
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
}
const ::google::protobuf::Descriptor* ParallelDictResponse::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return ParallelDictResponse_descriptor_;
}

const ParallelDictResponse& ParallelDictResponse::default_instance() {
  protobuf_InitDefaults_cube_2eproto();
  return *internal_default_instance();
}

::google::protobuf::internal::ExplicitlyConstructed<ParallelDictResponse> ParallelDictResponse_default_instance_;

ParallelDictResponse* ParallelDictResponse::New(::google::protobuf::Arena* arena) const {
  ParallelDictResponse* n = new ParallelDictResponse;
  if (arena != NULL) {
    arena->Own(n);
  }
  return n;
}

void ParallelDictResponse::Clear() {
// @@protoc_insertion_point(message_clear_start:rec.mcube.ParallelDictResponse)
  responses_.Clear();
  _has_bits_.Clear();
  if (_internal_metadata_.have_unknown_fields()) {
    mutable_unknown_fields()->Clear();
  }
}

bool ParallelDictResponse::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:rec.mcube.ParallelDictResponse)
  for (;;) {
    ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoff(127);
    tag = p.first;
    if (!p.second) goto handle_unusual;
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
      // repeated .rec.mcube.DictResponse responses = 1;
      case 1: {
        if (tag == 10) {
          DO_(input->IncrementRecursionDepth());
         parse_loop_responses:
          DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtualNoRecursionDepth(
                input, add_responses()));
        } else {
          goto handle_unusual;
        }
        if (input->ExpectTag(10)) goto parse_loop_responses;
        input->UnsafeDecrementRecursionDepth();
        if (input->ExpectAtEnd()) goto success;
        break;
      }

      default: {
      handle_unusual:
        if (tag == 0 ||
            ::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
          goto success;
        }
        DO_(::google::protobuf::internal::WireFormat::SkipField(
              input, tag, mutable_unknown_fields()));
        break;
      }
    }
  }
success:
  // @@protoc_insertion_point(parse_success:rec.mcube.ParallelDictResponse)
  return true;
failure:
  // @@protoc_insertion_point(parse_failure:rec.mcube.ParallelDictResponse)
  return false;
#undef DO_
}

void ParallelDictResponse::SerializeWithCachedSizes(
    ::google::protobuf::io::CodedOutputStream* output) const {
  // @@protoc_insertion_point(serialize_start:rec.mcube.ParallelDictResponse)
  // repeated .rec.mcube.DictResponse responses = 1;
  for (unsigned int i = 0, n = this->responses_size(); i < n; i++) {
    ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
      1, this->responses(i), output);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
        unknown_fields(), output);
  }
  // @@protoc_insertion_point(serialize_end:rec.mcube.ParallelDictResponse)
}

::google::protobuf::uint8* ParallelDictResponse::InternalSerializeWithCachedSizesToArray(
    bool deterministic, ::google::protobuf::uint8* target) const {
  (void)deterministic; // Unused
  // @@protoc_insertion_point(serialize_to_array_start:rec.mcube.ParallelDictResponse)
  // repeated .rec.mcube.DictResponse responses = 1;
  for (unsigned int i = 0, n = this->responses_size(); i < n; i++) {
    target = ::google::protobuf::internal::WireFormatLite::
      InternalWriteMessageNoVirtualToArray(
        1, this->responses(i), false, target);
  }

  if (_internal_metadata_.have_unknown_fields()) {
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
        unknown_fields(), target);
  }
  // @@protoc_insertion_point(serialize_to_array_end:rec.mcube.ParallelDictResponse)
  return target;
}

size_t ParallelDictResponse::ByteSizeLong() const {
// @@protoc_insertion_point(message_byte_size_start:rec.mcube.ParallelDictResponse)
  size_t total_size = 0;

  // repeated .rec.mcube.DictResponse responses = 1;
  {
    unsigned int count = this->responses_size();
    total_size += 1UL * count;
    for (unsigned int i = 0; i < count; i++) {
      total_size +=
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
          this->responses(i));
    }
  }

  if (_internal_metadata_.have_unknown_fields()) {
    total_size +=
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
        unknown_fields());
  }
  int cached_size = ::google::protobuf::internal::ToCachedSize(total_size);
  GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
  _cached_size_ = cached_size;
  GOOGLE_SAFE_CONCURRENT_WRITES_END();
  return total_size;
}

void ParallelDictResponse::MergeFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_merge_from_start:rec.mcube.ParallelDictResponse)
  if (GOOGLE_PREDICT_FALSE(&from == this)) MergeFromFail(__LINE__);
  const ParallelDictResponse* source =
      ::google::protobuf::internal::DynamicCastToGenerated<const ParallelDictResponse>(
          &from);
  if (source == NULL) {
  // @@protoc_insertion_point(generalized_merge_from_cast_fail:rec.mcube.ParallelDictResponse)
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
  } else {
  // @@protoc_insertion_point(generalized_merge_from_cast_success:rec.mcube.ParallelDictResponse)
    UnsafeMergeFrom(*source);
  }
}

void ParallelDictResponse::MergeFrom(const ParallelDictResponse& from) {
// @@protoc_insertion_point(class_specific_merge_from_start:rec.mcube.ParallelDictResponse)
  if (GOOGLE_PREDICT_TRUE(&from != this)) {
    UnsafeMergeFrom(from);
  } else {
    MergeFromFail(__LINE__);
  }
}

void ParallelDictResponse::UnsafeMergeFrom(const ParallelDictResponse& from) {
  GOOGLE_DCHECK(&from != this);
  responses_.MergeFrom(from.responses_);
  if (from._internal_metadata_.have_unknown_fields()) {
    ::google::protobuf::UnknownFieldSet::MergeToInternalMetdata(
      from.unknown_fields(), &_internal_metadata_);
  }
}

void ParallelDictResponse::CopyFrom(const ::google::protobuf::Message& from) {
// @@protoc_insertion_point(generalized_copy_from_start:rec.mcube.ParallelDictResponse)
  if (&from == this) return;
  Clear();
  MergeFrom(from);
}

void ParallelDictResponse::CopyFrom(const ParallelDictResponse& from) {
// @@protoc_insertion_point(class_specific_copy_from_start:rec.mcube.ParallelDictResponse)
  if (&from == this) return;
  Clear();
  UnsafeMergeFrom(from);
}

bool ParallelDictResponse::IsInitialized() const {

  if (!::google::protobuf::internal::AllAreInitialized(this->responses())) return false;
  return true;
}

void ParallelDictResponse::Swap(ParallelDictResponse* other) {
  if (other == this) return;
  InternalSwap(other);
}
void ParallelDictResponse::InternalSwap(ParallelDictResponse* other) {
  responses_.UnsafeArenaSwap(&other->responses_);
  std::swap(_has_bits_[0], other->_has_bits_[0]);
  _internal_metadata_.Swap(&other->_internal_metadata_);
  std::swap(_cached_size_, other->_cached_size_);
}

::google::protobuf::Metadata ParallelDictResponse::GetMetadata() const {
  protobuf_AssignDescriptorsOnce();
  ::google::protobuf::Metadata metadata;
  metadata.descriptor = ParallelDictResponse_descriptor_;
  metadata.reflection = ParallelDictResponse_reflection_;
  return metadata;
}

#if PROTOBUF_INLINE_NOT_IN_HEADERS
// ParallelDictResponse

// repeated .rec.mcube.DictResponse responses = 1;
int ParallelDictResponse::responses_size() const {
  return responses_.size();
}
void ParallelDictResponse::clear_responses() {
  responses_.Clear();
}
const ::rec::mcube::DictResponse& ParallelDictResponse::responses(int index) const {
  // @@protoc_insertion_point(field_get:rec.mcube.ParallelDictResponse.responses)
  return responses_.Get(index);
}
::rec::mcube::DictResponse* ParallelDictResponse::mutable_responses(int index) {
  // @@protoc_insertion_point(field_mutable:rec.mcube.ParallelDictResponse.responses)
  return responses_.Mutable(index);
}
::rec::mcube::DictResponse* ParallelDictResponse::add_responses() {
  // @@protoc_insertion_point(field_add:rec.mcube.ParallelDictResponse.responses)
  return responses_.Add();
}
::google::protobuf::RepeatedPtrField< ::rec::mcube::DictResponse >*
ParallelDictResponse::mutable_responses() {
  // @@protoc_insertion_point(field_mutable_list:rec.mcube.ParallelDictResponse.responses)
  return &responses_;
}
const ::google::protobuf::RepeatedPtrField< ::rec::mcube::DictResponse >&
ParallelDictResponse::responses() const {
  // @@protoc_insertion_point(field_list:rec.mcube.ParallelDictResponse.responses)
  return responses_;
}

inline const ParallelDictResponse* ParallelDictResponse::internal_default_instance() {
  return &ParallelDictResponse_default_instance_.get();
}
#endif  // PROTOBUF_INLINE_NOT_IN_HEADERS

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

DictService::~DictService() {}

const ::google::protobuf::ServiceDescriptor* DictService::descriptor() {
  protobuf_AssignDescriptorsOnce();
  return DictService_descriptor_;
}

const ::google::protobuf::ServiceDescriptor* DictService::GetDescriptor() {
  protobuf_AssignDescriptorsOnce();
  return DictService_descriptor_;
}

void DictService::seek(::google::protobuf::RpcController* controller,
                         const ::rec::mcube::DictRequest*,
                         ::rec::mcube::DictResponse*,
                         ::google::protobuf::Closure* done) {
  controller->SetFailed("Method seek() not implemented.");
  done->Run();
}

void DictService::parallel_seek(::google::protobuf::RpcController* controller,
                         const ::rec::mcube::ParallelDictRequest*,
                         ::rec::mcube::ParallelDictResponse*,
                         ::google::protobuf::Closure* done) {
  controller->SetFailed("Method parallel_seek() not implemented.");
  done->Run();
}

void DictService::CallMethod(const ::google::protobuf::MethodDescriptor* method,
                             ::google::protobuf::RpcController* controller,
                             const ::google::protobuf::Message* request,
                             ::google::protobuf::Message* response,
                             ::google::protobuf::Closure* done) {
  GOOGLE_DCHECK_EQ(method->service(), DictService_descriptor_);
  switch(method->index()) {
    case 0:
      seek(controller,
             ::google::protobuf::down_cast<const ::rec::mcube::DictRequest*>(request),
             ::google::protobuf::down_cast< ::rec::mcube::DictResponse*>(response),
             done);
      break;
    case 1:
      parallel_seek(controller,
             ::google::protobuf::down_cast<const ::rec::mcube::ParallelDictRequest*>(request),
             ::google::protobuf::down_cast< ::rec::mcube::ParallelDictResponse*>(response),
             done);
      break;
    default:
      GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
      break;
  }
}

const ::google::protobuf::Message& DictService::GetRequestPrototype(
    const ::google::protobuf::MethodDescriptor* method) const {
  GOOGLE_DCHECK_EQ(method->service(), descriptor());
  switch(method->index()) {
    case 0:
      return ::rec::mcube::DictRequest::default_instance();
    case 1:
      return ::rec::mcube::ParallelDictRequest::default_instance();
    default:
      GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
      return *::google::protobuf::MessageFactory::generated_factory()
          ->GetPrototype(method->input_type());
  }
}

const ::google::protobuf::Message& DictService::GetResponsePrototype(
    const ::google::protobuf::MethodDescriptor* method) const {
  GOOGLE_DCHECK_EQ(method->service(), descriptor());
  switch(method->index()) {
    case 0:
      return ::rec::mcube::DictResponse::default_instance();
    case 1:
      return ::rec::mcube::ParallelDictResponse::default_instance();
    default:
      GOOGLE_LOG(FATAL) << "Bad method index; this should never happen.";
      return *::google::protobuf::MessageFactory::generated_factory()
          ->GetPrototype(method->output_type());
  }
}

DictService_Stub::DictService_Stub(::google::protobuf::RpcChannel* channel)
  : channel_(channel), owns_channel_(false) {}
DictService_Stub::DictService_Stub(
    ::google::protobuf::RpcChannel* channel,
    ::google::protobuf::Service::ChannelOwnership ownership)
  : channel_(channel),
    owns_channel_(ownership == ::google::protobuf::Service::STUB_OWNS_CHANNEL) {}
DictService_Stub::~DictService_Stub() {
  if (owns_channel_) delete channel_;
}

void DictService_Stub::seek(::google::protobuf::RpcController* controller,
                              const ::rec::mcube::DictRequest* request,
                              ::rec::mcube::DictResponse* response,
                              ::google::protobuf::Closure* done) {
  channel_->CallMethod(descriptor()->method(0),
                       controller, request, response, done);
}
void DictService_Stub::parallel_seek(::google::protobuf::RpcController* controller,
                              const ::rec::mcube::ParallelDictRequest* request,
                              ::rec::mcube::ParallelDictResponse* response,
                              ::google::protobuf::Closure* done) {
  channel_->CallMethod(descriptor()->method(1),
                       controller, request, response, done);
}

// @@protoc_insertion_point(namespace_scope)

}  // namespace mcube
}  // namespace rec

// @@protoc_insertion_point(global_scope)
