text: // Generated by the protocol buffer compiler.  DO NOT EDIT!
  
  #include "google/protobuf/descriptor.pb.h"
  #include <google/protobuf/stubs/once.h>
  #include <google/protobuf/descriptor.h>
  #include <google/protobuf/io/coded_stream.h>
  #include <google/protobuf/reflection_ops.h>
  #include <google/protobuf/wire_format_inl.h>
  
  namespace google {
  namespace protobuf {
  
  namespace {
  
  const ::google::protobuf::Descriptor* FileDescriptorSet_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    FileDescriptorSet_reflection_ = NULL;
  const ::google::protobuf::Descriptor* FileDescriptorProto_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    FileDescriptorProto_reflection_ = NULL;
  const ::google::protobuf::Descriptor* DescriptorProto_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    DescriptorProto_reflection_ = NULL;
  const ::google::protobuf::Descriptor* DescriptorProto_ExtensionRange_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    DescriptorProto_ExtensionRange_reflection_ = NULL;
  const ::google::protobuf::Descriptor* FieldDescriptorProto_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    FieldDescriptorProto_reflection_ = NULL;
  const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Type_descriptor_ = NULL;
  const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Label_descriptor_ = NULL;
  const ::google::protobuf::Descriptor* EnumDescriptorProto_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    EnumDescriptorProto_reflection_ = NULL;
  const ::google::protobuf::Descriptor* EnumValueDescriptorProto_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    EnumValueDescriptorProto_reflection_ = NULL;
  const ::google::protobuf::Descriptor* ServiceDescriptorProto_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    ServiceDescriptorProto_reflection_ = NULL;
  const ::google::protobuf::Descriptor* MethodDescriptorProto_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    MethodDescriptorProto_reflection_ = NULL;
  const ::google::protobuf::Descriptor* FileOptions_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    FileOptions_reflection_ = NULL;
  const ::google::protobuf::EnumDescriptor* FileOptions_OptimizeMode_descriptor_ = NULL;
  const ::google::protobuf::Descriptor* MessageOptions_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    MessageOptions_reflection_ = NULL;
  const ::google::protobuf::Descriptor* FieldOptions_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    FieldOptions_reflection_ = NULL;
  const ::google::protobuf::EnumDescriptor* FieldOptions_CType_descriptor_ = NULL;
  const ::google::protobuf::Descriptor* EnumOptions_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    EnumOptions_reflection_ = NULL;
  const ::google::protobuf::Descriptor* EnumValueOptions_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    EnumValueOptions_reflection_ = NULL;
  const ::google::protobuf::Descriptor* ServiceOptions_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    ServiceOptions_reflection_ = NULL;
  const ::google::protobuf::Descriptor* MethodOptions_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    MethodOptions_reflection_ = NULL;
  const ::google::protobuf::Descriptor* UninterpretedOption_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    UninterpretedOption_reflection_ = NULL;
  const ::google::protobuf::Descriptor* UninterpretedOption_NamePart_descriptor_ = NULL;
  const ::google::protobuf::internal::GeneratedMessageReflection*
    UninterpretedOption_NamePart_reflection_ = NULL;
  
  }  // namespace
  
  
  void protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto() {
    protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
    const ::google::protobuf::FileDescriptor* file =
      ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
        "google/protobuf/descriptor.proto");
    GOOGLE_CHECK(file != NULL);
    FileDescriptorSet_descriptor_ = file->message_type(0);
    static const int FileDescriptorSet_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorSet, file_),
    };
    FileDescriptorSet_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        FileDescriptorSet_descriptor_,
        FileDescriptorSet::default_instance_,
        FileDescriptorSet_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorSet, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorSet, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(FileDescriptorSet));
    FileDescriptorProto_descriptor_ = file->message_type(1);
    static const int FileDescriptorProto_offsets_[8] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, name_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, package_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, dependency_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, message_type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, enum_type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, service_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, extension_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, options_),
    };
    FileDescriptorProto_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        FileDescriptorProto_descriptor_,
        FileDescriptorProto::default_instance_,
        FileDescriptorProto_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileDescriptorProto, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(FileDescriptorProto));
    DescriptorProto_descriptor_ = file->message_type(2);
    static const int DescriptorProto_offsets_[7] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, name_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, field_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, extension_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, nested_type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, enum_type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, extension_range_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, options_),
    };
    DescriptorProto_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        DescriptorProto_descriptor_,
        DescriptorProto::default_instance_,
        DescriptorProto_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(DescriptorProto));
    DescriptorProto_ExtensionRange_descriptor_ = DescriptorProto_descriptor_->nested_type(0);
    static const int DescriptorProto_ExtensionRange_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto_ExtensionRange, start_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto_ExtensionRange, end_),
    };
    DescriptorProto_ExtensionRange_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        DescriptorProto_ExtensionRange_descriptor_,
        DescriptorProto_ExtensionRange::default_instance_,
        DescriptorProto_ExtensionRange_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto_ExtensionRange, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DescriptorProto_ExtensionRange, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(DescriptorProto_ExtensionRange));
    FieldDescriptorProto_descriptor_ = file->message_type(3);
    static const int FieldDescriptorProto_offsets_[8] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, name_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, number_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, label_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, type_name_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, extendee_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, default_value_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, options_),
    };
    FieldDescriptorProto_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        FieldDescriptorProto_descriptor_,
        FieldDescriptorProto::default_instance_,
        FieldDescriptorProto_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldDescriptorProto, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(FieldDescriptorProto));
    FieldDescriptorProto_Type_descriptor_ = FieldDescriptorProto_descriptor_->enum_type(0);
    FieldDescriptorProto_Label_descriptor_ = FieldDescriptorProto_descriptor_->enum_type(1);
    EnumDescriptorProto_descriptor_ = file->message_type(4);
    static const int EnumDescriptorProto_offsets_[3] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumDescriptorProto, name_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumDescriptorProto, value_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumDescriptorProto, options_),
    };
    EnumDescriptorProto_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        EnumDescriptorProto_descriptor_,
        EnumDescriptorProto::default_instance_,
        EnumDescriptorProto_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumDescriptorProto, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumDescriptorProto, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(EnumDescriptorProto));
    EnumValueDescriptorProto_descriptor_ = file->message_type(5);
    static const int EnumValueDescriptorProto_offsets_[3] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueDescriptorProto, name_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueDescriptorProto, number_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueDescriptorProto, options_),
    };
    EnumValueDescriptorProto_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        EnumValueDescriptorProto_descriptor_,
        EnumValueDescriptorProto::default_instance_,
        EnumValueDescriptorProto_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueDescriptorProto, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueDescriptorProto, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(EnumValueDescriptorProto));
    ServiceDescriptorProto_descriptor_ = file->message_type(6);
    static const int ServiceDescriptorProto_offsets_[3] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDescriptorProto, name_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDescriptorProto, method_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDescriptorProto, options_),
    };
    ServiceDescriptorProto_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        ServiceDescriptorProto_descriptor_,
        ServiceDescriptorProto::default_instance_,
        ServiceDescriptorProto_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDescriptorProto, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceDescriptorProto, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(ServiceDescriptorProto));
    MethodDescriptorProto_descriptor_ = file->message_type(7);
    static const int MethodDescriptorProto_offsets_[4] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, name_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, input_type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, output_type_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, options_),
    };
    MethodDescriptorProto_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        MethodDescriptorProto_descriptor_,
        MethodDescriptorProto::default_instance_,
        MethodDescriptorProto_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodDescriptorProto, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(MethodDescriptorProto));
    FileOptions_descriptor_ = file->message_type(8);
    static const int FileOptions_offsets_[5] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, java_package_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, java_outer_classname_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, java_multiple_files_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, optimize_for_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, uninterpreted_option_),
    };
    FileOptions_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        FileOptions_descriptor_,
        FileOptions::default_instance_,
        FileOptions_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, _unknown_fields_),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FileOptions, _extensions_),
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(FileOptions));
    FileOptions_OptimizeMode_descriptor_ = FileOptions_descriptor_->enum_type(0);
    MessageOptions_descriptor_ = file->message_type(9);
    static const int MessageOptions_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageOptions, message_set_wire_format_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageOptions, uninterpreted_option_),
    };
    MessageOptions_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        MessageOptions_descriptor_,
        MessageOptions::default_instance_,
        MessageOptions_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageOptions, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageOptions, _unknown_fields_),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MessageOptions, _extensions_),
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(MessageOptions));
    FieldOptions_descriptor_ = file->message_type(10);
    static const int FieldOptions_offsets_[5] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, ctype_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, packed_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, deprecated_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, experimental_map_key_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, uninterpreted_option_),
    };
    FieldOptions_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        FieldOptions_descriptor_,
        FieldOptions::default_instance_,
        FieldOptions_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, _unknown_fields_),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldOptions, _extensions_),
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(FieldOptions));
    FieldOptions_CType_descriptor_ = FieldOptions_descriptor_->enum_type(0);
    EnumOptions_descriptor_ = file->message_type(11);
    static const int EnumOptions_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumOptions, uninterpreted_option_),
    };
    EnumOptions_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        EnumOptions_descriptor_,
        EnumOptions::default_instance_,
        EnumOptions_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumOptions, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumOptions, _unknown_fields_),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumOptions, _extensions_),
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(EnumOptions));
    EnumValueOptions_descriptor_ = file->message_type(12);
    static const int EnumValueOptions_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueOptions, uninterpreted_option_),
    };
    EnumValueOptions_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        EnumValueOptions_descriptor_,
        EnumValueOptions::default_instance_,
        EnumValueOptions_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueOptions, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueOptions, _unknown_fields_),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(EnumValueOptions, _extensions_),
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(EnumValueOptions));
    ServiceOptions_descriptor_ = file->message_type(13);
    static const int ServiceOptions_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceOptions, uninterpreted_option_),
    };
    ServiceOptions_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        ServiceOptions_descriptor_,
        ServiceOptions::default_instance_,
        ServiceOptions_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceOptions, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceOptions, _unknown_fields_),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ServiceOptions, _extensions_),
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(ServiceOptions));
    MethodOptions_descriptor_ = file->message_type(14);
    static const int MethodOptions_offsets_[1] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodOptions, uninterpreted_option_),
    };
    MethodOptions_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        MethodOptions_descriptor_,
        MethodOptions::default_instance_,
        MethodOptions_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodOptions, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodOptions, _unknown_fields_),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(MethodOptions, _extensions_),
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(MethodOptions));
    UninterpretedOption_descriptor_ = file->message_type(15);
    static const int UninterpretedOption_offsets_[6] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, name_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, identifier_value_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, positive_int_value_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, negative_int_value_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, double_value_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, string_value_),
    };
    UninterpretedOption_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        UninterpretedOption_descriptor_,
        UninterpretedOption::default_instance_,
        UninterpretedOption_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(UninterpretedOption));
    UninterpretedOption_NamePart_descriptor_ = UninterpretedOption_descriptor_->nested_type(0);
    static const int UninterpretedOption_NamePart_offsets_[2] = {
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption_NamePart, name_part_),
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption_NamePart, is_extension_),
    };
    UninterpretedOption_NamePart_reflection_ =
      new ::google::protobuf::internal::GeneratedMessageReflection(
        UninterpretedOption_NamePart_descriptor_,
        UninterpretedOption_NamePart::default_instance_,
        UninterpretedOption_NamePart_offsets_,
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption_NamePart, _has_bits_[0]),
        GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UninterpretedOption_NamePart, _unknown_fields_),
        -1,
        ::google::protobuf::DescriptorPool::generated_pool(),
        ::google::protobuf::MessageFactory::generated_factory(),
        sizeof(UninterpretedOption_NamePart));
  }
  
  namespace {
  
  GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
  inline void protobuf_AssignDescriptorsOnce() {
    ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
                   &protobuf_AssignDesc_google_2fprotobuf_2fdescriptor_2eproto);
  }
  
  void protobuf_RegisterTypes() {
    protobuf_AssignDescriptorsOnce();
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      FileDescriptorSet_descriptor_, &FileDescriptorSet::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      FileDescriptorProto_descriptor_, &FileDescriptorProto::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      DescriptorProto_descriptor_, &DescriptorProto::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      DescriptorProto_ExtensionRange_descriptor_, &DescriptorProto_ExtensionRange::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      FieldDescriptorProto_descriptor_, &FieldDescriptorProto::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      EnumDescriptorProto_descriptor_, &EnumDescriptorProto::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      EnumValueDescriptorProto_descriptor_, &EnumValueDescriptorProto::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ServiceDescriptorProto_descriptor_, &ServiceDescriptorProto::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      MethodDescriptorProto_descriptor_, &MethodDescriptorProto::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      FileOptions_descriptor_, &FileOptions::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      MessageOptions_descriptor_, &MessageOptions::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      FieldOptions_descriptor_, &FieldOptions::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      EnumOptions_descriptor_, &EnumOptions::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      EnumValueOptions_descriptor_, &EnumValueOptions::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      ServiceOptions_descriptor_, &ServiceOptions::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      MethodOptions_descriptor_, &MethodOptions::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      UninterpretedOption_descriptor_, &UninterpretedOption::default_instance());
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
      UninterpretedOption_NamePart_descriptor_, &UninterpretedOption_NamePart::default_instance());
  }
  
  }  // namespace
  
  void protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto() {
    delete FileDescriptorSet::default_instance_;
    delete FileDescriptorSet_reflection_;
    delete FileDescriptorProto::default_instance_;
    delete FileDescriptorProto_reflection_;
    delete DescriptorProto::default_instance_;
    delete DescriptorProto_reflection_;
    delete DescriptorProto_ExtensionRange::default_instance_;
    delete DescriptorProto_ExtensionRange_reflection_;
    delete FieldDescriptorProto::default_instance_;
    delete FieldDescriptorProto_reflection_;
    delete EnumDescriptorProto::default_instance_;
    delete EnumDescriptorProto_reflection_;
    delete EnumValueDescriptorProto::default_instance_;
    delete EnumValueDescriptorProto_reflection_;
    delete ServiceDescriptorProto::default_instance_;
    delete ServiceDescriptorProto_reflection_;
    delete MethodDescriptorProto::default_instance_;
    delete MethodDescriptorProto_reflection_;
    delete FileOptions::default_instance_;
    delete FileOptions_reflection_;
    delete MessageOptions::default_instance_;
    delete MessageOptions_reflection_;
    delete FieldOptions::default_instance_;
    delete FieldOptions_reflection_;
    delete EnumOptions::default_instance_;
    delete EnumOptions_reflection_;
    delete EnumValueOptions::default_instance_;
    delete EnumValueOptions_reflection_;
    delete ServiceOptions::default_instance_;
    delete ServiceOptions_reflection_;
    delete MethodOptions::default_instance_;
    delete MethodOptions_reflection_;
    delete UninterpretedOption::default_instance_;
    delete UninterpretedOption_reflection_;
    delete UninterpretedOption_NamePart::default_instance_;
    delete UninterpretedOption_NamePart_reflection_;
  }
  
  void protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto() {
    static bool already_here = false;
    if (already_here) return;
    already_here = true;
    GOOGLE_PROTOBUF_VERIFY_VERSION;
  
    ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
      "\n google/protobuf/descriptor.proto\022\017goog"
      "le.protobuf\"G\n\021FileDescriptorSet\0222\n\004file"
      "\030\001 \003(\0132$.google.protobuf.FileDescriptorP"
      "roto\"\334\002\n\023FileDescriptorProto\022\014\n\004name\030\001 \001"
      "(\t\022\017\n\007package\030\002 \001(\t\022\022\n\ndependency\030\003 \003(\t\022"
      "6\n\014message_type\030\004 \003(\0132 .google.protobuf."
      "DescriptorProto\0227\n\tenum_type\030\005 \003(\0132$.goo"
      "gle.protobuf.EnumDescriptorProto\0228\n\007serv"
      "ice\030\006 \003(\0132\'.google.protobuf.ServiceDescr"
      "iptorProto\0228\n\textension\030\007 \003(\0132%.google.p"
      "rotobuf.FieldDescriptorProto\022-\n\007options\030"
      "\010 \001(\0132\034.google.protobuf.FileOptions\"\251\003\n\017"
      "DescriptorProto\022\014\n\004name\030\001 \001(\t\0224\n\005field\030\002"
      " \003(\0132%.google.protobuf.FieldDescriptorPr"
      "oto\0228\n\textension\030\006 \003(\0132%.google.protobuf"
      ".FieldDescriptorProto\0225\n\013nested_type\030\003 \003"
      "(\0132 .google.protobuf.DescriptorProto\0227\n\t"
      "enum_type\030\004 \003(\0132$.google.protobuf.EnumDe"
      "scriptorProto\022H\n\017extension_range\030\005 \003(\0132/"
      ".google.protobuf.DescriptorProto.Extensi"
      "onRange\0220\n\007options\030\007 \001(\0132\037.google.protob"
      "uf.MessageOptions\032,\n\016ExtensionRange\022\r\n\005s"
      "tart\030\001 \001(\005\022\013\n\003end\030\002 \001(\005\"\224\005\n\024FieldDescrip"
      "torProto\022\014\n\004name\030\001 \001(\t\022\016\n\006number\030\003 \001(\005\022:"
      "\n\005label\030\004 \001(\0162+.google.protobuf.FieldDes"
      "criptorProto.Label\0228\n\004type\030\005 \001(\0162*.googl"
      "e.protobuf.FieldDescriptorProto.Type\022\021\n\t"
      "type_name\030\006 \001(\t\022\020\n\010extendee\030\002 \001(\t\022\025\n\rdef"
      "ault_value\030\007 \001(\t\022.\n\007options\030\010 \001(\0132\035.goog"
      "le.protobuf.FieldOptions\"\266\002\n\004Type\022\017\n\013TYP"
      "E_DOUBLE\020\001\022\016\n\nTYPE_FLOAT\020\002\022\016\n\nTYPE_INT64"
      "\020\003\022\017\n\013TYPE_UINT64\020\004\022\016\n\nTYPE_INT32\020\005\022\020\n\014T"
      "YPE_FIXED64\020\006\022\020\n\014TYPE_FIXED32\020\007\022\r\n\tTYPE_"
      "BOOL\020\010\022\017\n\013TYPE_STRING\020\t\022\016\n\nTYPE_GROUP\020\n\022"
      "\020\n\014TYPE_MESSAGE\020\013\022\016\n\nTYPE_BYTES\020\014\022\017\n\013TYP"
      "E_UINT32\020\r\022\r\n\tTYPE_ENUM\020\016\022\021\n\rTYPE_SFIXED"
      "32\020\017\022\021\n\rTYPE_SFIXED64\020\020\022\017\n\013TYPE_SINT32\020\021"
      "\022\017\n\013TYPE_SINT64\020\022\"C\n\005Label\022\022\n\016LABEL_OPTI"
      "ONAL\020\001\022\022\n\016LABEL_REQUIRED\020\002\022\022\n\016LABEL_REPE"
      "ATED\020\003\"\214\001\n\023EnumDescriptorProto\022\014\n\004name\030\001"
      " \001(\t\0228\n\005value\030\002 \003(\0132).google.protobuf.En"
      "umValueDescriptorProto\022-\n\007options\030\003 \001(\0132"
      "\034.google.protobuf.EnumOptions\"l\n\030EnumVal"
      "ueDescriptorProto\022\014\n\004name\030\001 \001(\t\022\016\n\006numbe"
      "r\030\002 \001(\005\0222\n\007options\030\003 \001(\0132!.google.protob"
      "uf.EnumValueOptions\"\220\001\n\026ServiceDescripto"
      "rProto\022\014\n\004name\030\001 \001(\t\0226\n\006method\030\002 \003(\0132&.g"
      "oogle.protobuf.MethodDescriptorProto\0220\n\007"
      "options\030\003 \001(\0132\037.google.protobuf.ServiceO"
      "ptions\"\177\n\025MethodDescriptorProto\022\014\n\004name\030"
      "\001 \001(\t\022\022\n\ninput_type\030\002 \001(\t\022\023\n\013output_type"
      "\030\003 \001(\t\022/\n\007options\030\004 \001(\0132\036.google.protobu"
      "f.MethodOptions\"\247\002\n\013FileOptions\022\024\n\014java_"
      "package\030\001 \001(\t\022\034\n\024java_outer_classname\030\010 "
      "\001(\t\022\"\n\023java_multiple_files\030\n \001(\010:\005false\022"
      "F\n\014optimize_for\030\t \001(\0162).google.protobuf."
      "FileOptions.OptimizeMode:\005SPEED\022C\n\024unint"
      "erpreted_option\030\347\007 \003(\0132$.google.protobuf"
      ".UninterpretedOption\"(\n\014OptimizeMode\022\t\n\005"
      "SPEED\020\001\022\r\n\tCODE_SIZE\020\002*\t\010\350\007\020\200\200\200\200\002\"\210\001\n\016Me"
      "ssageOptions\022&\n\027message_set_wire_format\030"
      "\001 \001(\010:\005false\022C\n\024uninterpreted_option\030\347\007 "
      "\003(\0132$.google.protobuf.UninterpretedOptio"
      "n*\t\010\350\007\020\200\200\200\200\002\"\200\002\n\014FieldOptions\0222\n\005ctype\030\001"
      " \001(\0162#.google.protobuf.FieldOptions.CTyp"
      "e\022\016\n\006packed\030\002 \001(\010\022\031\n\ndeprecated\030\003 \001(\010:\005f"
      "alse\022\034\n\024experimental_map_key\030\t \001(\t\022C\n\024un"
      "interpreted_option\030\347\007 \003(\0132$.google.proto"
      "buf.UninterpretedOption\"#\n\005CType\022\010\n\004CORD"
      "\020\001\022\020\n\014STRING_PIECE\020\002*\t\010\350\007\020\200\200\200\200\002\"]\n\013EnumO"
      "ptions\022C\n\024uninterpreted_option\030\347\007 \003(\0132$."
      "google.protobuf.UninterpretedOption*\t\010\350\007"
      "\020\200\200\200\200\002\"b\n\020EnumValueOptions\022C\n\024uninterpre"
      "ted_option\030\347\007 \003(\0132$.google.protobuf.Unin"
      "terpretedOption*\t\010\350\007\020\200\200\200\200\002\"`\n\016ServiceOpt"
      "ions\022C\n\024uninterpreted_option\030\347\007 \003(\0132$.go"
      "ogle.protobuf.UninterpretedOption*\t\010\350\007\020\200"
      "\200\200\200\002\"_\n\rMethodOptions\022C\n\024uninterpreted_o"
      "ption\030\347\007 \003(\0132$.google.protobuf.Uninterpr"
      "etedOption*\t\010\350\007\020\200\200\200\200\002\"\205\002\n\023UninterpretedO"
      "ption\022;\n\004name\030\002 \003(\0132-.google.protobuf.Un"
      "interpretedOption.NamePart\022\030\n\020identifier"
      "_value\030\003 \001(\t\022\032\n\022positive_int_value\030\004 \001(\004"
      "\022\032\n\022negative_int_value\030\005 \001(\003\022\024\n\014double_v"
      "alue\030\006 \001(\001\022\024\n\014string_value\030\007 \001(\014\0323\n\010Name"
      "Part\022\021\n\tname_part\030\001 \002(\t\022\024\n\014is_extension\030"
      "\002 \002(\010B)\n\023com.google.protobufB\020Descriptor"
      "ProtosH\001", 3488);
    ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
      "google/protobuf/descriptor.proto", &protobuf_RegisterTypes);
    FileDescriptorSet::default_instance_ = new FileDescriptorSet();
    FileDescriptorProto::default_instance_ = new FileDescriptorProto();
    DescriptorProto::default_instance_ = new DescriptorProto();
    DescriptorProto_ExtensionRange::default_instance_ = new DescriptorProto_ExtensionRange();
    FieldDescriptorProto::default_instance_ = new FieldDescriptorProto();
    EnumDescriptorProto::default_instance_ = new EnumDescriptorProto();
    EnumValueDescriptorProto::default_instance_ = new EnumValueDescriptorProto();
    ServiceDescriptorProto::default_instance_ = new ServiceDescriptorProto();
    MethodDescriptorProto::default_instance_ = new MethodDescriptorProto();
    FileOptions::default_instance_ = new FileOptions();
    MessageOptions::default_instance_ = new MessageOptions();
    FieldOptions::default_instance_ = new FieldOptions();
    EnumOptions::default_instance_ = new EnumOptions();
    EnumValueOptions::default_instance_ = new EnumValueOptions();
    ServiceOptions::default_instance_ = new ServiceOptions();
    MethodOptions::default_instance_ = new MethodOptions();
    UninterpretedOption::default_instance_ = new UninterpretedOption();
    UninterpretedOption_NamePart::default_instance_ = new UninterpretedOption_NamePart();
    FileDescriptorSet::default_instance_->InitAsDefaultInstance();
    FileDescriptorProto::default_instance_->InitAsDefaultInstance();
    DescriptorProto::default_instance_->InitAsDefaultInstance();
    DescriptorProto_ExtensionRange::default_instance_->InitAsDefaultInstance();
    FieldDescriptorProto::default_instance_->InitAsDefaultInstance();
    EnumDescriptorProto::default_instance_->InitAsDefaultInstance();
    EnumValueDescriptorProto::default_instance_->InitAsDefaultInstance();
    ServiceDescriptorProto::default_instance_->InitAsDefaultInstance();
    MethodDescriptorProto::default_instance_->InitAsDefaultInstance();
    FileOptions::default_instance_->InitAsDefaultInstance();
    MessageOptions::default_instance_->InitAsDefaultInstance();
    FieldOptions::default_instance_->InitAsDefaultInstance();
    EnumOptions::default_instance_->InitAsDefaultInstance();
    EnumValueOptions::default_instance_->InitAsDefaultInstance();
    ServiceOptions::default_instance_->InitAsDefaultInstance();
    MethodOptions::default_instance_->InitAsDefaultInstance();
    UninterpretedOption::default_instance_->InitAsDefaultInstance();
    UninterpretedOption_NamePart::default_instance_->InitAsDefaultInstance();
    ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_google_2fprotobuf_2fdescriptor_2eproto);
  }
  
  // Force AddDescriptors() to be called at static initialization time.
  struct StaticDescriptorInitializer_google_2fprotobuf_2fdescriptor_2eproto {
    StaticDescriptorInitializer_google_2fprotobuf_2fdescriptor_2eproto() {
      protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();
    }
  } static_descriptor_initializer_google_2fprotobuf_2fdescriptor_2eproto_;
  
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int FileDescriptorSet::kFileFieldNumber;
  #endif  // !_MSC_VER
  
  FileDescriptorSet::FileDescriptorSet()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void FileDescriptorSet::InitAsDefaultInstance() {}
  
  FileDescriptorSet::FileDescriptorSet(const FileDescriptorSet& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void FileDescriptorSet::SharedCtor() {
    _cached_size_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  FileDescriptorSet::~FileDescriptorSet() {
    SharedDtor();
  }
  
  void FileDescriptorSet::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  const ::google::protobuf::Descriptor* FileDescriptorSet::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return FileDescriptorSet_descriptor_;
  }
  
  const FileDescriptorSet& FileDescriptorSet::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  FileDescriptorSet* FileDescriptorSet::default_instance_ = NULL;
  
  FileDescriptorSet* FileDescriptorSet::New() const {
    return new FileDescriptorSet;
  }
  
  void FileDescriptorSet::Clear() {
    file_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool FileDescriptorSet::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // repeated .google.protobuf.FileDescriptorProto file = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_file:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_file()));
          if (input->ExpectTag(10)) goto parse_file;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void FileDescriptorSet::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      FileDescriptorSet::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // repeated .google.protobuf.FileDescriptorProto file = 1;
    for (int i = 0; i < this->file_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(1, this->file(i), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* FileDescriptorSet::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // repeated .google.protobuf.FileDescriptorProto file = 1;
    for (int i = 0; i < this->file_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(1, this->file(i), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int FileDescriptorSet::ByteSize() const {
    int total_size = 0;
    
    // repeated .google.protobuf.FileDescriptorProto file = 1;
    total_size += 1 * this->file_size();
    for (int i = 0; i < this->file_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->file(i));
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void FileDescriptorSet::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const FileDescriptorSet* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const FileDescriptorSet*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void FileDescriptorSet::MergeFrom(const FileDescriptorSet& from) {
    GOOGLE_CHECK_NE(&from, this);
    file_.MergeFrom(from.file_);
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void FileDescriptorSet::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void FileDescriptorSet::CopyFrom(const FileDescriptorSet& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void FileDescriptorSet::Swap(FileDescriptorSet* other) {
    if (other != this) {
      file_.Swap(&other->file_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  bool FileDescriptorSet::IsInitialized() const {
    
    for (int i = 0; i < file_size(); i++) {
      if (!this->file(i).IsInitialized()) return false;
    }
    return true;
  }
  
  const ::google::protobuf::Descriptor* FileDescriptorSet::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* FileDescriptorSet::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return FileDescriptorSet_reflection_;
  }
  
  // ===================================================================
  
  const ::std::string FileDescriptorProto::_default_name_;
  const ::std::string FileDescriptorProto::_default_package_;
  #ifndef _MSC_VER
  const int FileDescriptorProto::kNameFieldNumber;
  const int FileDescriptorProto::kPackageFieldNumber;
  const int FileDescriptorProto::kDependencyFieldNumber;
  const int FileDescriptorProto::kMessageTypeFieldNumber;
  const int FileDescriptorProto::kEnumTypeFieldNumber;
  const int FileDescriptorProto::kServiceFieldNumber;
  const int FileDescriptorProto::kExtensionFieldNumber;
  const int FileDescriptorProto::kOptionsFieldNumber;
  #endif  // !_MSC_VER
  
  FileDescriptorProto::FileDescriptorProto()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void FileDescriptorProto::InitAsDefaultInstance() {  options_ = const_cast< ::google::protobuf::FileOptions*>(&::google::protobuf::FileOptions::default_instance());
  }
  
  FileDescriptorProto::FileDescriptorProto(const FileDescriptorProto& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void FileDescriptorProto::SharedCtor() {
    _cached_size_ = 0;
    name_ = const_cast< ::std::string*>(&_default_name_);
    package_ = const_cast< ::std::string*>(&_default_package_);
    options_ = NULL;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  FileDescriptorProto::~FileDescriptorProto() {
    SharedDtor();
  }
  
  void FileDescriptorProto::SharedDtor() {
    if (name_ != &_default_name_) {
      delete name_;
    }
    if (package_ != &_default_package_) {
      delete package_;
    }
    if (this != default_instance_) {
      delete options_;
    }
  }
  
  const ::google::protobuf::Descriptor* FileDescriptorProto::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return FileDescriptorProto_descriptor_;
  }
  
  const FileDescriptorProto& FileDescriptorProto::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  FileDescriptorProto* FileDescriptorProto::default_instance_ = NULL;
  
  FileDescriptorProto* FileDescriptorProto::New() const {
    return new FileDescriptorProto;
  }
  
  void FileDescriptorProto::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (_has_bit(0)) {
        if (name_ != &_default_name_) {
          name_->clear();
        }
      }
      if (_has_bit(1)) {
        if (package_ != &_default_package_) {
          package_->clear();
        }
      }
      if (_has_bit(7)) {
        if (options_ != NULL) options_->::google::protobuf::FileOptions::Clear();
      }
    }
    dependency_.Clear();
    message_type_.Clear();
    enum_type_.Clear();
    service_.Clear();
    extension_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool FileDescriptorProto::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // optional string name = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_name()));
          if (input->ExpectTag(18)) goto parse_package;
          break;
        }
        
        // optional string package = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_package:
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_package()));
          if (input->ExpectTag(26)) goto parse_dependency;
          break;
        }
        
        // repeated string dependency = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_dependency:
          DO_(::google::protobuf::internal::WireFormat::ReadString(
               input, add_dependency()));
          if (input->ExpectTag(26)) goto parse_dependency;
          if (input->ExpectTag(34)) goto parse_message_type;
          break;
        }
        
        // repeated .google.protobuf.DescriptorProto message_type = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_message_type:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_message_type()));
          if (input->ExpectTag(34)) goto parse_message_type;
          if (input->ExpectTag(42)) goto parse_enum_type;
          break;
        }
        
        // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
        case 5: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_enum_type:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_enum_type()));
          if (input->ExpectTag(42)) goto parse_enum_type;
          if (input->ExpectTag(50)) goto parse_service;
          break;
        }
        
        // repeated .google.protobuf.ServiceDescriptorProto service = 6;
        case 6: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_service:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_service()));
          if (input->ExpectTag(50)) goto parse_service;
          if (input->ExpectTag(58)) goto parse_extension;
          break;
        }
        
        // repeated .google.protobuf.FieldDescriptorProto extension = 7;
        case 7: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_extension:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_extension()));
          if (input->ExpectTag(58)) goto parse_extension;
          if (input->ExpectTag(66)) goto parse_options;
          break;
        }
        
        // optional .google.protobuf.FileOptions options = 8;
        case 8: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_options:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, mutable_options()));
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void FileDescriptorProto::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      FileDescriptorProto::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // optional string name = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteString(1, this->name(), output);
    }
    
    // optional string package = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::WriteString(2, this->package(), output);
    }
    
    // repeated string dependency = 3;
    for (int i = 0; i < this->dependency_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteString(3, this->dependency(i), output);
    }
    
    // repeated .google.protobuf.DescriptorProto message_type = 4;
    for (int i = 0; i < this->message_type_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(4, this->message_type(i), output);
    }
    
    // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
    for (int i = 0; i < this->enum_type_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(5, this->enum_type(i), output);
    }
    
    // repeated .google.protobuf.ServiceDescriptorProto service = 6;
    for (int i = 0; i < this->service_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(6, this->service(i), output);
    }
    
    // repeated .google.protobuf.FieldDescriptorProto extension = 7;
    for (int i = 0; i < this->extension_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(7, this->extension(i), output);
    }
    
    // optional .google.protobuf.FileOptions options = 8;
    if (_has_bit(7)) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(8, this->options(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* FileDescriptorProto::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional string name = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(1, this->name(), target);
    }
    
    // optional string package = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(2, this->package(), target);
    }
    
    // repeated string dependency = 3;
    for (int i = 0; i < this->dependency_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(3, this->dependency(i), target);
    }
    
    // repeated .google.protobuf.DescriptorProto message_type = 4;
    for (int i = 0; i < this->message_type_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(4, this->message_type(i), target);
    }
    
    // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
    for (int i = 0; i < this->enum_type_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(5, this->enum_type(i), target);
    }
    
    // repeated .google.protobuf.ServiceDescriptorProto service = 6;
    for (int i = 0; i < this->service_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(6, this->service(i), target);
    }
    
    // repeated .google.protobuf.FieldDescriptorProto extension = 7;
    for (int i = 0; i < this->extension_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(7, this->extension(i), target);
    }
    
    // optional .google.protobuf.FileOptions options = 8;
    if (_has_bit(7)) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(8, this->options(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int FileDescriptorProto::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional string name = 1;
      if (has_name()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->name());
      }
      
      // optional string package = 2;
      if (has_package()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->package());
      }
      
      // optional .google.protobuf.FileOptions options = 8;
      if (has_options()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
            this->options());
      }
      
    }
    // repeated string dependency = 3;
    total_size += 1 * this->dependency_size();
    for (int i = 0; i < this->dependency_size(); i++) {
      total_size += ::google::protobuf::internal::WireFormat::StringSize(
        this->dependency(i));
    }
    
    // repeated .google.protobuf.DescriptorProto message_type = 4;
    total_size += 1 * this->message_type_size();
    for (int i = 0; i < this->message_type_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->message_type(i));
    }
    
    // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
    total_size += 1 * this->enum_type_size();
    for (int i = 0; i < this->enum_type_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->enum_type(i));
    }
    
    // repeated .google.protobuf.ServiceDescriptorProto service = 6;
    total_size += 1 * this->service_size();
    for (int i = 0; i < this->service_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->service(i));
    }
    
    // repeated .google.protobuf.FieldDescriptorProto extension = 7;
    total_size += 1 * this->extension_size();
    for (int i = 0; i < this->extension_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->extension(i));
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void FileDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const FileDescriptorProto* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const FileDescriptorProto*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void FileDescriptorProto::MergeFrom(const FileDescriptorProto& from) {
    GOOGLE_CHECK_NE(&from, this);
    dependency_.MergeFrom(from.dependency_);
    message_type_.MergeFrom(from.message_type_);
    enum_type_.MergeFrom(from.enum_type_);
    service_.MergeFrom(from.service_);
    extension_.MergeFrom(from.extension_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_name(from.name());
      }
      if (from._has_bit(1)) {
        set_package(from.package());
      }
      if (from._has_bit(7)) {
        mutable_options()->::google::protobuf::FileOptions::MergeFrom(from.options());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void FileDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void FileDescriptorProto::CopyFrom(const FileDescriptorProto& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void FileDescriptorProto::Swap(FileDescriptorProto* other) {
    if (other != this) {
      std::swap(name_, other->name_);
      std::swap(package_, other->package_);
      dependency_.Swap(&other->dependency_);
      message_type_.Swap(&other->message_type_);
      enum_type_.Swap(&other->enum_type_);
      service_.Swap(&other->service_);
      extension_.Swap(&other->extension_);
      std::swap(options_, other->options_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  bool FileDescriptorProto::IsInitialized() const {
    
    for (int i = 0; i < message_type_size(); i++) {
      if (!this->message_type(i).IsInitialized()) return false;
    }
    for (int i = 0; i < enum_type_size(); i++) {
      if (!this->enum_type(i).IsInitialized()) return false;
    }
    for (int i = 0; i < service_size(); i++) {
      if (!this->service(i).IsInitialized()) return false;
    }
    for (int i = 0; i < extension_size(); i++) {
      if (!this->extension(i).IsInitialized()) return false;
    }
    if (has_options()) {
      if (!this->options().IsInitialized()) return false;
    }
    return true;
  }
  
  const ::google::protobuf::Descriptor* FileDescriptorProto::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* FileDescriptorProto::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return FileDescriptorProto_reflection_;
  }
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int DescriptorProto_ExtensionRange::kStartFieldNumber;
  const int DescriptorProto_ExtensionRange::kEndFieldNumber;
  #endif  // !_MSC_VER
  
  DescriptorProto_ExtensionRange::DescriptorProto_ExtensionRange()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void DescriptorProto_ExtensionRange::InitAsDefaultInstance() {}
  
  DescriptorProto_ExtensionRange::DescriptorProto_ExtensionRange(const DescriptorProto_ExtensionRange& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void DescriptorProto_ExtensionRange::SharedCtor() {
    _cached_size_ = 0;
    start_ = 0;
    end_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  DescriptorProto_ExtensionRange::~DescriptorProto_ExtensionRange() {
    SharedDtor();
  }
  
  void DescriptorProto_ExtensionRange::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  const ::google::protobuf::Descriptor* DescriptorProto_ExtensionRange::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return DescriptorProto_ExtensionRange_descriptor_;
  }
  
  const DescriptorProto_ExtensionRange& DescriptorProto_ExtensionRange::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  DescriptorProto_ExtensionRange* DescriptorProto_ExtensionRange::default_instance_ = NULL;
  
  DescriptorProto_ExtensionRange* DescriptorProto_ExtensionRange::New() const {
    return new DescriptorProto_ExtensionRange;
  }
  
  void DescriptorProto_ExtensionRange::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      start_ = 0;
      end_ = 0;
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool DescriptorProto_ExtensionRange::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // optional int32 start = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
          DO_(::google::protobuf::internal::WireFormat::ReadInt32(
                input, &start_));
          _set_bit(0);
          if (input->ExpectTag(16)) goto parse_end;
          break;
        }
        
        // optional int32 end = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_end:
          DO_(::google::protobuf::internal::WireFormat::ReadInt32(
                input, &end_));
          _set_bit(1);
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void DescriptorProto_ExtensionRange::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      DescriptorProto_ExtensionRange::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // optional int32 start = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteInt32(1, this->start(), output);
    }
    
    // optional int32 end = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::WriteInt32(2, this->end(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* DescriptorProto_ExtensionRange::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional int32 start = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteInt32ToArray(1, this->start(), target);
    }
    
    // optional int32 end = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormat::WriteInt32ToArray(2, this->end(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int DescriptorProto_ExtensionRange::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional int32 start = 1;
      if (has_start()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::Int32Size(
            this->start());
      }
      
      // optional int32 end = 2;
      if (has_end()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::Int32Size(
            this->end());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void DescriptorProto_ExtensionRange::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const DescriptorProto_ExtensionRange* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const DescriptorProto_ExtensionRange*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void DescriptorProto_ExtensionRange::MergeFrom(const DescriptorProto_ExtensionRange& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_start(from.start());
      }
      if (from._has_bit(1)) {
        set_end(from.end());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void DescriptorProto_ExtensionRange::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void DescriptorProto_ExtensionRange::CopyFrom(const DescriptorProto_ExtensionRange& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void DescriptorProto_ExtensionRange::Swap(DescriptorProto_ExtensionRange* other) {
    if (other != this) {
      std::swap(start_, other->start_);
      std::swap(end_, other->end_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  bool DescriptorProto_ExtensionRange::IsInitialized() const {
    
    return true;
  }
  
  const ::google::protobuf::Descriptor* DescriptorProto_ExtensionRange::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* DescriptorProto_ExtensionRange::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return DescriptorProto_ExtensionRange_reflection_;
  }
  
  // -------------------------------------------------------------------
  
  const ::std::string DescriptorProto::_default_name_;
  #ifndef _MSC_VER
  const int DescriptorProto::kNameFieldNumber;
  const int DescriptorProto::kFieldFieldNumber;
  const int DescriptorProto::kExtensionFieldNumber;
  const int DescriptorProto::kNestedTypeFieldNumber;
  const int DescriptorProto::kEnumTypeFieldNumber;
  const int DescriptorProto::kExtensionRangeFieldNumber;
  const int DescriptorProto::kOptionsFieldNumber;
  #endif  // !_MSC_VER
  
  DescriptorProto::DescriptorProto()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void DescriptorProto::InitAsDefaultInstance() {  options_ = const_cast< ::google::protobuf::MessageOptions*>(&::google::protobuf::MessageOptions::default_instance());
  }
  
  DescriptorProto::DescriptorProto(const DescriptorProto& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void DescriptorProto::SharedCtor() {
    _cached_size_ = 0;
    name_ = const_cast< ::std::string*>(&_default_name_);
    options_ = NULL;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  DescriptorProto::~DescriptorProto() {
    SharedDtor();
  }
  
  void DescriptorProto::SharedDtor() {
    if (name_ != &_default_name_) {
      delete name_;
    }
    if (this != default_instance_) {
      delete options_;
    }
  }
  
  const ::google::protobuf::Descriptor* DescriptorProto::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return DescriptorProto_descriptor_;
  }
  
  const DescriptorProto& DescriptorProto::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  DescriptorProto* DescriptorProto::default_instance_ = NULL;
  
  DescriptorProto* DescriptorProto::New() const {
    return new DescriptorProto;
  }
  
  void DescriptorProto::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (_has_bit(0)) {
        if (name_ != &_default_name_) {
          name_->clear();
        }
      }
      if (_has_bit(6)) {
        if (options_ != NULL) options_->::google::protobuf::MessageOptions::Clear();
      }
    }
    field_.Clear();
    extension_.Clear();
    nested_type_.Clear();
    enum_type_.Clear();
    extension_range_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool DescriptorProto::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // optional string name = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_name()));
          if (input->ExpectTag(18)) goto parse_field;
          break;
        }
        
        // repeated .google.protobuf.FieldDescriptorProto field = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_field:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_field()));
          if (input->ExpectTag(18)) goto parse_field;
          if (input->ExpectTag(26)) goto parse_nested_type;
          break;
        }
        
        // repeated .google.protobuf.DescriptorProto nested_type = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_nested_type:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_nested_type()));
          if (input->ExpectTag(26)) goto parse_nested_type;
          if (input->ExpectTag(34)) goto parse_enum_type;
          break;
        }
        
        // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_enum_type:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_enum_type()));
          if (input->ExpectTag(34)) goto parse_enum_type;
          if (input->ExpectTag(42)) goto parse_extension_range;
          break;
        }
        
        // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
        case 5: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_extension_range:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_extension_range()));
          if (input->ExpectTag(42)) goto parse_extension_range;
          if (input->ExpectTag(50)) goto parse_extension;
          break;
        }
        
        // repeated .google.protobuf.FieldDescriptorProto extension = 6;
        case 6: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_extension:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_extension()));
          if (input->ExpectTag(50)) goto parse_extension;
          if (input->ExpectTag(58)) goto parse_options;
          break;
        }
        
        // optional .google.protobuf.MessageOptions options = 7;
        case 7: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_options:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, mutable_options()));
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void DescriptorProto::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      DescriptorProto::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // optional string name = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteString(1, this->name(), output);
    }
    
    // repeated .google.protobuf.FieldDescriptorProto field = 2;
    for (int i = 0; i < this->field_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(2, this->field(i), output);
    }
    
    // repeated .google.protobuf.DescriptorProto nested_type = 3;
    for (int i = 0; i < this->nested_type_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(3, this->nested_type(i), output);
    }
    
    // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
    for (int i = 0; i < this->enum_type_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(4, this->enum_type(i), output);
    }
    
    // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
    for (int i = 0; i < this->extension_range_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(5, this->extension_range(i), output);
    }
    
    // repeated .google.protobuf.FieldDescriptorProto extension = 6;
    for (int i = 0; i < this->extension_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(6, this->extension(i), output);
    }
    
    // optional .google.protobuf.MessageOptions options = 7;
    if (_has_bit(6)) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(7, this->options(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* DescriptorProto::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional string name = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(1, this->name(), target);
    }
    
    // repeated .google.protobuf.FieldDescriptorProto field = 2;
    for (int i = 0; i < this->field_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(2, this->field(i), target);
    }
    
    // repeated .google.protobuf.DescriptorProto nested_type = 3;
    for (int i = 0; i < this->nested_type_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(3, this->nested_type(i), target);
    }
    
    // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
    for (int i = 0; i < this->enum_type_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(4, this->enum_type(i), target);
    }
    
    // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
    for (int i = 0; i < this->extension_range_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(5, this->extension_range(i), target);
    }
    
    // repeated .google.protobuf.FieldDescriptorProto extension = 6;
    for (int i = 0; i < this->extension_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(6, this->extension(i), target);
    }
    
    // optional .google.protobuf.MessageOptions options = 7;
    if (_has_bit(6)) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(7, this->options(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int DescriptorProto::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional string name = 1;
      if (has_name()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->name());
      }
      
      // optional .google.protobuf.MessageOptions options = 7;
      if (has_options()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
            this->options());
      }
      
    }
    // repeated .google.protobuf.FieldDescriptorProto field = 2;
    total_size += 1 * this->field_size();
    for (int i = 0; i < this->field_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->field(i));
    }
    
    // repeated .google.protobuf.FieldDescriptorProto extension = 6;
    total_size += 1 * this->extension_size();
    for (int i = 0; i < this->extension_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->extension(i));
    }
    
    // repeated .google.protobuf.DescriptorProto nested_type = 3;
    total_size += 1 * this->nested_type_size();
    for (int i = 0; i < this->nested_type_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->nested_type(i));
    }
    
    // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
    total_size += 1 * this->enum_type_size();
    for (int i = 0; i < this->enum_type_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->enum_type(i));
    }
    
    // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
    total_size += 1 * this->extension_range_size();
    for (int i = 0; i < this->extension_range_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->extension_range(i));
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void DescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const DescriptorProto* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const DescriptorProto*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void DescriptorProto::MergeFrom(const DescriptorProto& from) {
    GOOGLE_CHECK_NE(&from, this);
    field_.MergeFrom(from.field_);
    extension_.MergeFrom(from.extension_);
    nested_type_.MergeFrom(from.nested_type_);
    enum_type_.MergeFrom(from.enum_type_);
    extension_range_.MergeFrom(from.extension_range_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_name(from.name());
      }
      if (from._has_bit(6)) {
        mutable_options()->::google::protobuf::MessageOptions::MergeFrom(from.options());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void DescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void DescriptorProto::CopyFrom(const DescriptorProto& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void DescriptorProto::Swap(DescriptorProto* other) {
    if (other != this) {
      std::swap(name_, other->name_);
      field_.Swap(&other->field_);
      extension_.Swap(&other->extension_);
      nested_type_.Swap(&other->nested_type_);
      enum_type_.Swap(&other->enum_type_);
      extension_range_.Swap(&other->extension_range_);
      std::swap(options_, other->options_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  bool DescriptorProto::IsInitialized() const {
    
    for (int i = 0; i < field_size(); i++) {
      if (!this->field(i).IsInitialized()) return false;
    }
    for (int i = 0; i < extension_size(); i++) {
      if (!this->extension(i).IsInitialized()) return false;
    }
    for (int i = 0; i < nested_type_size(); i++) {
      if (!this->nested_type(i).IsInitialized()) return false;
    }
    for (int i = 0; i < enum_type_size(); i++) {
      if (!this->enum_type(i).IsInitialized()) return false;
    }
    if (has_options()) {
      if (!this->options().IsInitialized()) return false;
    }
    return true;
  }
  
  const ::google::protobuf::Descriptor* DescriptorProto::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* DescriptorProto::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return DescriptorProto_reflection_;
  }
  
  // ===================================================================
  
  const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Type_descriptor() {
    protobuf_AssignDescriptorsOnce();
    return FieldDescriptorProto_Type_descriptor_;
  }
  bool FieldDescriptorProto_Type_IsValid(int value) {
    switch(value) {
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
      case 8:
      case 9:
      case 10:
      case 11:
      case 12:
      case 13:
      case 14:
      case 15:
      case 16:
      case 17:
      case 18:
        return true;
      default:
        return false;
    }
  }
  
  #ifndef _MSC_VER
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_DOUBLE;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_FLOAT;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_INT64;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_UINT64;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_INT32;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_FIXED64;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_FIXED32;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_BOOL;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_STRING;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_GROUP;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_MESSAGE;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_BYTES;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_UINT32;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_ENUM;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_SFIXED32;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_SFIXED64;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_SINT32;
  const FieldDescriptorProto_Type FieldDescriptorProto::TYPE_SINT64;
  const FieldDescriptorProto_Type FieldDescriptorProto::Type_MIN;
  const FieldDescriptorProto_Type FieldDescriptorProto::Type_MAX;
  #endif  // _MSC_VER
  const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Label_descriptor() {
    protobuf_AssignDescriptorsOnce();
    return FieldDescriptorProto_Label_descriptor_;
  }
  bool FieldDescriptorProto_Label_IsValid(int value) {
    switch(value) {
      case 1:
      case 2:
      case 3:
        return true;
      default:
        return false;
    }
  }
  
  #ifndef _MSC_VER
  const FieldDescriptorProto_Label FieldDescriptorProto::LABEL_OPTIONAL;
  const FieldDescriptorProto_Label FieldDescriptorProto::LABEL_REQUIRED;
  const FieldDescriptorProto_Label FieldDescriptorProto::LABEL_REPEATED;
  const FieldDescriptorProto_Label FieldDescriptorProto::Label_MIN;
  const FieldDescriptorProto_Label FieldDescriptorProto::Label_MAX;
  #endif  // _MSC_VER
  const ::std::string FieldDescriptorProto::_default_name_;
  const ::std::string FieldDescriptorProto::_default_type_name_;
  const ::std::string FieldDescriptorProto::_default_extendee_;
  const ::std::string FieldDescriptorProto::_default_default_value_;
  #ifndef _MSC_VER
  const int FieldDescriptorProto::kNameFieldNumber;
  const int FieldDescriptorProto::kNumberFieldNumber;
  const int FieldDescriptorProto::kLabelFieldNumber;
  const int FieldDescriptorProto::kTypeFieldNumber;
  const int FieldDescriptorProto::kTypeNameFieldNumber;
  const int FieldDescriptorProto::kExtendeeFieldNumber;
  const int FieldDescriptorProto::kDefaultValueFieldNumber;
  const int FieldDescriptorProto::kOptionsFieldNumber;
  #endif  // !_MSC_VER
  
  FieldDescriptorProto::FieldDescriptorProto()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void FieldDescriptorProto::InitAsDefaultInstance() {  options_ = const_cast< ::google::protobuf::FieldOptions*>(&::google::protobuf::FieldOptions::default_instance());
  }
  
  FieldDescriptorProto::FieldDescriptorProto(const FieldDescriptorProto& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void FieldDescriptorProto::SharedCtor() {
    _cached_size_ = 0;
    name_ = const_cast< ::std::string*>(&_default_name_);
    number_ = 0;
    label_ = 1;
    type_ = 1;
    type_name_ = const_cast< ::std::string*>(&_default_type_name_);
    extendee_ = const_cast< ::std::string*>(&_default_extendee_);
    default_value_ = const_cast< ::std::string*>(&_default_default_value_);
    options_ = NULL;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  FieldDescriptorProto::~FieldDescriptorProto() {
    SharedDtor();
  }
  
  void FieldDescriptorProto::SharedDtor() {
    if (name_ != &_default_name_) {
      delete name_;
    }
    if (type_name_ != &_default_type_name_) {
      delete type_name_;
    }
    if (extendee_ != &_default_extendee_) {
      delete extendee_;
    }
    if (default_value_ != &_default_default_value_) {
      delete default_value_;
    }
    if (this != default_instance_) {
      delete options_;
    }
  }
  
  const ::google::protobuf::Descriptor* FieldDescriptorProto::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return FieldDescriptorProto_descriptor_;
  }
  
  const FieldDescriptorProto& FieldDescriptorProto::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  FieldDescriptorProto* FieldDescriptorProto::default_instance_ = NULL;
  
  FieldDescriptorProto* FieldDescriptorProto::New() const {
    return new FieldDescriptorProto;
  }
  
  void FieldDescriptorProto::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (_has_bit(0)) {
        if (name_ != &_default_name_) {
          name_->clear();
        }
      }
      number_ = 0;
      label_ = 1;
      type_ = 1;
      if (_has_bit(4)) {
        if (type_name_ != &_default_type_name_) {
          type_name_->clear();
        }
      }
      if (_has_bit(5)) {
        if (extendee_ != &_default_extendee_) {
          extendee_->clear();
        }
      }
      if (_has_bit(6)) {
        if (default_value_ != &_default_default_value_) {
          default_value_->clear();
        }
      }
      if (_has_bit(7)) {
        if (options_ != NULL) options_->::google::protobuf::FieldOptions::Clear();
      }
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool FieldDescriptorProto::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // optional string name = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_name()));
          if (input->ExpectTag(18)) goto parse_extendee;
          break;
        }
        
        // optional string extendee = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_extendee:
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_extendee()));
          if (input->ExpectTag(24)) goto parse_number;
          break;
        }
        
        // optional int32 number = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_number:
          DO_(::google::protobuf::internal::WireFormat::ReadInt32(
                input, &number_));
          _set_bit(1);
          if (input->ExpectTag(32)) goto parse_label;
          break;
        }
        
        // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_label:
          int value;
          DO_(::google::protobuf::internal::WireFormat::ReadEnum(input, &value));
          if (::google::protobuf::FieldDescriptorProto_Label_IsValid(value)) {
            set_label(static_cast< ::google::protobuf::FieldDescriptorProto_Label >(value));
          } else {
            mutable_unknown_fields()->AddVarint(4, value);
          }
          if (input->ExpectTag(40)) goto parse_type;
          break;
        }
        
        // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
        case 5: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_type:
          int value;
          DO_(::google::protobuf::internal::WireFormat::ReadEnum(input, &value));
          if (::google::protobuf::FieldDescriptorProto_Type_IsValid(value)) {
            set_type(static_cast< ::google::protobuf::FieldDescriptorProto_Type >(value));
          } else {
            mutable_unknown_fields()->AddVarint(5, value);
          }
          if (input->ExpectTag(50)) goto parse_type_name;
          break;
        }
        
        // optional string type_name = 6;
        case 6: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_type_name:
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_type_name()));
          if (input->ExpectTag(58)) goto parse_default_value;
          break;
        }
        
        // optional string default_value = 7;
        case 7: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_default_value:
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_default_value()));
          if (input->ExpectTag(66)) goto parse_options;
          break;
        }
        
        // optional .google.protobuf.FieldOptions options = 8;
        case 8: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_options:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, mutable_options()));
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void FieldDescriptorProto::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      FieldDescriptorProto::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // optional string name = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteString(1, this->name(), output);
    }
    
    // optional string extendee = 2;
    if (_has_bit(5)) {
      ::google::protobuf::internal::WireFormat::WriteString(2, this->extendee(), output);
    }
    
    // optional int32 number = 3;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::WriteInt32(3, this->number(), output);
    }
    
    // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormat::WriteEnum(4, this->label(), output);
    }
    
    // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
    if (_has_bit(3)) {
      ::google::protobuf::internal::WireFormat::WriteEnum(5, this->type(), output);
    }
    
    // optional string type_name = 6;
    if (_has_bit(4)) {
      ::google::protobuf::internal::WireFormat::WriteString(6, this->type_name(), output);
    }
    
    // optional string default_value = 7;
    if (_has_bit(6)) {
      ::google::protobuf::internal::WireFormat::WriteString(7, this->default_value(), output);
    }
    
    // optional .google.protobuf.FieldOptions options = 8;
    if (_has_bit(7)) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(8, this->options(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* FieldDescriptorProto::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional string name = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(1, this->name(), target);
    }
    
    // optional string extendee = 2;
    if (_has_bit(5)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(2, this->extendee(), target);
    }
    
    // optional int32 number = 3;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormat::WriteInt32ToArray(3, this->number(), target);
    }
    
    // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormat::WriteEnumToArray(4, this->label(), target);
    }
    
    // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
    if (_has_bit(3)) {
      target = ::google::protobuf::internal::WireFormat::WriteEnumToArray(5, this->type(), target);
    }
    
    // optional string type_name = 6;
    if (_has_bit(4)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(6, this->type_name(), target);
    }
    
    // optional string default_value = 7;
    if (_has_bit(6)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(7, this->default_value(), target);
    }
    
    // optional .google.protobuf.FieldOptions options = 8;
    if (_has_bit(7)) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(8, this->options(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int FieldDescriptorProto::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional string name = 1;
      if (has_name()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->name());
      }
      
      // optional int32 number = 3;
      if (has_number()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::Int32Size(
            this->number());
      }
      
      // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
      if (has_label()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::EnumSize(this->label());
      }
      
      // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
      if (has_type()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::EnumSize(this->type());
      }
      
      // optional string type_name = 6;
      if (has_type_name()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->type_name());
      }
      
      // optional string extendee = 2;
      if (has_extendee()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->extendee());
      }
      
      // optional string default_value = 7;
      if (has_default_value()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->default_value());
      }
      
      // optional .google.protobuf.FieldOptions options = 8;
      if (has_options()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
            this->options());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void FieldDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const FieldDescriptorProto* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const FieldDescriptorProto*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void FieldDescriptorProto::MergeFrom(const FieldDescriptorProto& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_name(from.name());
      }
      if (from._has_bit(1)) {
        set_number(from.number());
      }
      if (from._has_bit(2)) {
        set_label(from.label());
      }
      if (from._has_bit(3)) {
        set_type(from.type());
      }
      if (from._has_bit(4)) {
        set_type_name(from.type_name());
      }
      if (from._has_bit(5)) {
        set_extendee(from.extendee());
      }
      if (from._has_bit(6)) {
        set_default_value(from.default_value());
      }
      if (from._has_bit(7)) {
        mutable_options()->::google::protobuf::FieldOptions::MergeFrom(from.options());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void FieldDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void FieldDescriptorProto::CopyFrom(const FieldDescriptorProto& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void FieldDescriptorProto::Swap(FieldDescriptorProto* other) {
    if (other != this) {
      std::swap(name_, other->name_);
      std::swap(number_, other->number_);
      std::swap(label_, other->label_);
      std::swap(type_, other->type_);
      std::swap(type_name_, other->type_name_);
      std::swap(extendee_, other->extendee_);
      std::swap(default_value_, other->default_value_);
      std::swap(options_, other->options_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  bool FieldDescriptorProto::IsInitialized() const {
    
    if (has_options()) {
      if (!this->options().IsInitialized()) return false;
    }
    return true;
  }
  
  const ::google::protobuf::Descriptor* FieldDescriptorProto::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* FieldDescriptorProto::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return FieldDescriptorProto_reflection_;
  }
  
  // ===================================================================
  
  const ::std::string EnumDescriptorProto::_default_name_;
  #ifndef _MSC_VER
  const int EnumDescriptorProto::kNameFieldNumber;
  const int EnumDescriptorProto::kValueFieldNumber;
  const int EnumDescriptorProto::kOptionsFieldNumber;
  #endif  // !_MSC_VER
  
  EnumDescriptorProto::EnumDescriptorProto()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void EnumDescriptorProto::InitAsDefaultInstance() {  options_ = const_cast< ::google::protobuf::EnumOptions*>(&::google::protobuf::EnumOptions::default_instance());
  }
  
  EnumDescriptorProto::EnumDescriptorProto(const EnumDescriptorProto& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void EnumDescriptorProto::SharedCtor() {
    _cached_size_ = 0;
    name_ = const_cast< ::std::string*>(&_default_name_);
    options_ = NULL;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  EnumDescriptorProto::~EnumDescriptorProto() {
    SharedDtor();
  }
  
  void EnumDescriptorProto::SharedDtor() {
    if (name_ != &_default_name_) {
      delete name_;
    }
    if (this != default_instance_) {
      delete options_;
    }
  }
  
  const ::google::protobuf::Descriptor* EnumDescriptorProto::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return EnumDescriptorProto_descriptor_;
  }
  
  const EnumDescriptorProto& EnumDescriptorProto::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  EnumDescriptorProto* EnumDescriptorProto::default_instance_ = NULL;
  
  EnumDescriptorProto* EnumDescriptorProto::New() const {
    return new EnumDescriptorProto;
  }
  
  void EnumDescriptorProto::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (_has_bit(0)) {
        if (name_ != &_default_name_) {
          name_->clear();
        }
      }
      if (_has_bit(2)) {
        if (options_ != NULL) options_->::google::protobuf::EnumOptions::Clear();
      }
    }
    value_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool EnumDescriptorProto::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // optional string name = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_name()));
          if (input->ExpectTag(18)) goto parse_value;
          break;
        }
        
        // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_value:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_value()));
          if (input->ExpectTag(18)) goto parse_value;
          if (input->ExpectTag(26)) goto parse_options;
          break;
        }
        
        // optional .google.protobuf.EnumOptions options = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_options:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, mutable_options()));
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void EnumDescriptorProto::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      EnumDescriptorProto::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // optional string name = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteString(1, this->name(), output);
    }
    
    // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
    for (int i = 0; i < this->value_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(2, this->value(i), output);
    }
    
    // optional .google.protobuf.EnumOptions options = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(3, this->options(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* EnumDescriptorProto::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional string name = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(1, this->name(), target);
    }
    
    // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
    for (int i = 0; i < this->value_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(2, this->value(i), target);
    }
    
    // optional .google.protobuf.EnumOptions options = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(3, this->options(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int EnumDescriptorProto::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional string name = 1;
      if (has_name()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->name());
      }
      
      // optional .google.protobuf.EnumOptions options = 3;
      if (has_options()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
            this->options());
      }
      
    }
    // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
    total_size += 1 * this->value_size();
    for (int i = 0; i < this->value_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->value(i));
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void EnumDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const EnumDescriptorProto* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const EnumDescriptorProto*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void EnumDescriptorProto::MergeFrom(const EnumDescriptorProto& from) {
    GOOGLE_CHECK_NE(&from, this);
    value_.MergeFrom(from.value_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_name(from.name());
      }
      if (from._has_bit(2)) {
        mutable_options()->::google::protobuf::EnumOptions::MergeFrom(from.options());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void EnumDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void EnumDescriptorProto::CopyFrom(const EnumDescriptorProto& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void EnumDescriptorProto::Swap(EnumDescriptorProto* other) {
    if (other != this) {
      std::swap(name_, other->name_);
      value_.Swap(&other->value_);
      std::swap(options_, other->options_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  bool EnumDescriptorProto::IsInitialized() const {
    
    for (int i = 0; i < value_size(); i++) {
      if (!this->value(i).IsInitialized()) return false;
    }
    if (has_options()) {
      if (!this->options().IsInitialized()) return false;
    }
    return true;
  }
  
  const ::google::protobuf::Descriptor* EnumDescriptorProto::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* EnumDescriptorProto::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return EnumDescriptorProto_reflection_;
  }
  
  // ===================================================================
  
  const ::std::string EnumValueDescriptorProto::_default_name_;
  #ifndef _MSC_VER
  const int EnumValueDescriptorProto::kNameFieldNumber;
  const int EnumValueDescriptorProto::kNumberFieldNumber;
  const int EnumValueDescriptorProto::kOptionsFieldNumber;
  #endif  // !_MSC_VER
  
  EnumValueDescriptorProto::EnumValueDescriptorProto()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void EnumValueDescriptorProto::InitAsDefaultInstance() {  options_ = const_cast< ::google::protobuf::EnumValueOptions*>(&::google::protobuf::EnumValueOptions::default_instance());
  }
  
  EnumValueDescriptorProto::EnumValueDescriptorProto(const EnumValueDescriptorProto& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void EnumValueDescriptorProto::SharedCtor() {
    _cached_size_ = 0;
    name_ = const_cast< ::std::string*>(&_default_name_);
    number_ = 0;
    options_ = NULL;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  EnumValueDescriptorProto::~EnumValueDescriptorProto() {
    SharedDtor();
  }
  
  void EnumValueDescriptorProto::SharedDtor() {
    if (name_ != &_default_name_) {
      delete name_;
    }
    if (this != default_instance_) {
      delete options_;
    }
  }
  
  const ::google::protobuf::Descriptor* EnumValueDescriptorProto::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return EnumValueDescriptorProto_descriptor_;
  }
  
  const EnumValueDescriptorProto& EnumValueDescriptorProto::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  EnumValueDescriptorProto* EnumValueDescriptorProto::default_instance_ = NULL;
  
  EnumValueDescriptorProto* EnumValueDescriptorProto::New() const {
    return new EnumValueDescriptorProto;
  }
  
  void EnumValueDescriptorProto::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (_has_bit(0)) {
        if (name_ != &_default_name_) {
          name_->clear();
        }
      }
      number_ = 0;
      if (_has_bit(2)) {
        if (options_ != NULL) options_->::google::protobuf::EnumValueOptions::Clear();
      }
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool EnumValueDescriptorProto::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // optional string name = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_name()));
          if (input->ExpectTag(16)) goto parse_number;
          break;
        }
        
        // optional int32 number = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_number:
          DO_(::google::protobuf::internal::WireFormat::ReadInt32(
                input, &number_));
          _set_bit(1);
          if (input->ExpectTag(26)) goto parse_options;
          break;
        }
        
        // optional .google.protobuf.EnumValueOptions options = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_options:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, mutable_options()));
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void EnumValueDescriptorProto::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      EnumValueDescriptorProto::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // optional string name = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteString(1, this->name(), output);
    }
    
    // optional int32 number = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::WriteInt32(2, this->number(), output);
    }
    
    // optional .google.protobuf.EnumValueOptions options = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(3, this->options(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* EnumValueDescriptorProto::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional string name = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(1, this->name(), target);
    }
    
    // optional int32 number = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormat::WriteInt32ToArray(2, this->number(), target);
    }
    
    // optional .google.protobuf.EnumValueOptions options = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(3, this->options(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int EnumValueDescriptorProto::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional string name = 1;
      if (has_name()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->name());
      }
      
      // optional int32 number = 2;
      if (has_number()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::Int32Size(
            this->number());
      }
      
      // optional .google.protobuf.EnumValueOptions options = 3;
      if (has_options()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
            this->options());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void EnumValueDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const EnumValueDescriptorProto* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const EnumValueDescriptorProto*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void EnumValueDescriptorProto::MergeFrom(const EnumValueDescriptorProto& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_name(from.name());
      }
      if (from._has_bit(1)) {
        set_number(from.number());
      }
      if (from._has_bit(2)) {
        mutable_options()->::google::protobuf::EnumValueOptions::MergeFrom(from.options());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void EnumValueDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void EnumValueDescriptorProto::CopyFrom(const EnumValueDescriptorProto& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void EnumValueDescriptorProto::Swap(EnumValueDescriptorProto* other) {
    if (other != this) {
      std::swap(name_, other->name_);
      std::swap(number_, other->number_);
      std::swap(options_, other->options_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  bool EnumValueDescriptorProto::IsInitialized() const {
    
    if (has_options()) {
      if (!this->options().IsInitialized()) return false;
    }
    return true;
  }
  
  const ::google::protobuf::Descriptor* EnumValueDescriptorProto::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* EnumValueDescriptorProto::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return EnumValueDescriptorProto_reflection_;
  }
  
  // ===================================================================
  
  const ::std::string ServiceDescriptorProto::_default_name_;
  #ifndef _MSC_VER
  const int ServiceDescriptorProto::kNameFieldNumber;
  const int ServiceDescriptorProto::kMethodFieldNumber;
  const int ServiceDescriptorProto::kOptionsFieldNumber;
  #endif  // !_MSC_VER
  
  ServiceDescriptorProto::ServiceDescriptorProto()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void ServiceDescriptorProto::InitAsDefaultInstance() {  options_ = const_cast< ::google::protobuf::ServiceOptions*>(&::google::protobuf::ServiceOptions::default_instance());
  }
  
  ServiceDescriptorProto::ServiceDescriptorProto(const ServiceDescriptorProto& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void ServiceDescriptorProto::SharedCtor() {
    _cached_size_ = 0;
    name_ = const_cast< ::std::string*>(&_default_name_);
    options_ = NULL;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  ServiceDescriptorProto::~ServiceDescriptorProto() {
    SharedDtor();
  }
  
  void ServiceDescriptorProto::SharedDtor() {
    if (name_ != &_default_name_) {
      delete name_;
    }
    if (this != default_instance_) {
      delete options_;
    }
  }
  
  const ::google::protobuf::Descriptor* ServiceDescriptorProto::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return ServiceDescriptorProto_descriptor_;
  }
  
  const ServiceDescriptorProto& ServiceDescriptorProto::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  ServiceDescriptorProto* ServiceDescriptorProto::default_instance_ = NULL;
  
  ServiceDescriptorProto* ServiceDescriptorProto::New() const {
    return new ServiceDescriptorProto;
  }
  
  void ServiceDescriptorProto::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (_has_bit(0)) {
        if (name_ != &_default_name_) {
          name_->clear();
        }
      }
      if (_has_bit(2)) {
        if (options_ != NULL) options_->::google::protobuf::ServiceOptions::Clear();
      }
    }
    method_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool ServiceDescriptorProto::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // optional string name = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_name()));
          if (input->ExpectTag(18)) goto parse_method;
          break;
        }
        
        // repeated .google.protobuf.MethodDescriptorProto method = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_method:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_method()));
          if (input->ExpectTag(18)) goto parse_method;
          if (input->ExpectTag(26)) goto parse_options;
          break;
        }
        
        // optional .google.protobuf.ServiceOptions options = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_options:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, mutable_options()));
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void ServiceDescriptorProto::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      ServiceDescriptorProto::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // optional string name = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteString(1, this->name(), output);
    }
    
    // repeated .google.protobuf.MethodDescriptorProto method = 2;
    for (int i = 0; i < this->method_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(2, this->method(i), output);
    }
    
    // optional .google.protobuf.ServiceOptions options = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(3, this->options(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* ServiceDescriptorProto::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional string name = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(1, this->name(), target);
    }
    
    // repeated .google.protobuf.MethodDescriptorProto method = 2;
    for (int i = 0; i < this->method_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(2, this->method(i), target);
    }
    
    // optional .google.protobuf.ServiceOptions options = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(3, this->options(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int ServiceDescriptorProto::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional string name = 1;
      if (has_name()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->name());
      }
      
      // optional .google.protobuf.ServiceOptions options = 3;
      if (has_options()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
            this->options());
      }
      
    }
    // repeated .google.protobuf.MethodDescriptorProto method = 2;
    total_size += 1 * this->method_size();
    for (int i = 0; i < this->method_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->method(i));
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void ServiceDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const ServiceDescriptorProto* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const ServiceDescriptorProto*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void ServiceDescriptorProto::MergeFrom(const ServiceDescriptorProto& from) {
    GOOGLE_CHECK_NE(&from, this);
    method_.MergeFrom(from.method_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_name(from.name());
      }
      if (from._has_bit(2)) {
        mutable_options()->::google::protobuf::ServiceOptions::MergeFrom(from.options());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void ServiceDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void ServiceDescriptorProto::CopyFrom(const ServiceDescriptorProto& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void ServiceDescriptorProto::Swap(ServiceDescriptorProto* other) {
    if (other != this) {
      std::swap(name_, other->name_);
      method_.Swap(&other->method_);
      std::swap(options_, other->options_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  bool ServiceDescriptorProto::IsInitialized() const {
    
    for (int i = 0; i < method_size(); i++) {
      if (!this->method(i).IsInitialized()) return false;
    }
    if (has_options()) {
      if (!this->options().IsInitialized()) return false;
    }
    return true;
  }
  
  const ::google::protobuf::Descriptor* ServiceDescriptorProto::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* ServiceDescriptorProto::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return ServiceDescriptorProto_reflection_;
  }
  
  // ===================================================================
  
  const ::std::string MethodDescriptorProto::_default_name_;
  const ::std::string MethodDescriptorProto::_default_input_type_;
  const ::std::string MethodDescriptorProto::_default_output_type_;
  #ifndef _MSC_VER
  const int MethodDescriptorProto::kNameFieldNumber;
  const int MethodDescriptorProto::kInputTypeFieldNumber;
  const int MethodDescriptorProto::kOutputTypeFieldNumber;
  const int MethodDescriptorProto::kOptionsFieldNumber;
  #endif  // !_MSC_VER
  
  MethodDescriptorProto::MethodDescriptorProto()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void MethodDescriptorProto::InitAsDefaultInstance() {  options_ = const_cast< ::google::protobuf::MethodOptions*>(&::google::protobuf::MethodOptions::default_instance());
  }
  
  MethodDescriptorProto::MethodDescriptorProto(const MethodDescriptorProto& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void MethodDescriptorProto::SharedCtor() {
    _cached_size_ = 0;
    name_ = const_cast< ::std::string*>(&_default_name_);
    input_type_ = const_cast< ::std::string*>(&_default_input_type_);
    output_type_ = const_cast< ::std::string*>(&_default_output_type_);
    options_ = NULL;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  MethodDescriptorProto::~MethodDescriptorProto() {
    SharedDtor();
  }
  
  void MethodDescriptorProto::SharedDtor() {
    if (name_ != &_default_name_) {
      delete name_;
    }
    if (input_type_ != &_default_input_type_) {
      delete input_type_;
    }
    if (output_type_ != &_default_output_type_) {
      delete output_type_;
    }
    if (this != default_instance_) {
      delete options_;
    }
  }
  
  const ::google::protobuf::Descriptor* MethodDescriptorProto::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return MethodDescriptorProto_descriptor_;
  }
  
  const MethodDescriptorProto& MethodDescriptorProto::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  MethodDescriptorProto* MethodDescriptorProto::default_instance_ = NULL;
  
  MethodDescriptorProto* MethodDescriptorProto::New() const {
    return new MethodDescriptorProto;
  }
  
  void MethodDescriptorProto::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (_has_bit(0)) {
        if (name_ != &_default_name_) {
          name_->clear();
        }
      }
      if (_has_bit(1)) {
        if (input_type_ != &_default_input_type_) {
          input_type_->clear();
        }
      }
      if (_has_bit(2)) {
        if (output_type_ != &_default_output_type_) {
          output_type_->clear();
        }
      }
      if (_has_bit(3)) {
        if (options_ != NULL) options_->::google::protobuf::MethodOptions::Clear();
      }
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool MethodDescriptorProto::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // optional string name = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_name()));
          if (input->ExpectTag(18)) goto parse_input_type;
          break;
        }
        
        // optional string input_type = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_input_type:
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_input_type()));
          if (input->ExpectTag(26)) goto parse_output_type;
          break;
        }
        
        // optional string output_type = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_output_type:
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_output_type()));
          if (input->ExpectTag(34)) goto parse_options;
          break;
        }
        
        // optional .google.protobuf.MethodOptions options = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_options:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, mutable_options()));
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void MethodDescriptorProto::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      MethodDescriptorProto::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // optional string name = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteString(1, this->name(), output);
    }
    
    // optional string input_type = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::WriteString(2, this->input_type(), output);
    }
    
    // optional string output_type = 3;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormat::WriteString(3, this->output_type(), output);
    }
    
    // optional .google.protobuf.MethodOptions options = 4;
    if (_has_bit(3)) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(4, this->options(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* MethodDescriptorProto::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional string name = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(1, this->name(), target);
    }
    
    // optional string input_type = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(2, this->input_type(), target);
    }
    
    // optional string output_type = 3;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(3, this->output_type(), target);
    }
    
    // optional .google.protobuf.MethodOptions options = 4;
    if (_has_bit(3)) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(4, this->options(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int MethodDescriptorProto::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional string name = 1;
      if (has_name()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->name());
      }
      
      // optional string input_type = 2;
      if (has_input_type()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->input_type());
      }
      
      // optional string output_type = 3;
      if (has_output_type()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->output_type());
      }
      
      // optional .google.protobuf.MethodOptions options = 4;
      if (has_options()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
            this->options());
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void MethodDescriptorProto::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const MethodDescriptorProto* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const MethodDescriptorProto*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void MethodDescriptorProto::MergeFrom(const MethodDescriptorProto& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_name(from.name());
      }
      if (from._has_bit(1)) {
        set_input_type(from.input_type());
      }
      if (from._has_bit(2)) {
        set_output_type(from.output_type());
      }
      if (from._has_bit(3)) {
        mutable_options()->::google::protobuf::MethodOptions::MergeFrom(from.options());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void MethodDescriptorProto::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void MethodDescriptorProto::CopyFrom(const MethodDescriptorProto& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void MethodDescriptorProto::Swap(MethodDescriptorProto* other) {
    if (other != this) {
      std::swap(name_, other->name_);
      std::swap(input_type_, other->input_type_);
      std::swap(output_type_, other->output_type_);
      std::swap(options_, other->options_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  bool MethodDescriptorProto::IsInitialized() const {
    
    if (has_options()) {
      if (!this->options().IsInitialized()) return false;
    }
    return true;
  }
  
  const ::google::protobuf::Descriptor* MethodDescriptorProto::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* MethodDescriptorProto::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return MethodDescriptorProto_reflection_;
  }
  
  // ===================================================================
  
  const ::google::protobuf::EnumDescriptor* FileOptions_OptimizeMode_descriptor() {
    protobuf_AssignDescriptorsOnce();
    return FileOptions_OptimizeMode_descriptor_;
  }
  bool FileOptions_OptimizeMode_IsValid(int value) {
    switch(value) {
      case 1:
      case 2:
        return true;
      default:
        return false;
    }
  }
  
  #ifndef _MSC_VER
  const FileOptions_OptimizeMode FileOptions::SPEED;
  const FileOptions_OptimizeMode FileOptions::CODE_SIZE;
  const FileOptions_OptimizeMode FileOptions::OptimizeMode_MIN;
  const FileOptions_OptimizeMode FileOptions::OptimizeMode_MAX;
  #endif  // _MSC_VER
  const ::std::string FileOptions::_default_java_package_;
  const ::std::string FileOptions::_default_java_outer_classname_;
  #ifndef _MSC_VER
  const int FileOptions::kJavaPackageFieldNumber;
  const int FileOptions::kJavaOuterClassnameFieldNumber;
  const int FileOptions::kJavaMultipleFilesFieldNumber;
  const int FileOptions::kOptimizeForFieldNumber;
  const int FileOptions::kUninterpretedOptionFieldNumber;
  #endif  // !_MSC_VER
  
  FileOptions::FileOptions()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void FileOptions::InitAsDefaultInstance() {}
  
  FileOptions::FileOptions(const FileOptions& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void FileOptions::SharedCtor() {
    _cached_size_ = 0;
    java_package_ = const_cast< ::std::string*>(&_default_java_package_);
    java_outer_classname_ = const_cast< ::std::string*>(&_default_java_outer_classname_);
    java_multiple_files_ = false;
    optimize_for_ = 1;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  FileOptions::~FileOptions() {
    SharedDtor();
  }
  
  void FileOptions::SharedDtor() {
    if (java_package_ != &_default_java_package_) {
      delete java_package_;
    }
    if (java_outer_classname_ != &_default_java_outer_classname_) {
      delete java_outer_classname_;
    }
    if (this != default_instance_) {
    }
  }
  
  const ::google::protobuf::Descriptor* FileOptions::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return FileOptions_descriptor_;
  }
  
  const FileOptions& FileOptions::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  FileOptions* FileOptions::default_instance_ = NULL;
  
  FileOptions* FileOptions::New() const {
    return new FileOptions;
  }
  
  void FileOptions::Clear() {
    _extensions_.Clear();
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (_has_bit(0)) {
        if (java_package_ != &_default_java_package_) {
          java_package_->clear();
        }
      }
      if (_has_bit(1)) {
        if (java_outer_classname_ != &_default_java_outer_classname_) {
          java_outer_classname_->clear();
        }
      }
      java_multiple_files_ = false;
      optimize_for_ = 1;
    }
    uninterpreted_option_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool FileOptions::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // optional string java_package = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_java_package()));
          if (input->ExpectTag(66)) goto parse_java_outer_classname;
          break;
        }
        
        // optional string java_outer_classname = 8;
        case 8: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_java_outer_classname:
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_java_outer_classname()));
          if (input->ExpectTag(72)) goto parse_optimize_for;
          break;
        }
        
        // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
        case 9: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_optimize_for:
          int value;
          DO_(::google::protobuf::internal::WireFormat::ReadEnum(input, &value));
          if (::google::protobuf::FileOptions_OptimizeMode_IsValid(value)) {
            set_optimize_for(static_cast< ::google::protobuf::FileOptions_OptimizeMode >(value));
          } else {
            mutable_unknown_fields()->AddVarint(9, value);
          }
          if (input->ExpectTag(80)) goto parse_java_multiple_files;
          break;
        }
        
        // optional bool java_multiple_files = 10 [default = false];
        case 10: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_java_multiple_files:
          DO_(::google::protobuf::internal::WireFormat::ReadBool(
                input, &java_multiple_files_));
          _set_bit(2);
          if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
          break;
        }
        
        // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
        case 999: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_uninterpreted_option:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_uninterpreted_option()));
          if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          if ((8000u <= tag)) {
            DO_(_extensions_.ParseField(tag, input, default_instance_,
                                        mutable_unknown_fields()));
            continue;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void FileOptions::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      FileOptions::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // optional string java_package = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteString(1, this->java_package(), output);
    }
    
    // optional string java_outer_classname = 8;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::WriteString(8, this->java_outer_classname(), output);
    }
    
    // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
    if (_has_bit(3)) {
      ::google::protobuf::internal::WireFormat::WriteEnum(9, this->optimize_for(), output);
    }
    
    // optional bool java_multiple_files = 10 [default = false];
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormat::WriteBool(10, this->java_multiple_files(), output);
    }
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(999, this->uninterpreted_option(i), output);
    }
    
    // Extension range [1000, 536870912)
    _extensions_.SerializeWithCachedSizes(
        1000, 536870912, output);
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* FileOptions::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional string java_package = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(1, this->java_package(), target);
    }
    
    // optional string java_outer_classname = 8;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(8, this->java_outer_classname(), target);
    }
    
    // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
    if (_has_bit(3)) {
      target = ::google::protobuf::internal::WireFormat::WriteEnumToArray(9, this->optimize_for(), target);
    }
    
    // optional bool java_multiple_files = 10 [default = false];
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormat::WriteBoolToArray(10, this->java_multiple_files(), target);
    }
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(999, this->uninterpreted_option(i), target);
    }
    
    // Extension range [1000, 536870912)
    target = _extensions_.SerializeWithCachedSizesToArray(
        1000, 536870912, target);
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int FileOptions::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional string java_package = 1;
      if (has_java_package()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->java_package());
      }
      
      // optional string java_outer_classname = 8;
      if (has_java_outer_classname()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->java_outer_classname());
      }
      
      // optional bool java_multiple_files = 10 [default = false];
      if (has_java_multiple_files()) {
        total_size += 1 + 1;
      }
      
      // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
      if (has_optimize_for()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::EnumSize(this->optimize_for());
      }
      
    }
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    total_size += 2 * this->uninterpreted_option_size();
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->uninterpreted_option(i));
    }
    
    total_size += _extensions_.ByteSize();
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void FileOptions::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const FileOptions* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const FileOptions*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void FileOptions::MergeFrom(const FileOptions& from) {
    GOOGLE_CHECK_NE(&from, this);
    uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_java_package(from.java_package());
      }
      if (from._has_bit(1)) {
        set_java_outer_classname(from.java_outer_classname());
      }
      if (from._has_bit(2)) {
        set_java_multiple_files(from.java_multiple_files());
      }
      if (from._has_bit(3)) {
        set_optimize_for(from.optimize_for());
      }
    }
    _extensions_.MergeFrom(from._extensions_);
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void FileOptions::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void FileOptions::CopyFrom(const FileOptions& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void FileOptions::Swap(FileOptions* other) {
    if (other != this) {
      std::swap(java_package_, other->java_package_);
      std::swap(java_outer_classname_, other->java_outer_classname_);
      std::swap(java_multiple_files_, other->java_multiple_files_);
      std::swap(optimize_for_, other->optimize_for_);
      uninterpreted_option_.Swap(&other->uninterpreted_option_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
      _extensions_.Swap(&other->_extensions_);
    }
  }
  
  bool FileOptions::IsInitialized() const {
    
    for (int i = 0; i < uninterpreted_option_size(); i++) {
      if (!this->uninterpreted_option(i).IsInitialized()) return false;
    }
    
    if (!_extensions_.IsInitialized()) return false;  return true;
  }
  
  const ::google::protobuf::Descriptor* FileOptions::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* FileOptions::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return FileOptions_reflection_;
  }
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int MessageOptions::kMessageSetWireFormatFieldNumber;
  const int MessageOptions::kUninterpretedOptionFieldNumber;
  #endif  // !_MSC_VER
  
  MessageOptions::MessageOptions()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void MessageOptions::InitAsDefaultInstance() {}
  
  MessageOptions::MessageOptions(const MessageOptions& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void MessageOptions::SharedCtor() {
    _cached_size_ = 0;
    message_set_wire_format_ = false;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  MessageOptions::~MessageOptions() {
    SharedDtor();
  }
  
  void MessageOptions::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  const ::google::protobuf::Descriptor* MessageOptions::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return MessageOptions_descriptor_;
  }
  
  const MessageOptions& MessageOptions::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  MessageOptions* MessageOptions::default_instance_ = NULL;
  
  MessageOptions* MessageOptions::New() const {
    return new MessageOptions;
  }
  
  void MessageOptions::Clear() {
    _extensions_.Clear();
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      message_set_wire_format_ = false;
    }
    uninterpreted_option_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool MessageOptions::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // optional bool message_set_wire_format = 1 [default = false];
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
          DO_(::google::protobuf::internal::WireFormat::ReadBool(
                input, &message_set_wire_format_));
          _set_bit(0);
          if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
          break;
        }
        
        // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
        case 999: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_uninterpreted_option:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_uninterpreted_option()));
          if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          if ((8000u <= tag)) {
            DO_(_extensions_.ParseField(tag, input, default_instance_,
                                        mutable_unknown_fields()));
            continue;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void MessageOptions::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      MessageOptions::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // optional bool message_set_wire_format = 1 [default = false];
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteBool(1, this->message_set_wire_format(), output);
    }
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(999, this->uninterpreted_option(i), output);
    }
    
    // Extension range [1000, 536870912)
    _extensions_.SerializeWithCachedSizes(
        1000, 536870912, output);
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* MessageOptions::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional bool message_set_wire_format = 1 [default = false];
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteBoolToArray(1, this->message_set_wire_format(), target);
    }
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(999, this->uninterpreted_option(i), target);
    }
    
    // Extension range [1000, 536870912)
    target = _extensions_.SerializeWithCachedSizesToArray(
        1000, 536870912, target);
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int MessageOptions::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional bool message_set_wire_format = 1 [default = false];
      if (has_message_set_wire_format()) {
        total_size += 1 + 1;
      }
      
    }
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    total_size += 2 * this->uninterpreted_option_size();
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->uninterpreted_option(i));
    }
    
    total_size += _extensions_.ByteSize();
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void MessageOptions::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const MessageOptions* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const MessageOptions*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void MessageOptions::MergeFrom(const MessageOptions& from) {
    GOOGLE_CHECK_NE(&from, this);
    uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_message_set_wire_format(from.message_set_wire_format());
      }
    }
    _extensions_.MergeFrom(from._extensions_);
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void MessageOptions::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void MessageOptions::CopyFrom(const MessageOptions& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void MessageOptions::Swap(MessageOptions* other) {
    if (other != this) {
      std::swap(message_set_wire_format_, other->message_set_wire_format_);
      uninterpreted_option_.Swap(&other->uninterpreted_option_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
      _extensions_.Swap(&other->_extensions_);
    }
  }
  
  bool MessageOptions::IsInitialized() const {
    
    for (int i = 0; i < uninterpreted_option_size(); i++) {
      if (!this->uninterpreted_option(i).IsInitialized()) return false;
    }
    
    if (!_extensions_.IsInitialized()) return false;  return true;
  }
  
  const ::google::protobuf::Descriptor* MessageOptions::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* MessageOptions::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return MessageOptions_reflection_;
  }
  
  // ===================================================================
  
  const ::google::protobuf::EnumDescriptor* FieldOptions_CType_descriptor() {
    protobuf_AssignDescriptorsOnce();
    return FieldOptions_CType_descriptor_;
  }
  bool FieldOptions_CType_IsValid(int value) {
    switch(value) {
      case 1:
      case 2:
        return true;
      default:
        return false;
    }
  }
  
  #ifndef _MSC_VER
  const FieldOptions_CType FieldOptions::CORD;
  const FieldOptions_CType FieldOptions::STRING_PIECE;
  const FieldOptions_CType FieldOptions::CType_MIN;
  const FieldOptions_CType FieldOptions::CType_MAX;
  #endif  // _MSC_VER
  const ::std::string FieldOptions::_default_experimental_map_key_;
  #ifndef _MSC_VER
  const int FieldOptions::kCtypeFieldNumber;
  const int FieldOptions::kPackedFieldNumber;
  const int FieldOptions::kDeprecatedFieldNumber;
  const int FieldOptions::kExperimentalMapKeyFieldNumber;
  const int FieldOptions::kUninterpretedOptionFieldNumber;
  #endif  // !_MSC_VER
  
  FieldOptions::FieldOptions()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void FieldOptions::InitAsDefaultInstance() {}
  
  FieldOptions::FieldOptions(const FieldOptions& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void FieldOptions::SharedCtor() {
    _cached_size_ = 0;
    ctype_ = 1;
    packed_ = false;
    deprecated_ = false;
    experimental_map_key_ = const_cast< ::std::string*>(&_default_experimental_map_key_);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  FieldOptions::~FieldOptions() {
    SharedDtor();
  }
  
  void FieldOptions::SharedDtor() {
    if (experimental_map_key_ != &_default_experimental_map_key_) {
      delete experimental_map_key_;
    }
    if (this != default_instance_) {
    }
  }
  
  const ::google::protobuf::Descriptor* FieldOptions::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return FieldOptions_descriptor_;
  }
  
  const FieldOptions& FieldOptions::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  FieldOptions* FieldOptions::default_instance_ = NULL;
  
  FieldOptions* FieldOptions::New() const {
    return new FieldOptions;
  }
  
  void FieldOptions::Clear() {
    _extensions_.Clear();
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      ctype_ = 1;
      packed_ = false;
      deprecated_ = false;
      if (_has_bit(3)) {
        if (experimental_map_key_ != &_default_experimental_map_key_) {
          experimental_map_key_->clear();
        }
      }
    }
    uninterpreted_option_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool FieldOptions::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // optional .google.protobuf.FieldOptions.CType ctype = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
          int value;
          DO_(::google::protobuf::internal::WireFormat::ReadEnum(input, &value));
          if (::google::protobuf::FieldOptions_CType_IsValid(value)) {
            set_ctype(static_cast< ::google::protobuf::FieldOptions_CType >(value));
          } else {
            mutable_unknown_fields()->AddVarint(1, value);
          }
          if (input->ExpectTag(16)) goto parse_packed;
          break;
        }
        
        // optional bool packed = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_packed:
          DO_(::google::protobuf::internal::WireFormat::ReadBool(
                input, &packed_));
          _set_bit(1);
          if (input->ExpectTag(24)) goto parse_deprecated;
          break;
        }
        
        // optional bool deprecated = 3 [default = false];
        case 3: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_deprecated:
          DO_(::google::protobuf::internal::WireFormat::ReadBool(
                input, &deprecated_));
          _set_bit(2);
          if (input->ExpectTag(74)) goto parse_experimental_map_key;
          break;
        }
        
        // optional string experimental_map_key = 9;
        case 9: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_experimental_map_key:
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_experimental_map_key()));
          if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
          break;
        }
        
        // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
        case 999: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_uninterpreted_option:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_uninterpreted_option()));
          if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          if ((8000u <= tag)) {
            DO_(_extensions_.ParseField(tag, input, default_instance_,
                                        mutable_unknown_fields()));
            continue;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void FieldOptions::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      FieldOptions::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // optional .google.protobuf.FieldOptions.CType ctype = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteEnum(1, this->ctype(), output);
    }
    
    // optional bool packed = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::WriteBool(2, this->packed(), output);
    }
    
    // optional bool deprecated = 3 [default = false];
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormat::WriteBool(3, this->deprecated(), output);
    }
    
    // optional string experimental_map_key = 9;
    if (_has_bit(3)) {
      ::google::protobuf::internal::WireFormat::WriteString(9, this->experimental_map_key(), output);
    }
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(999, this->uninterpreted_option(i), output);
    }
    
    // Extension range [1000, 536870912)
    _extensions_.SerializeWithCachedSizes(
        1000, 536870912, output);
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* FieldOptions::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // optional .google.protobuf.FieldOptions.CType ctype = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteEnumToArray(1, this->ctype(), target);
    }
    
    // optional bool packed = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormat::WriteBoolToArray(2, this->packed(), target);
    }
    
    // optional bool deprecated = 3 [default = false];
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormat::WriteBoolToArray(3, this->deprecated(), target);
    }
    
    // optional string experimental_map_key = 9;
    if (_has_bit(3)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(9, this->experimental_map_key(), target);
    }
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(999, this->uninterpreted_option(i), target);
    }
    
    // Extension range [1000, 536870912)
    target = _extensions_.SerializeWithCachedSizesToArray(
        1000, 536870912, target);
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int FieldOptions::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // optional .google.protobuf.FieldOptions.CType ctype = 1;
      if (has_ctype()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::EnumSize(this->ctype());
      }
      
      // optional bool packed = 2;
      if (has_packed()) {
        total_size += 1 + 1;
      }
      
      // optional bool deprecated = 3 [default = false];
      if (has_deprecated()) {
        total_size += 1 + 1;
      }
      
      // optional string experimental_map_key = 9;
      if (has_experimental_map_key()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->experimental_map_key());
      }
      
    }
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    total_size += 2 * this->uninterpreted_option_size();
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->uninterpreted_option(i));
    }
    
    total_size += _extensions_.ByteSize();
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void FieldOptions::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const FieldOptions* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const FieldOptions*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void FieldOptions::MergeFrom(const FieldOptions& from) {
    GOOGLE_CHECK_NE(&from, this);
    uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_ctype(from.ctype());
      }
      if (from._has_bit(1)) {
        set_packed(from.packed());
      }
      if (from._has_bit(2)) {
        set_deprecated(from.deprecated());
      }
      if (from._has_bit(3)) {
        set_experimental_map_key(from.experimental_map_key());
      }
    }
    _extensions_.MergeFrom(from._extensions_);
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void FieldOptions::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void FieldOptions::CopyFrom(const FieldOptions& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void FieldOptions::Swap(FieldOptions* other) {
    if (other != this) {
      std::swap(ctype_, other->ctype_);
      std::swap(packed_, other->packed_);
      std::swap(deprecated_, other->deprecated_);
      std::swap(experimental_map_key_, other->experimental_map_key_);
      uninterpreted_option_.Swap(&other->uninterpreted_option_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
      _extensions_.Swap(&other->_extensions_);
    }
  }
  
  bool FieldOptions::IsInitialized() const {
    
    for (int i = 0; i < uninterpreted_option_size(); i++) {
      if (!this->uninterpreted_option(i).IsInitialized()) return false;
    }
    
    if (!_extensions_.IsInitialized()) return false;  return true;
  }
  
  const ::google::protobuf::Descriptor* FieldOptions::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* FieldOptions::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return FieldOptions_reflection_;
  }
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int EnumOptions::kUninterpretedOptionFieldNumber;
  #endif  // !_MSC_VER
  
  EnumOptions::EnumOptions()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void EnumOptions::InitAsDefaultInstance() {}
  
  EnumOptions::EnumOptions(const EnumOptions& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void EnumOptions::SharedCtor() {
    _cached_size_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  EnumOptions::~EnumOptions() {
    SharedDtor();
  }
  
  void EnumOptions::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  const ::google::protobuf::Descriptor* EnumOptions::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return EnumOptions_descriptor_;
  }
  
  const EnumOptions& EnumOptions::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  EnumOptions* EnumOptions::default_instance_ = NULL;
  
  EnumOptions* EnumOptions::New() const {
    return new EnumOptions;
  }
  
  void EnumOptions::Clear() {
    _extensions_.Clear();
    uninterpreted_option_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool EnumOptions::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
        case 999: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_uninterpreted_option:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_uninterpreted_option()));
          if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          if ((8000u <= tag)) {
            DO_(_extensions_.ParseField(tag, input, default_instance_,
                                        mutable_unknown_fields()));
            continue;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void EnumOptions::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      EnumOptions::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(999, this->uninterpreted_option(i), output);
    }
    
    // Extension range [1000, 536870912)
    _extensions_.SerializeWithCachedSizes(
        1000, 536870912, output);
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* EnumOptions::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(999, this->uninterpreted_option(i), target);
    }
    
    // Extension range [1000, 536870912)
    target = _extensions_.SerializeWithCachedSizesToArray(
        1000, 536870912, target);
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int EnumOptions::ByteSize() const {
    int total_size = 0;
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    total_size += 2 * this->uninterpreted_option_size();
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->uninterpreted_option(i));
    }
    
    total_size += _extensions_.ByteSize();
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void EnumOptions::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const EnumOptions* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const EnumOptions*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void EnumOptions::MergeFrom(const EnumOptions& from) {
    GOOGLE_CHECK_NE(&from, this);
    uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
    _extensions_.MergeFrom(from._extensions_);
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void EnumOptions::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void EnumOptions::CopyFrom(const EnumOptions& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void EnumOptions::Swap(EnumOptions* other) {
    if (other != this) {
      uninterpreted_option_.Swap(&other->uninterpreted_option_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
      _extensions_.Swap(&other->_extensions_);
    }
  }
  
  bool EnumOptions::IsInitialized() const {
    
    for (int i = 0; i < uninterpreted_option_size(); i++) {
      if (!this->uninterpreted_option(i).IsInitialized()) return false;
    }
    
    if (!_extensions_.IsInitialized()) return false;  return true;
  }
  
  const ::google::protobuf::Descriptor* EnumOptions::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* EnumOptions::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return EnumOptions_reflection_;
  }
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int EnumValueOptions::kUninterpretedOptionFieldNumber;
  #endif  // !_MSC_VER
  
  EnumValueOptions::EnumValueOptions()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void EnumValueOptions::InitAsDefaultInstance() {}
  
  EnumValueOptions::EnumValueOptions(const EnumValueOptions& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void EnumValueOptions::SharedCtor() {
    _cached_size_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  EnumValueOptions::~EnumValueOptions() {
    SharedDtor();
  }
  
  void EnumValueOptions::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  const ::google::protobuf::Descriptor* EnumValueOptions::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return EnumValueOptions_descriptor_;
  }
  
  const EnumValueOptions& EnumValueOptions::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  EnumValueOptions* EnumValueOptions::default_instance_ = NULL;
  
  EnumValueOptions* EnumValueOptions::New() const {
    return new EnumValueOptions;
  }
  
  void EnumValueOptions::Clear() {
    _extensions_.Clear();
    uninterpreted_option_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool EnumValueOptions::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
        case 999: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_uninterpreted_option:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_uninterpreted_option()));
          if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          if ((8000u <= tag)) {
            DO_(_extensions_.ParseField(tag, input, default_instance_,
                                        mutable_unknown_fields()));
            continue;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void EnumValueOptions::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      EnumValueOptions::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(999, this->uninterpreted_option(i), output);
    }
    
    // Extension range [1000, 536870912)
    _extensions_.SerializeWithCachedSizes(
        1000, 536870912, output);
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* EnumValueOptions::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(999, this->uninterpreted_option(i), target);
    }
    
    // Extension range [1000, 536870912)
    target = _extensions_.SerializeWithCachedSizesToArray(
        1000, 536870912, target);
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int EnumValueOptions::ByteSize() const {
    int total_size = 0;
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    total_size += 2 * this->uninterpreted_option_size();
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->uninterpreted_option(i));
    }
    
    total_size += _extensions_.ByteSize();
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void EnumValueOptions::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const EnumValueOptions* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const EnumValueOptions*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void EnumValueOptions::MergeFrom(const EnumValueOptions& from) {
    GOOGLE_CHECK_NE(&from, this);
    uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
    _extensions_.MergeFrom(from._extensions_);
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void EnumValueOptions::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void EnumValueOptions::CopyFrom(const EnumValueOptions& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void EnumValueOptions::Swap(EnumValueOptions* other) {
    if (other != this) {
      uninterpreted_option_.Swap(&other->uninterpreted_option_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
      _extensions_.Swap(&other->_extensions_);
    }
  }
  
  bool EnumValueOptions::IsInitialized() const {
    
    for (int i = 0; i < uninterpreted_option_size(); i++) {
      if (!this->uninterpreted_option(i).IsInitialized()) return false;
    }
    
    if (!_extensions_.IsInitialized()) return false;  return true;
  }
  
  const ::google::protobuf::Descriptor* EnumValueOptions::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* EnumValueOptions::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return EnumValueOptions_reflection_;
  }
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int ServiceOptions::kUninterpretedOptionFieldNumber;
  #endif  // !_MSC_VER
  
  ServiceOptions::ServiceOptions()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void ServiceOptions::InitAsDefaultInstance() {}
  
  ServiceOptions::ServiceOptions(const ServiceOptions& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void ServiceOptions::SharedCtor() {
    _cached_size_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  ServiceOptions::~ServiceOptions() {
    SharedDtor();
  }
  
  void ServiceOptions::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  const ::google::protobuf::Descriptor* ServiceOptions::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return ServiceOptions_descriptor_;
  }
  
  const ServiceOptions& ServiceOptions::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  ServiceOptions* ServiceOptions::default_instance_ = NULL;
  
  ServiceOptions* ServiceOptions::New() const {
    return new ServiceOptions;
  }
  
  void ServiceOptions::Clear() {
    _extensions_.Clear();
    uninterpreted_option_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool ServiceOptions::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
        case 999: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_uninterpreted_option:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_uninterpreted_option()));
          if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          if ((8000u <= tag)) {
            DO_(_extensions_.ParseField(tag, input, default_instance_,
                                        mutable_unknown_fields()));
            continue;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void ServiceOptions::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      ServiceOptions::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(999, this->uninterpreted_option(i), output);
    }
    
    // Extension range [1000, 536870912)
    _extensions_.SerializeWithCachedSizes(
        1000, 536870912, output);
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* ServiceOptions::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(999, this->uninterpreted_option(i), target);
    }
    
    // Extension range [1000, 536870912)
    target = _extensions_.SerializeWithCachedSizesToArray(
        1000, 536870912, target);
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int ServiceOptions::ByteSize() const {
    int total_size = 0;
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    total_size += 2 * this->uninterpreted_option_size();
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->uninterpreted_option(i));
    }
    
    total_size += _extensions_.ByteSize();
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void ServiceOptions::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const ServiceOptions* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const ServiceOptions*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void ServiceOptions::MergeFrom(const ServiceOptions& from) {
    GOOGLE_CHECK_NE(&from, this);
    uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
    _extensions_.MergeFrom(from._extensions_);
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void ServiceOptions::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void ServiceOptions::CopyFrom(const ServiceOptions& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void ServiceOptions::Swap(ServiceOptions* other) {
    if (other != this) {
      uninterpreted_option_.Swap(&other->uninterpreted_option_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
      _extensions_.Swap(&other->_extensions_);
    }
  }
  
  bool ServiceOptions::IsInitialized() const {
    
    for (int i = 0; i < uninterpreted_option_size(); i++) {
      if (!this->uninterpreted_option(i).IsInitialized()) return false;
    }
    
    if (!_extensions_.IsInitialized()) return false;  return true;
  }
  
  const ::google::protobuf::Descriptor* ServiceOptions::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* ServiceOptions::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return ServiceOptions_reflection_;
  }
  
  // ===================================================================
  
  #ifndef _MSC_VER
  const int MethodOptions::kUninterpretedOptionFieldNumber;
  #endif  // !_MSC_VER
  
  MethodOptions::MethodOptions()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void MethodOptions::InitAsDefaultInstance() {}
  
  MethodOptions::MethodOptions(const MethodOptions& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void MethodOptions::SharedCtor() {
    _cached_size_ = 0;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  MethodOptions::~MethodOptions() {
    SharedDtor();
  }
  
  void MethodOptions::SharedDtor() {
    if (this != default_instance_) {
    }
  }
  
  const ::google::protobuf::Descriptor* MethodOptions::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return MethodOptions_descriptor_;
  }
  
  const MethodOptions& MethodOptions::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  MethodOptions* MethodOptions::default_instance_ = NULL;
  
  MethodOptions* MethodOptions::New() const {
    return new MethodOptions;
  }
  
  void MethodOptions::Clear() {
    _extensions_.Clear();
    uninterpreted_option_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool MethodOptions::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
        case 999: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_uninterpreted_option:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_uninterpreted_option()));
          if (input->ExpectTag(7994)) goto parse_uninterpreted_option;
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          if ((8000u <= tag)) {
            DO_(_extensions_.ParseField(tag, input, default_instance_,
                                        mutable_unknown_fields()));
            continue;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void MethodOptions::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      MethodOptions::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(999, this->uninterpreted_option(i), output);
    }
    
    // Extension range [1000, 536870912)
    _extensions_.SerializeWithCachedSizes(
        1000, 536870912, output);
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* MethodOptions::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(999, this->uninterpreted_option(i), target);
    }
    
    // Extension range [1000, 536870912)
    target = _extensions_.SerializeWithCachedSizesToArray(
        1000, 536870912, target);
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int MethodOptions::ByteSize() const {
    int total_size = 0;
    
    // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
    total_size += 2 * this->uninterpreted_option_size();
    for (int i = 0; i < this->uninterpreted_option_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->uninterpreted_option(i));
    }
    
    total_size += _extensions_.ByteSize();
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void MethodOptions::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const MethodOptions* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const MethodOptions*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void MethodOptions::MergeFrom(const MethodOptions& from) {
    GOOGLE_CHECK_NE(&from, this);
    uninterpreted_option_.MergeFrom(from.uninterpreted_option_);
    _extensions_.MergeFrom(from._extensions_);
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void MethodOptions::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void MethodOptions::CopyFrom(const MethodOptions& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void MethodOptions::Swap(MethodOptions* other) {
    if (other != this) {
      uninterpreted_option_.Swap(&other->uninterpreted_option_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
      _extensions_.Swap(&other->_extensions_);
    }
  }
  
  bool MethodOptions::IsInitialized() const {
    
    for (int i = 0; i < uninterpreted_option_size(); i++) {
      if (!this->uninterpreted_option(i).IsInitialized()) return false;
    }
    
    if (!_extensions_.IsInitialized()) return false;  return true;
  }
  
  const ::google::protobuf::Descriptor* MethodOptions::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* MethodOptions::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return MethodOptions_reflection_;
  }
  
  // ===================================================================
  
  const ::std::string UninterpretedOption_NamePart::_default_name_part_;
  #ifndef _MSC_VER
  const int UninterpretedOption_NamePart::kNamePartFieldNumber;
  const int UninterpretedOption_NamePart::kIsExtensionFieldNumber;
  #endif  // !_MSC_VER
  
  UninterpretedOption_NamePart::UninterpretedOption_NamePart()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void UninterpretedOption_NamePart::InitAsDefaultInstance() {}
  
  UninterpretedOption_NamePart::UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void UninterpretedOption_NamePart::SharedCtor() {
    _cached_size_ = 0;
    name_part_ = const_cast< ::std::string*>(&_default_name_part_);
    is_extension_ = false;
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  UninterpretedOption_NamePart::~UninterpretedOption_NamePart() {
    SharedDtor();
  }
  
  void UninterpretedOption_NamePart::SharedDtor() {
    if (name_part_ != &_default_name_part_) {
      delete name_part_;
    }
    if (this != default_instance_) {
    }
  }
  
  const ::google::protobuf::Descriptor* UninterpretedOption_NamePart::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return UninterpretedOption_NamePart_descriptor_;
  }
  
  const UninterpretedOption_NamePart& UninterpretedOption_NamePart::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  UninterpretedOption_NamePart* UninterpretedOption_NamePart::default_instance_ = NULL;
  
  UninterpretedOption_NamePart* UninterpretedOption_NamePart::New() const {
    return new UninterpretedOption_NamePart;
  }
  
  void UninterpretedOption_NamePart::Clear() {
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (_has_bit(0)) {
        if (name_part_ != &_default_name_part_) {
          name_part_->clear();
        }
      }
      is_extension_ = false;
    }
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool UninterpretedOption_NamePart::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // required string name_part = 1;
        case 1: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_name_part()));
          if (input->ExpectTag(16)) goto parse_is_extension;
          break;
        }
        
        // required bool is_extension = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_is_extension:
          DO_(::google::protobuf::internal::WireFormat::ReadBool(
                input, &is_extension_));
          _set_bit(1);
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void UninterpretedOption_NamePart::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      UninterpretedOption_NamePart::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // required string name_part = 1;
    if (_has_bit(0)) {
      ::google::protobuf::internal::WireFormat::WriteString(1, this->name_part(), output);
    }
    
    // required bool is_extension = 2;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::WriteBool(2, this->is_extension(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* UninterpretedOption_NamePart::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // required string name_part = 1;
    if (_has_bit(0)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(1, this->name_part(), target);
    }
    
    // required bool is_extension = 2;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormat::WriteBoolToArray(2, this->is_extension(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int UninterpretedOption_NamePart::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      // required string name_part = 1;
      if (has_name_part()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->name_part());
      }
      
      // required bool is_extension = 2;
      if (has_is_extension()) {
        total_size += 1 + 1;
      }
      
    }
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void UninterpretedOption_NamePart::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const UninterpretedOption_NamePart* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const UninterpretedOption_NamePart*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void UninterpretedOption_NamePart::MergeFrom(const UninterpretedOption_NamePart& from) {
    GOOGLE_CHECK_NE(&from, this);
    if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
      if (from._has_bit(0)) {
        set_name_part(from.name_part());
      }
      if (from._has_bit(1)) {
        set_is_extension(from.is_extension());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void UninterpretedOption_NamePart::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void UninterpretedOption_NamePart::CopyFrom(const UninterpretedOption_NamePart& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void UninterpretedOption_NamePart::Swap(UninterpretedOption_NamePart* other) {
    if (other != this) {
      std::swap(name_part_, other->name_part_);
      std::swap(is_extension_, other->is_extension_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  bool UninterpretedOption_NamePart::IsInitialized() const {
    if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
    
    return true;
  }
  
  const ::google::protobuf::Descriptor* UninterpretedOption_NamePart::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* UninterpretedOption_NamePart::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return UninterpretedOption_NamePart_reflection_;
  }
  
  // -------------------------------------------------------------------
  
  const ::std::string UninterpretedOption::_default_identifier_value_;
  const ::std::string UninterpretedOption::_default_string_value_;
  #ifndef _MSC_VER
  const int UninterpretedOption::kNameFieldNumber;
  const int UninterpretedOption::kIdentifierValueFieldNumber;
  const int UninterpretedOption::kPositiveIntValueFieldNumber;
  const int UninterpretedOption::kNegativeIntValueFieldNumber;
  const int UninterpretedOption::kDoubleValueFieldNumber;
  const int UninterpretedOption::kStringValueFieldNumber;
  #endif  // !_MSC_VER
  
  UninterpretedOption::UninterpretedOption()
    : ::google::protobuf::Message() {
    SharedCtor();
  }
  
  void UninterpretedOption::InitAsDefaultInstance() {}
  
  UninterpretedOption::UninterpretedOption(const UninterpretedOption& from)
    : ::google::protobuf::Message() {
    SharedCtor();
    MergeFrom(from);
  }
  
  void UninterpretedOption::SharedCtor() {
    _cached_size_ = 0;
    identifier_value_ = const_cast< ::std::string*>(&_default_identifier_value_);
    positive_int_value_ = GOOGLE_ULONGLONG(0);
    negative_int_value_ = GOOGLE_LONGLONG(0);
    double_value_ = 0;
    string_value_ = const_cast< ::std::string*>(&_default_string_value_);
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
  }
  
  UninterpretedOption::~UninterpretedOption() {
    SharedDtor();
  }
  
  void UninterpretedOption::SharedDtor() {
    if (identifier_value_ != &_default_identifier_value_) {
      delete identifier_value_;
    }
    if (string_value_ != &_default_string_value_) {
      delete string_value_;
    }
    if (this != default_instance_) {
    }
  }
  
  const ::google::protobuf::Descriptor* UninterpretedOption::descriptor() {
    protobuf_AssignDescriptorsOnce();
    return UninterpretedOption_descriptor_;
  }
  
  const UninterpretedOption& UninterpretedOption::default_instance() {
    if (default_instance_ == NULL) protobuf_AddDesc_google_2fprotobuf_2fdescriptor_2eproto();  return *default_instance_;
  }
  
  UninterpretedOption* UninterpretedOption::default_instance_ = NULL;
  
  UninterpretedOption* UninterpretedOption::New() const {
    return new UninterpretedOption;
  }
  
  void UninterpretedOption::Clear() {
    if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
      if (_has_bit(1)) {
        if (identifier_value_ != &_default_identifier_value_) {
          identifier_value_->clear();
        }
      }
      positive_int_value_ = GOOGLE_ULONGLONG(0);
      negative_int_value_ = GOOGLE_LONGLONG(0);
      double_value_ = 0;
      if (_has_bit(5)) {
        if (string_value_ != &_default_string_value_) {
          string_value_->clear();
        }
      }
    }
    name_.Clear();
    ::memset(_has_bits_, 0, sizeof(_has_bits_));
    mutable_unknown_fields()->Clear();
  }
  
  bool UninterpretedOption::MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) {
  #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
    ::google::protobuf::uint32 tag;
    while ((tag = input->ReadTag()) != 0) {
      switch (::google::protobuf::internal::WireFormat::GetTagFieldNumber(tag)) {
        // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
        case 2: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_name:
          DO_(::google::protobuf::internal::WireFormat::ReadMessageNoVirtual(
               input, add_name()));
          if (input->ExpectTag(18)) goto parse_name;
          if (input->ExpectTag(26)) goto parse_identifier_value;
          break;
        }
        
        // optional string identifier_value = 3;
        case 3: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_identifier_value:
          DO_(::google::protobuf::internal::WireFormat::ReadString(input, mutable_identifier_value()));
          if (input->ExpectTag(32)) goto parse_positive_int_value;
          break;
        }
        
        // optional uint64 positive_int_value = 4;
        case 4: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_positive_int_value:
          DO_(::google::protobuf::internal::WireFormat::ReadUInt64(
                input, &positive_int_value_));
          _set_bit(2);
          if (input->ExpectTag(40)) goto parse_negative_int_value;
          break;
        }
        
        // optional int64 negative_int_value = 5;
        case 5: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_VARINT) {
            goto handle_uninterpreted;
          }
         parse_negative_int_value:
          DO_(::google::protobuf::internal::WireFormat::ReadInt64(
                input, &negative_int_value_));
          _set_bit(3);
          if (input->ExpectTag(49)) goto parse_double_value;
          break;
        }
        
        // optional double double_value = 6;
        case 6: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_FIXED64) {
            goto handle_uninterpreted;
          }
         parse_double_value:
          DO_(::google::protobuf::internal::WireFormat::ReadDouble(
                input, &double_value_));
          _set_bit(4);
          if (input->ExpectTag(58)) goto parse_string_value;
          break;
        }
        
        // optional bytes string_value = 7;
        case 7: {
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) !=
              ::google::protobuf::internal::WireFormat::WIRETYPE_LENGTH_DELIMITED) {
            goto handle_uninterpreted;
          }
         parse_string_value:
          DO_(::google::protobuf::internal::WireFormat::ReadBytes(input, mutable_string_value()));
          if (input->ExpectAtEnd()) return true;
          break;
        }
        
        default: {
        handle_uninterpreted:
          if (::google::protobuf::internal::WireFormat::GetTagWireType(tag) ==
              ::google::protobuf::internal::WireFormat::WIRETYPE_END_GROUP) {
            return true;
          }
          DO_(::google::protobuf::internal::WireFormat::SkipField(
                input, tag, mutable_unknown_fields()));
          break;
        }
      }
    }
    return true;
  #undef DO_
  }
  
  void UninterpretedOption::SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const {
    ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
    if (raw_buffer != NULL) {
      UninterpretedOption::SerializeWithCachedSizesToArray(raw_buffer);
      return;
    }
    
    // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
    for (int i = 0; i < this->name_size(); i++) {
      ::google::protobuf::internal::WireFormat::WriteMessageNoVirtual(2, this->name(i), output);
    }
    
    // optional string identifier_value = 3;
    if (_has_bit(1)) {
      ::google::protobuf::internal::WireFormat::WriteString(3, this->identifier_value(), output);
    }
    
    // optional uint64 positive_int_value = 4;
    if (_has_bit(2)) {
      ::google::protobuf::internal::WireFormat::WriteUInt64(4, this->positive_int_value(), output);
    }
    
    // optional int64 negative_int_value = 5;
    if (_has_bit(3)) {
      ::google::protobuf::internal::WireFormat::WriteInt64(5, this->negative_int_value(), output);
    }
    
    // optional double double_value = 6;
    if (_has_bit(4)) {
      ::google::protobuf::internal::WireFormat::WriteDouble(6, this->double_value(), output);
    }
    
    // optional bytes string_value = 7;
    if (_has_bit(5)) {
      ::google::protobuf::internal::WireFormat::WriteBytes(7, this->string_value(), output);
    }
    
    if (!unknown_fields().empty()) {
      ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
          unknown_fields(), output);
    }
  }
  
  ::google::protobuf::uint8* UninterpretedOption::SerializeWithCachedSizesToArray(
      ::google::protobuf::uint8* target) const {
    // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
    for (int i = 0; i < this->name_size(); i++) {
      target = ::google::protobuf::internal::WireFormat::WriteMessageNoVirtualToArray(2, this->name(i), target);
    }
    
    // optional string identifier_value = 3;
    if (_has_bit(1)) {
      target = ::google::protobuf::internal::WireFormat::WriteStringToArray(3, this->identifier_value(), target);
    }
    
    // optional uint64 positive_int_value = 4;
    if (_has_bit(2)) {
      target = ::google::protobuf::internal::WireFormat::WriteUInt64ToArray(4, this->positive_int_value(), target);
    }
    
    // optional int64 negative_int_value = 5;
    if (_has_bit(3)) {
      target = ::google::protobuf::internal::WireFormat::WriteInt64ToArray(5, this->negative_int_value(), target);
    }
    
    // optional double double_value = 6;
    if (_has_bit(4)) {
      target = ::google::protobuf::internal::WireFormat::WriteDoubleToArray(6, this->double_value(), target);
    }
    
    // optional bytes string_value = 7;
    if (_has_bit(5)) {
      target = ::google::protobuf::internal::WireFormat::WriteBytesToArray(7, this->string_value(), target);
    }
    
    if (!unknown_fields().empty()) {
      target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
          unknown_fields(), target);
    }
    return target;
  }
  
  int UninterpretedOption::ByteSize() const {
    int total_size = 0;
    
    if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) {
      // optional string identifier_value = 3;
      if (has_identifier_value()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::StringSize(this->identifier_value());
      }
      
      // optional uint64 positive_int_value = 4;
      if (has_positive_int_value()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::UInt64Size(
            this->positive_int_value());
      }
      
      // optional int64 negative_int_value = 5;
      if (has_negative_int_value()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::Int64Size(
            this->negative_int_value());
      }
      
      // optional double double_value = 6;
      if (has_double_value()) {
        total_size += 1 + 8;
      }
      
      // optional bytes string_value = 7;
      if (has_string_value()) {
        total_size += 1 +
          ::google::protobuf::internal::WireFormat::BytesSize(this->string_value());
      }
      
    }
    // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
    total_size += 1 * this->name_size();
    for (int i = 0; i < this->name_size(); i++) {
      total_size +=
        ::google::protobuf::internal::WireFormat::MessageSizeNoVirtual(
          this->name(i));
    }
    
    if (!unknown_fields().empty()) {
      total_size +=
        ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
          unknown_fields());
    }
    _cached_size_ = total_size;
    return total_size;
  }
  
  void UninterpretedOption::MergeFrom(const ::google::protobuf::Message& from) {
    GOOGLE_CHECK_NE(&from, this);
    const UninterpretedOption* source =
      ::google::protobuf::internal::dynamic_cast_if_available<const UninterpretedOption*>(
        &from);
    if (source == NULL) {
      ::google::protobuf::internal::ReflectionOps::Merge(from, this);
    } else {
      MergeFrom(*source);
    }
  }
  
  void UninterpretedOption::MergeFrom(const UninterpretedOption& from) {
    GOOGLE_CHECK_NE(&from, this);
    name_.MergeFrom(from.name_);
    if (from._has_bits_[1 / 32] & (0xffu << (1 % 32))) {
      if (from._has_bit(1)) {
        set_identifier_value(from.identifier_value());
      }
      if (from._has_bit(2)) {
        set_positive_int_value(from.positive_int_value());
      }
      if (from._has_bit(3)) {
        set_negative_int_value(from.negative_int_value());
      }
      if (from._has_bit(4)) {
        set_double_value(from.double_value());
      }
      if (from._has_bit(5)) {
        set_string_value(from.string_value());
      }
    }
    mutable_unknown_fields()->MergeFrom(from.unknown_fields());
  }
  
  void UninterpretedOption::CopyFrom(const ::google::protobuf::Message& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void UninterpretedOption::CopyFrom(const UninterpretedOption& from) {
    if (&from == this) return;
    Clear();
    MergeFrom(from);
  }
  
  void UninterpretedOption::Swap(UninterpretedOption* other) {
    if (other != this) {
      name_.Swap(&other->name_);
      std::swap(identifier_value_, other->identifier_value_);
      std::swap(positive_int_value_, other->positive_int_value_);
      std::swap(negative_int_value_, other->negative_int_value_);
      std::swap(double_value_, other->double_value_);
      std::swap(string_value_, other->string_value_);
      std::swap(_has_bits_[0], other->_has_bits_[0]);
      _unknown_fields_.Swap(&other->_unknown_fields_);
      std::swap(_cached_size_, other->_cached_size_);
    }
  }
  
  bool UninterpretedOption::IsInitialized() const {
    
    for (int i = 0; i < name_size(); i++) {
      if (!this->name(i).IsInitialized()) return false;
    }
    return true;
  }
  
  const ::google::protobuf::Descriptor* UninterpretedOption::GetDescriptor() const {
    return descriptor();
  }
  
  const ::google::protobuf::Reflection* UninterpretedOption::GetReflection() const {
    protobuf_AssignDescriptorsOnce();
    return UninterpretedOption_reflection_;
  }
  
  }  // namespace protobuf
  }  // namespace google
  