protobuf/csharp/ProtocolBuffers/DescriptorProtos/DescriptorProtoFile.cs

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

using pb = global::Google.ProtocolBuffers;
using pbc = global::Google.ProtocolBuffers.Collections;
using pbd = global::Google.ProtocolBuffers.Descriptors;
using scg = global::System.Collections.Generic;
namespace Google.ProtocolBuffers.DescriptorProtos {
  
  public static partial class DescriptorProtoFile {
  
    #region Descriptor
    public static pbd::FileDescriptor Descriptor {
        get { return descriptor; }
    }
    private static readonly pbd::FileDescriptor descriptor = pbd::FileDescriptor.InternalBuildGeneratedFileFrom (
        new byte[] {
            0x0a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x65, 
            0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0f, 0x67, 0x6f, 0x6f, 0x67, 
            0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x22, 0xdc, 0x02, 0x0a, 0x13, 0x46, 0x69, 0x6c, 0x65, 
            0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x0a, 0x04, 0x6e, 
            0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x12, 0x0f, 0x0a, 0x07, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 
            0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x12, 0x12, 0x0a, 0x0a, 0x64, 0x65, 0x70, 0x65, 0x6e, 0x64, 0x65, 0x6e, 0x63, 0x79, 
            0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x12, 0x36, 0x0a, 0x0c, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x74, 0x79, 
            0x70, 0x65, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 
            0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 
            0x74, 0x6f, 0x12, 0x37, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x03, 0x28, 
            0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 
            0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 
            0x38, 0x0a, 0x07, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x67, 
            0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x69, 
            0x63, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x38, 0x0a, 
            0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 
            0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 
            0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x2d, 0x0a, 0x07, 0x6f, 
            0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 
            0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 
            0x6e, 0x73, 0x22, 0xa9, 0x03, 0x0a, 0x0f, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 
            0x74, 0x6f, 0x12, 0x0c, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x12, 0x34, 0x0a, 0x05, 
            0x66, 0x69, 0x65, 0x6c, 0x64, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 
            0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 
            0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x38, 0x0a, 0x09, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 
            0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 
            0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 
            0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x35, 0x0a, 0x0b, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x74, 
            0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 
            0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 
            0x6f, 0x74, 0x6f, 0x12, 0x37, 0x0a, 0x09, 0x65, 0x6e, 0x75, 0x6d, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x03, 
            0x28, 0x0b, 0x32, 0x24, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 
            0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 
            0x12, 0x48, 0x0a, 0x0f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x18, 
            0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 
            0x62, 0x75, 0x66, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 
            0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x30, 0x0a, 0x07, 0x6f, 0x70, 
            0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 
            0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 
            0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x2c, 0x0a, 0x0e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x61, 0x6e, 
            0x67, 0x65, 0x12, 0x0d, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x12, 0x0b, 0x0a, 
            0x03, 0x65, 0x6e, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x22, 0x94, 0x05, 0x0a, 0x14, 0x46, 0x69, 0x65, 0x6c, 0x64, 
            0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x0a, 0x04, 0x6e, 
            0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x12, 0x0e, 0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 
            0x03, 0x20, 0x01, 0x28, 0x05, 0x12, 0x3a, 0x0a, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 
            0x32, 0x2b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 
            0x69, 0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 
            0x4c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x38, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 
            0x2a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 
            0x65, 0x6c, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x54, 
            0x79, 0x70, 0x65, 0x12, 0x11, 0x0a, 0x09, 0x74, 0x79, 0x70, 0x65, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x06, 0x20, 0x01, 
            0x28, 0x09, 0x12, 0x10, 0x0a, 0x08, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x64, 0x65, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 
            0x12, 0x15, 0x0a, 0x0d, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 
            0x01, 0x28, 0x09, 0x12, 0x2e, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 
            0x32, 0x1d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 
            0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xb6, 0x02, 0x0a, 0x04, 0x54, 0x79, 0x70, 0x65, 
            0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x44, 0x4f, 0x55, 0x42, 0x4c, 0x45, 0x10, 0x01, 0x12, 0x0e, 0x0a, 
            0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x4c, 0x4f, 0x41, 0x54, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 
            0x45, 0x5f, 0x49, 0x4e, 0x54, 0x36, 0x34, 0x10, 0x03, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x49, 
            0x4e, 0x54, 0x36, 0x34, 0x10, 0x04, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x49, 0x4e, 0x54, 0x33, 0x32, 
            0x10, 0x05, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x49, 0x58, 0x45, 0x44, 0x36, 0x34, 0x10, 0x06, 
            0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x46, 0x49, 0x58, 0x45, 0x44, 0x33, 0x32, 0x10, 0x07, 0x12, 0x0d, 
            0x0a, 0x09, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x4f, 0x4f, 0x4c, 0x10, 0x08, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 
            0x45, 0x5f, 0x53, 0x54, 0x52, 0x49, 0x4e, 0x47, 0x10, 0x09, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x47, 
            0x52, 0x4f, 0x55, 0x50, 0x10, 0x0a, 0x12, 0x10, 0x0a, 0x0c, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4d, 0x45, 0x53, 0x53, 0x41, 
            0x47, 0x45, 0x10, 0x0b, 0x12, 0x0e, 0x0a, 0x0a, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x42, 0x59, 0x54, 0x45, 0x53, 0x10, 0x0c, 
            0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x55, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10, 0x0d, 0x12, 0x0d, 0x0a, 
            0x09, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x45, 0x4e, 0x55, 0x4d, 0x10, 0x0e, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59, 0x50, 0x45, 
            0x5f, 0x53, 0x46, 0x49, 0x58, 0x45, 0x44, 0x33, 0x32, 0x10, 0x0f, 0x12, 0x11, 0x0a, 0x0d, 0x54, 0x59, 0x50, 0x45, 0x5f, 
            0x53, 0x46, 0x49, 0x58, 0x45, 0x44, 0x36, 0x34, 0x10, 0x10, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 
            0x49, 0x4e, 0x54, 0x33, 0x32, 0x10, 0x11, 0x12, 0x0f, 0x0a, 0x0b, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x53, 0x49, 0x4e, 0x54, 
            0x36, 0x34, 0x10, 0x12, 0x22, 0x43, 0x0a, 0x05, 0x4c, 0x61, 0x62, 0x65, 0x6c, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 
            0x45, 0x4c, 0x5f, 0x4f, 0x50, 0x54, 0x49, 0x4f, 0x4e, 0x41, 0x4c, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 
            0x45, 0x4c, 0x5f, 0x52, 0x45, 0x51, 0x55, 0x49, 0x52, 0x45, 0x44, 0x10, 0x02, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x41, 0x42, 
            0x45, 0x4c, 0x5f, 0x52, 0x45, 0x50, 0x45, 0x41, 0x54, 0x45, 0x44, 0x10, 0x03, 0x22, 0x8c, 0x01, 0x0a, 0x13, 0x45, 0x6e, 
            0x75, 0x6d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x0a, 
            0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x12, 0x38, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 
            0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 
            0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 
            0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x2d, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 
            0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 
            0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x6c, 0x0a, 0x18, 
            0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 
            0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x12, 0x0e, 
            0x0a, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x12, 0x32, 0x0a, 0x07, 0x6f, 0x70, 
            0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 
            0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 
            0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x90, 0x01, 0x0a, 0x16, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x44, 0x65, 
            0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 
            0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x12, 0x36, 0x0a, 0x06, 0x6d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x18, 0x02, 0x20, 
            0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 
            0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 
            0x6f, 0x74, 0x6f, 0x12, 0x30, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 
            0x32, 0x1f, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 
            0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x7f, 0x0a, 0x15, 0x4d, 0x65, 0x74, 
            0x68, 0x6f, 0x64, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0c, 
            0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x12, 0x12, 0x0a, 0x0a, 0x69, 0x6e, 0x70, 0x75, 
            0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x12, 0x13, 0x0a, 0x0b, 0x6f, 0x75, 0x74, 0x70, 
            0x75, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x12, 0x2f, 0x0a, 0x07, 0x6f, 0x70, 0x74, 
            0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 
            0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 
            0x6e, 0x73, 0x22, 0x88, 0x03, 0x0a, 0x0b, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x14, 
            0x0a, 0x0c, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x70, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 
            0x12, 0x1c, 0x0a, 0x14, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6f, 0x75, 0x74, 0x65, 0x72, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 
            0x6e, 0x61, 0x6d, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x12, 0x22, 0x0a, 0x13, 0x6a, 0x61, 0x76, 0x61, 0x5f, 0x6d, 
            0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x3a, 
            0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x12, 0x4a, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x5f, 0x66, 
            0x6f, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x29, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 
            0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x6c, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4f, 
            0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x3a, 0x09, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x53, 0x49, 
            0x5a, 0x45, 0x12, 0x19, 0x0a, 0x10, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x70, 0x61, 
            0x63, 0x65, 0x18, 0xe8, 0x07, 0x20, 0x01, 0x28, 0x09, 0x12, 0x1e, 0x0a, 0x15, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x5f, 
            0x66, 0x69, 0x6c, 0x65, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0xe9, 0x07, 0x20, 0x01, 0x28, 
            0x09, 0x12, 0x25, 0x0a, 0x15, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x5f, 0x6d, 0x75, 0x6c, 0x74, 0x69, 0x70, 0x6c, 0x65, 
            0x5f, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0xea, 0x07, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 
            0x12, 0x23, 0x0a, 0x13, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x5f, 0x63, 0x6c, 0x61, 0x73, 
            0x73, 0x65, 0x73, 0x18, 0xeb, 0x07, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x12, 0x24, 0x0a, 
            0x15, 0x63, 0x73, 0x68, 0x61, 0x72, 0x70, 0x5f, 0x70, 0x75, 0x62, 0x6c, 0x69, 0x63, 0x5f, 0x63, 0x6c, 0x61, 0x73, 0x73, 
            0x65, 0x73, 0x18, 0xec, 0x07, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x04, 0x74, 0x72, 0x75, 0x65, 0x22, 0x28, 0x0a, 0x0c, 0x4f, 
            0x70, 0x74, 0x69, 0x6d, 0x69, 0x7a, 0x65, 0x4d, 0x6f, 0x64, 0x65, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x50, 0x45, 0x45, 0x44, 
            0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x43, 0x4f, 0x44, 0x45, 0x5f, 0x53, 0x49, 0x5a, 0x45, 0x10, 0x02, 0x22, 0x38, 0x0a, 
            0x0e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x26, 0x0a, 0x17, 0x6d, 
            0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x77, 0x69, 0x72, 0x65, 0x5f, 0x66, 0x6f, 0x72, 0x6d, 
            0x61, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x3a, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65, 0x22, 0x85, 0x01, 0x0a, 0x0c, 
            0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x32, 0x0a, 0x05, 0x63, 0x74, 0x79, 0x70, 
            0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x23, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 
            0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x43, 
            0x54, 0x79, 0x70, 0x65, 0x12, 0x1c, 0x0a, 0x14, 0x65, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x61, 0x6c, 
            0x5f, 0x6d, 0x61, 0x70, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x22, 0x23, 0x0a, 0x05, 0x43, 0x54, 
            0x79, 0x70, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x43, 0x4f, 0x52, 0x44, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x53, 0x54, 0x52, 
            0x49, 0x4e, 0x47, 0x5f, 0x50, 0x49, 0x45, 0x43, 0x45, 0x10, 0x02, 0x22, 0x0d, 0x0a, 0x0b, 0x45, 0x6e, 0x75, 0x6d, 0x4f, 
            0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x12, 0x0a, 0x10, 0x45, 0x6e, 0x75, 0x6d, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x4f, 
            0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x10, 0x0a, 0x0e, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x4f, 0x70, 0x74, 
            0x69, 0x6f, 0x6e, 0x73, 0x22, 0x0f, 0x0a, 0x0d, 0x4d, 0x65, 0x74, 0x68, 0x6f, 0x64, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 
            0x73, 0x42, 0x72, 0x0a, 0x13, 0x63, 0x6f, 0x6d, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 
            0x6f, 0x62, 0x75, 0x66, 0x42, 0x10, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 0x72, 0x6f, 0x74, 
            0x6f, 0x73, 0x48, 0x01, 0xc2, 0x3e, 0x27, 0x47, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x50, 0x72, 0x6f, 0x74, 0x6f, 0x63, 
            0x6f, 0x6c, 0x42, 0x75, 0x66, 0x66, 0x65, 0x72, 0x73, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 
            0x50, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0xca, 0x3e, 0x13, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x6f, 0x72, 0x50, 
            0x72, 0x6f, 0x74, 0x6f, 0x46, 0x69, 0x6c, 0x65, 0xd0, 0x3e, 0x00, 0xd8, 0x3e, 0x00, 0xe0, 0x3e, 0x01, 
        }, new pbd::FileDescriptor[] {
        });
    #endregion
    
    #region Extensions
    #endregion
    
    #region Static variables
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FileDescriptorProto__Descriptor 
        = Descriptor.MessageTypes[0];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Builder> internal__static_google_protobuf_FileDescriptorProto__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Builder>(internal__static_google_protobuf_FileDescriptorProto__Descriptor,
            new string[] { "Name", "Package", "Dependency", "MessageType", "EnumType", "Service", "Extension", "Options", });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_DescriptorProto__Descriptor 
        = Descriptor.MessageTypes[1];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder> internal__static_google_protobuf_DescriptorProto__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder>(internal__static_google_protobuf_DescriptorProto__Descriptor,
            new string[] { "Name", "Field", "Extension", "NestedType", "EnumType", "ExtensionRange", "Options", });
    internal static readonly pbd::MessageDescriptor  internal__static_google_protobuf_DescriptorProto_ExtensionRange__Descriptor 
        = internal__static_google_protobuf_DescriptorProto__Descriptor.NestedTypes[0];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder> internal__static_google_protobuf_DescriptorProto_ExtensionRange__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder>(internal__static_google_protobuf_DescriptorProto_ExtensionRange__Descriptor,
            new string[] { "Start", "End", });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FieldDescriptorProto__Descriptor 
        = Descriptor.MessageTypes[2];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder> internal__static_google_protobuf_FieldDescriptorProto__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder>(internal__static_google_protobuf_FieldDescriptorProto__Descriptor,
            new string[] { "Name", "Number", "Label", "Type", "TypeName", "Extendee", "DefaultValue", "Options", });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumDescriptorProto__Descriptor 
        = Descriptor.MessageTypes[3];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder> internal__static_google_protobuf_EnumDescriptorProto__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder>(internal__static_google_protobuf_EnumDescriptorProto__Descriptor,
            new string[] { "Name", "Value", "Options", });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumValueDescriptorProto__Descriptor 
        = Descriptor.MessageTypes[4];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder> internal__static_google_protobuf_EnumValueDescriptorProto__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder>(internal__static_google_protobuf_EnumValueDescriptorProto__Descriptor,
            new string[] { "Name", "Number", "Options", });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_ServiceDescriptorProto__Descriptor 
        = Descriptor.MessageTypes[5];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder> internal__static_google_protobuf_ServiceDescriptorProto__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder>(internal__static_google_protobuf_ServiceDescriptorProto__Descriptor,
            new string[] { "Name", "Method", "Options", });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MethodDescriptorProto__Descriptor 
        = Descriptor.MessageTypes[6];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder> internal__static_google_protobuf_MethodDescriptorProto__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto, global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder>(internal__static_google_protobuf_MethodDescriptorProto__Descriptor,
            new string[] { "Name", "InputType", "OutputType", "Options", });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FileOptions__Descriptor 
        = Descriptor.MessageTypes[7];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileOptions, global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder> internal__static_google_protobuf_FileOptions__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FileOptions, global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder>(internal__static_google_protobuf_FileOptions__Descriptor,
            new string[] { "JavaPackage", "JavaOuterClassname", "JavaMultipleFiles", "OptimizeFor", "CsharpNamespace", "CsharpFileClassname", "CsharpMultipleFiles", "CsharpNestClasses", "CsharpPublicClasses", });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MessageOptions__Descriptor 
        = Descriptor.MessageTypes[8];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions, global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Builder> internal__static_google_protobuf_MessageOptions__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions, global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Builder>(internal__static_google_protobuf_MessageOptions__Descriptor,
            new string[] { "MessageSetWireFormat", });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_FieldOptions__Descriptor 
        = Descriptor.MessageTypes[9];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Builder> internal__static_google_protobuf_FieldOptions__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions, global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Builder>(internal__static_google_protobuf_FieldOptions__Descriptor,
            new string[] { "Ctype", "ExperimentalMapKey", });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumOptions__Descriptor 
        = Descriptor.MessageTypes[10];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Builder> internal__static_google_protobuf_EnumOptions__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Builder>(internal__static_google_protobuf_EnumOptions__Descriptor,
            new string[] { });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_EnumValueOptions__Descriptor 
        = Descriptor.MessageTypes[11];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Builder> internal__static_google_protobuf_EnumValueOptions__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Builder>(internal__static_google_protobuf_EnumValueOptions__Descriptor,
            new string[] { });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_ServiceOptions__Descriptor 
        = Descriptor.MessageTypes[12];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Builder> internal__static_google_protobuf_ServiceOptions__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions, global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Builder>(internal__static_google_protobuf_ServiceOptions__Descriptor,
            new string[] { });
    internal static readonly pbd::MessageDescriptor internal__static_google_protobuf_MethodOptions__Descriptor 
        = Descriptor.MessageTypes[13];
    internal static pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Builder> internal__static_google_protobuf_MethodOptions__FieldAccessorTable
        = new pb::FieldAccess.FieldAccessorTable<global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions, global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Builder>(internal__static_google_protobuf_MethodOptions__Descriptor,
            new string[] { });
    #endregion
    
  }
  
  #region Enums
  #endregion
  
  #region Messages
  public sealed partial class FileDescriptorProto : pb::GeneratedMessage<FileDescriptorProto, FileDescriptorProto.Builder> {
    private static readonly FileDescriptorProto defaultInstance = new FileDescriptorProto();
    public static FileDescriptorProto DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override FileDescriptorProto DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override FileDescriptorProto ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileDescriptorProto__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<FileDescriptorProto, FileDescriptorProto.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileDescriptorProto__FieldAccessorTable; }
    }
    
    // optional string name = 1;
    private bool hasName;
    private string name_ = "";
    public bool HasName {
      get { return hasName; }
    }
    public string Name {
      get { return name_; }
    }
    
    // optional string package = 2;
    private bool hasPackage;
    private string package_ = "";
    public bool HasPackage {
      get { return hasPackage; }
    }
    public string Package {
      get { return package_; }
    }
    
    // repeated string dependency = 3;
    private scg::IList<string> dependency_ = pbc::Lists<string>.Empty;
    public scg::IList<string> DependencyList {
      get { return dependency_; }
    }
    public int DependencyCount {
      get { return dependency_.Count; }
    }
    public string GetDependency(int index) {
      return dependency_[index];
    }
    
    // repeated .google.protobuf.DescriptorProto message_type = 4;
    private scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> messageType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty;
    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> MessageTypeList {
      get { return messageType_; } 
    }
    public int MessageTypeCount
      { get { return messageType_.Count; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto GetMessageType(int index) {
      return messageType_ [index];
    }
    
    // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
    private scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> enumType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty;
    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList {
      get { return enumType_; } 
    }
    public int EnumTypeCount
      { get { return enumType_.Count; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto GetEnumType(int index) {
      return enumType_ [index];
    }
    
    // repeated .google.protobuf.ServiceDescriptorProto service = 6;
    private scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto> service_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>.Empty;
    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto> ServiceList {
      get { return service_; } 
    }
    public int ServiceCount
      { get { return service_.Count; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto GetService(int index) {
      return service_ [index];
    }
    
    // repeated .google.protobuf.FieldDescriptorProto extension = 7;
    private scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> extension_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty;
    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList {
      get { return extension_; } 
    }
    public int ExtensionCount
      { get { return extension_.Count; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetExtension(int index) {
      return extension_ [index];
    }
    
    // optional .google.protobuf.FileOptions options = 8;
    private bool hasOptions;
    private global::Google.ProtocolBuffers.DescriptorProtos.FileOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance;
    public bool HasOptions {
      get { return hasOptions; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions Options {
      get { return options_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasName) {
        output.WriteString(1, Name);
      }
      if (HasPackage) {
        output.WriteString(2, Package);
      }
      foreach (string element in DependencyList) {
        output.WriteString(3, element);
      }
      foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in MessageTypeList) {
        output.WriteMessage(4, element);
      }
      foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) {
        output.WriteMessage(5, element);
      }
      foreach (global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto element in ServiceList) {
        output.WriteMessage(6, element);
      }
      foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) {
        output.WriteMessage(7, element);
      }
      if (HasOptions) {
        output.WriteMessage(8, Options);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasName) {
          size += pb::CodedOutputStream.ComputeStringSize(1, Name);
        }
        if (HasPackage) {
          size += pb::CodedOutputStream.ComputeStringSize(2, Package);
        }
        foreach (string element in DependencyList) {
          size += pb::CodedOutputStream
            .ComputeStringSize(3, element);
        }
        foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in MessageTypeList) {
          size += pb::CodedOutputStream.ComputeMessageSize(4, element);
        }
        foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) {
          size += pb::CodedOutputStream.ComputeMessageSize(5, element);
        }
        foreach (global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto element in ServiceList) {
          size += pb::CodedOutputStream.ComputeMessageSize(6, element);
        }
        foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) {
          size += pb::CodedOutputStream.ComputeMessageSize(7, element);
        }
        if (HasOptions) {
          size += pb::CodedOutputStream.ComputeMessageSize(8, Options);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto BuildPartial() {
        result.dependency_ = pbc::Lists<string>.AsReadOnly(result.dependency_);
        if (result.messageType_ != pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty) {
          result.messageType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.AsReadOnly(result.messageType_);
        }
        if (result.enumType_ != pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty) {
          result.enumType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.AsReadOnly(result.enumType_);
        }
        if (result.service_ != pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>.Empty) {
          result.service_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>.AsReadOnly(result.service_);
        }
        if (result.extension_ != pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.extension_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.AsReadOnly(result.extension_);
        }
        global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.FileDescriptorProto.DefaultInstance) return this;
        if (other.HasName) {
          Name = other.Name;
        }
        if (other.HasPackage) {
          Package = other.Package;
        }
        if (other.dependency_.Count != 0) {
          if (result.dependency_.Count == 0) {
            result.dependency_ = new scg::List<string>();
          }
          base.AddRange(other.dependency_, result.dependency_);
        }
        if (other.messageType_.Count != 0) {
          if (result.messageType_.Count == 0) {
            result.messageType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>();
          }
          base.AddRange(other.messageType_, result.messageType_);
        }
        if (other.enumType_.Count != 0) {
          if (result.enumType_.Count == 0) {
            result.enumType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>();
          }
          base.AddRange(other.enumType_, result.enumType_);
        }
        if (other.service_.Count != 0) {
          if (result.service_.Count == 0) {
            result.service_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>();
          }
          base.AddRange(other.service_, result.service_);
        }
        if (other.extension_.Count != 0) {
          if (result.extension_.Count == 0) {
            result.extension_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
          }
          base.AddRange(other.extension_, result.extension_);
        }
        if (other.HasOptions) {
          MergeOptions(other.Options);
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
            case 10: {
              Name = input.ReadString();
              break;
            }
            case 18: {
              Package = input.ReadString();
              break;
            }
            case 26: {
              AddDependency(input.ReadString());
              break;
            }
            case 34: {
              global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddMessageType(subBuilder.BuildPartial());
              break;
            }
            case 42: {
              global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddEnumType(subBuilder.BuildPartial());
              break;
            }
            case 50: {
              global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddService(subBuilder.BuildPartial());
              break;
            }
            case 58: {
              global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddExtension(subBuilder.BuildPartial());
              break;
            }
            case 66: {
              global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder();
              if (HasOptions) {
                subBuilder.MergeFrom(Options);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              Options = subBuilder.BuildPartial();
              break;
            }
          }
        }
      }
      
      
      // optional string name = 1;
      public bool HasName {
        get { return result.HasName; }
      }
      public string Name {
        get { return result.Name; }
        set { SetName(value); }
      }
      public Builder SetName(string value) {
        result.hasName = true;
        result.name_ = value;
        return this;
      }
      public Builder ClearName() {
        result.hasName = false;
        result.name_ = "";
        return this;
      }
      
      // optional string package = 2;
      public bool HasPackage {
        get { return result.HasPackage; }
      }
      public string Package {
        get { return result.Package; }
        set { SetPackage(value); }
      }
      public Builder SetPackage(string value) {
        result.hasPackage = true;
        result.package_ = value;
        return this;
      }
      public Builder ClearPackage() {
        result.hasPackage = false;
        result.package_ = "";
        return this;
      }
      
      // repeated string dependency = 3;
      public scg::IList<string> DependencyList {
        get { return pbc::Lists<string>.AsReadOnly(result.dependency_); }
      }
      public int DependencyCount {
        get { return result.DependencyCount; }
      }
      public string GetDependency(int index) {
        return result.GetDependency(index);
      }
      public Builder SetDependency(int index, string value) {
        result.dependency_[index] = value;
        return this;
      }
      public Builder AddDependency(string value) {
        if (result.dependency_.Count == 0) {
          result.dependency_ = new scg::List<string>();
        }
        result.dependency_.Add(value);
        return this;
      }
      public Builder AddRangeDependency(scg::IEnumerable<string> values) {
        if (result.dependency_.Count == 0) {
          result.dependency_ = new scg::List<string>();
        }
        base.AddRange(values, result.dependency_);
        return this;
      }
      public Builder ClearDependency() {
        result.dependency_ = pbc::Lists<string>.Empty;
        return this;
      }
      
      // repeated .google.protobuf.DescriptorProto message_type = 4;
      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> MessageTypeList {
        get { return pbc::Lists.AsReadOnly(result.messageType_); }
      }
      public int MessageTypeCount {
        get { return result.MessageTypeCount; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto GetMessageType(int index) {
        return result.GetMessageType(index);
      }
      public Builder SetMessageType(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto value) {
        result.messageType_[index] = value;
        return this;
      }
      public Builder SetMessageType(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder builderForValue) {
        result.messageType_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddMessageType(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto value) {
        if (result.messageType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty) {
          result.messageType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>();
        }
        result.messageType_.Add(value);
        return this;
      }
      public Builder AddMessageType(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder builderForValue) {
        if (result.messageType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty) {
          result.messageType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>();
        }
        result.messageType_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeMessageType(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> values) {
        if (result.messageType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty) {
          result.messageType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>();
        }
        base.AddRange(values, result.messageType_);
        return this;
      }
      public Builder ClearMessageType() {
        result.messageType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty;
        return this;
      }
      
      // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList {
        get { return pbc::Lists.AsReadOnly(result.enumType_); }
      }
      public int EnumTypeCount {
        get { return result.EnumTypeCount; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto GetEnumType(int index) {
        return result.GetEnumType(index);
      }
      public Builder SetEnumType(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto value) {
        result.enumType_[index] = value;
        return this;
      }
      public Builder SetEnumType(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder builderForValue) {
        result.enumType_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddEnumType(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto value) {
        if (result.enumType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty) {
          result.enumType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>();
        }
        result.enumType_.Add(value);
        return this;
      }
      public Builder AddEnumType(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder builderForValue) {
        if (result.enumType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty) {
          result.enumType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>();
        }
        result.enumType_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeEnumType(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> values) {
        if (result.enumType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty) {
          result.enumType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>();
        }
        base.AddRange(values, result.enumType_);
        return this;
      }
      public Builder ClearEnumType() {
        result.enumType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty;
        return this;
      }
      
      // repeated .google.protobuf.ServiceDescriptorProto service = 6;
      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto> ServiceList {
        get { return pbc::Lists.AsReadOnly(result.service_); }
      }
      public int ServiceCount {
        get { return result.ServiceCount; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto GetService(int index) {
        return result.GetService(index);
      }
      public Builder SetService(int index, global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto value) {
        result.service_[index] = value;
        return this;
      }
      public Builder SetService(int index, global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder builderForValue) {
        result.service_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddService(global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto value) {
        if (result.service_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>.Empty) {
          result.service_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>();
        }
        result.service_.Add(value);
        return this;
      }
      public Builder AddService(global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Builder builderForValue) {
        if (result.service_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>.Empty) {
          result.service_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>();
        }
        result.service_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeService(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto> values) {
        if (result.service_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>.Empty) {
          result.service_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>();
        }
        base.AddRange(values, result.service_);
        return this;
      }
      public Builder ClearService() {
        result.service_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto>.Empty;
        return this;
      }
      
      // repeated .google.protobuf.FieldDescriptorProto extension = 7;
      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList {
        get { return pbc::Lists.AsReadOnly(result.extension_); }
      }
      public int ExtensionCount {
        get { return result.ExtensionCount; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetExtension(int index) {
        return result.GetExtension(index);
      }
      public Builder SetExtension(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) {
        result.extension_[index] = value;
        return this;
      }
      public Builder SetExtension(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) {
        result.extension_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddExtension(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) {
        if (result.extension_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.extension_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
        }
        result.extension_.Add(value);
        return this;
      }
      public Builder AddExtension(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) {
        if (result.extension_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.extension_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
        }
        result.extension_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeExtension(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> values) {
        if (result.extension_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.extension_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
        }
        base.AddRange(values, result.extension_);
        return this;
      }
      public Builder ClearExtension() {
        result.extension_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty;
        return this;
      }
      
      // optional .google.protobuf.FileOptions options = 8;
      public bool HasOptions {
        get { return result.HasOptions; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions Options {
        get { return result.Options; }
        set { SetOptions(value); }
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions value) {
        result.hasOptions = true;
        result.options_ = value;
        return this;
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Builder builderForValue) {
        result.hasOptions = true;
        result.options_ = builderForValue.Build();
        return this;
      }
      public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions value) {
        if (result.HasOptions &&
            result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance) {
          result.options_ =
            global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
        } else {
          result.options_ = value;
        }
        result.hasOptions = true;
        return this;
      }
      public Builder ClearOptions() {
        result.hasOptions = false;
        result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance;
        return this;
      }
    }
  }
  
  public sealed partial class DescriptorProto : pb::GeneratedMessage<DescriptorProto, DescriptorProto.Builder> {
    private static readonly DescriptorProto defaultInstance = new DescriptorProto();
    public static DescriptorProto DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override DescriptorProto DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override DescriptorProto ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_DescriptorProto__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<DescriptorProto, DescriptorProto.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_DescriptorProto__FieldAccessorTable; }
    }
    
    #region Nested types
    public static class Types {
      public sealed partial class ExtensionRange : pb::GeneratedMessage<ExtensionRange, ExtensionRange.Builder> {
        private static readonly ExtensionRange defaultInstance = new ExtensionRange();
        public static ExtensionRange DefaultInstance {
          get { return defaultInstance; }
        }
        
        public override ExtensionRange DefaultInstanceForType {
          get { return defaultInstance; }
        }
        
        protected override ExtensionRange ThisMessage {
          get { return this; }
        }
        
        public static pbd::MessageDescriptor Descriptor {
          get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_DescriptorProto_ExtensionRange__Descriptor; }
        }
        
        protected override pb::FieldAccess.FieldAccessorTable<ExtensionRange, ExtensionRange.Builder> InternalFieldAccessors {
          get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_DescriptorProto_ExtensionRange__FieldAccessorTable; }
        }
        
        // optional int32 start = 1;
        private bool hasStart;
        private int start_ = 0;
        public bool HasStart {
          get { return hasStart; }
        }
        public int Start {
          get { return start_; }
        }
        
        // optional int32 end = 2;
        private bool hasEnd;
        private int end_ = 0;
        public bool HasEnd {
          get { return hasEnd; }
        }
        public int End {
          get { return end_; }
        }
        
        public override bool IsInitialized {
          get {
            return true;
          }
        }
        
        public override void WriteTo(pb::CodedOutputStream output) {
          if (HasStart) {
            output.WriteInt32(1, Start);
          }
          if (HasEnd) {
            output.WriteInt32(2, End);
          }
          UnknownFields.WriteTo(output);
        }
        
        private int memoizedSerializedSize = -1;
        public override int SerializedSize {
          get {
            int size = memoizedSerializedSize;
            if (size != -1) return size;
            
            size = 0;
            if (HasStart) {
              size += pb::CodedOutputStream.ComputeInt32Size(1, Start);
            }
            if (HasEnd) {
              size += pb::CodedOutputStream.ComputeInt32Size(2, End);
            }
            size += UnknownFields.SerializedSize;
            memoizedSerializedSize = size;
            return size;
          }
        }
        
        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(pb::ByteString data) {
          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(pb::ByteString data,
            pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
                   .BuildParsed();
        }
        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(byte[] data) {
          return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
        }
        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(byte[] data,
            pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
                   .BuildParsed();
        }
        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(global::System.IO.Stream input) {
          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(
            global::System.IO.Stream input,
            pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
                   .BuildParsed();
        }
        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(pb::CodedInputStream input) {
          return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
        }
        public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange ParseFrom(pb::CodedInputStream input,
            pb::ExtensionRegistry extensionRegistry) {
          return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
                   .BuildParsed();
        }
        
        public static Builder CreateBuilder() { return new Builder(); }
        public override Builder CreateBuilderForType() { return new Builder(); }
        public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange prototype) {
          return (Builder) new Builder().MergeFrom(prototype);
        }
        
        public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange, Builder> {
          protected override Builder ThisBuilder {
            get { return this; }
          }
          
          // Construct using global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.CreateBuilder()
          internal Builder() {}
          
          global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange result = new global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange();
          
          protected override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange MessageBeingBuilt {
            get { return result; }
          }
          
          public override Builder Clear() {
            result = new global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange();
            return this;
          }
          
          public override Builder Clone() {
            return new Builder().MergeFrom(result);
          }
          
          public override pbd::MessageDescriptor DescriptorForType {
            get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Descriptor; }
          }
          
          public override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange DefaultInstanceForType {
            get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.DefaultInstance; }
          }
          
          public override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange BuildPartial() {
            global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange returnMe = result;
            result = null;
            return returnMe;
          }
          
          public override Builder MergeFrom(pb::IMessage other) {
            if (other is global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange) {
              return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange) other);
            } else {
              base.MergeFrom(other);
              return this;
            }
          }
          
          public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange other) {
            if (other == global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.DefaultInstance) return this;
            if (other.HasStart) {
              Start = other.Start;
            }
            if (other.HasEnd) {
              End = other.End;
            }
            this.MergeUnknownFields(other.UnknownFields);
            return this;
          }
          
          public override Builder MergeFrom(pb::CodedInputStream input) {
            return MergeFrom(input, pb::ExtensionRegistry.Empty);
          }
          
          public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
            pb::UnknownFieldSet.Builder unknownFields =
              pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
            while (true) {
              uint tag = input.ReadTag();
              switch (tag) {
                case 0:
                  this.UnknownFields = unknownFields.Build();
                  return this;
                default: {
                  if (!ParseUnknownField(input, unknownFields,
                                         extensionRegistry, tag)) {
                    this.UnknownFields = unknownFields.Build();
                    return this;
                  }
                  break;
                }
                case 8: {
                  Start = input.ReadInt32();
                  break;
                }
                case 16: {
                  End = input.ReadInt32();
                  break;
                }
              }
            }
          }
          
          
          // optional int32 start = 1;
          public bool HasStart {
            get { return result.HasStart; }
          }
          public int Start {
            get { return result.Start; }
            set { SetStart(value); }
          }
          public Builder SetStart(int value) {
            result.hasStart = true;
            result.start_ = value;
            return this;
          }
          public Builder ClearStart() {
            result.hasStart = false;
            result.start_ = 0;
            return this;
          }
          
          // optional int32 end = 2;
          public bool HasEnd {
            get { return result.HasEnd; }
          }
          public int End {
            get { return result.End; }
            set { SetEnd(value); }
          }
          public Builder SetEnd(int value) {
            result.hasEnd = true;
            result.end_ = value;
            return this;
          }
          public Builder ClearEnd() {
            result.hasEnd = false;
            result.end_ = 0;
            return this;
          }
        }
      }
      
    }
    #endregion
    
    // optional string name = 1;
    private bool hasName;
    private string name_ = "";
    public bool HasName {
      get { return hasName; }
    }
    public string Name {
      get { return name_; }
    }
    
    // repeated .google.protobuf.FieldDescriptorProto field = 2;
    private scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> field_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty;
    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> FieldList {
      get { return field_; } 
    }
    public int FieldCount
      { get { return field_.Count; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetField(int index) {
      return field_ [index];
    }
    
    // repeated .google.protobuf.FieldDescriptorProto extension = 6;
    private scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> extension_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty;
    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList {
      get { return extension_; } 
    }
    public int ExtensionCount
      { get { return extension_.Count; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetExtension(int index) {
      return extension_ [index];
    }
    
    // repeated .google.protobuf.DescriptorProto nested_type = 3;
    private scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> nestedType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty;
    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> NestedTypeList {
      get { return nestedType_; } 
    }
    public int NestedTypeCount
      { get { return nestedType_.Count; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto GetNestedType(int index) {
      return nestedType_ [index];
    }
    
    // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
    private scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> enumType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty;
    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList {
      get { return enumType_; } 
    }
    public int EnumTypeCount
      { get { return enumType_.Count; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto GetEnumType(int index) {
      return enumType_ [index];
    }
    
    // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
    private scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange> extensionRange_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>.Empty;
    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange> ExtensionRangeList {
      get { return extensionRange_; } 
    }
    public int ExtensionRangeCount
      { get { return extensionRange_.Count; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange GetExtensionRange(int index) {
      return extensionRange_ [index];
    }
    
    // optional .google.protobuf.MessageOptions options = 7;
    private bool hasOptions;
    private global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance;
    public bool HasOptions {
      get { return hasOptions; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions Options {
      get { return options_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasName) {
        output.WriteString(1, Name);
      }
      foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in FieldList) {
        output.WriteMessage(2, element);
      }
      foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in NestedTypeList) {
        output.WriteMessage(3, element);
      }
      foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) {
        output.WriteMessage(4, element);
      }
      foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange element in ExtensionRangeList) {
        output.WriteMessage(5, element);
      }
      foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) {
        output.WriteMessage(6, element);
      }
      if (HasOptions) {
        output.WriteMessage(7, Options);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasName) {
          size += pb::CodedOutputStream.ComputeStringSize(1, Name);
        }
        foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in FieldList) {
          size += pb::CodedOutputStream.ComputeMessageSize(2, element);
        }
        foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto element in NestedTypeList) {
          size += pb::CodedOutputStream.ComputeMessageSize(3, element);
        }
        foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto element in EnumTypeList) {
          size += pb::CodedOutputStream.ComputeMessageSize(4, element);
        }
        foreach (global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange element in ExtensionRangeList) {
          size += pb::CodedOutputStream.ComputeMessageSize(5, element);
        }
        foreach (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto element in ExtensionList) {
          size += pb::CodedOutputStream.ComputeMessageSize(6, element);
        }
        if (HasOptions) {
          size += pb::CodedOutputStream.ComputeMessageSize(7, Options);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto BuildPartial() {
        if (result.field_ != pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.field_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.AsReadOnly(result.field_);
        }
        if (result.extension_ != pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.extension_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.AsReadOnly(result.extension_);
        }
        if (result.nestedType_ != pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty) {
          result.nestedType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.AsReadOnly(result.nestedType_);
        }
        if (result.enumType_ != pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty) {
          result.enumType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.AsReadOnly(result.enumType_);
        }
        if (result.extensionRange_ != pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>.Empty) {
          result.extensionRange_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>.AsReadOnly(result.extensionRange_);
        }
        global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.DefaultInstance) return this;
        if (other.HasName) {
          Name = other.Name;
        }
        if (other.field_.Count != 0) {
          if (result.field_.Count == 0) {
            result.field_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
          }
          base.AddRange(other.field_, result.field_);
        }
        if (other.extension_.Count != 0) {
          if (result.extension_.Count == 0) {
            result.extension_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
          }
          base.AddRange(other.extension_, result.extension_);
        }
        if (other.nestedType_.Count != 0) {
          if (result.nestedType_.Count == 0) {
            result.nestedType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>();
          }
          base.AddRange(other.nestedType_, result.nestedType_);
        }
        if (other.enumType_.Count != 0) {
          if (result.enumType_.Count == 0) {
            result.enumType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>();
          }
          base.AddRange(other.enumType_, result.enumType_);
        }
        if (other.extensionRange_.Count != 0) {
          if (result.extensionRange_.Count == 0) {
            result.extensionRange_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>();
          }
          base.AddRange(other.extensionRange_, result.extensionRange_);
        }
        if (other.HasOptions) {
          MergeOptions(other.Options);
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
            case 10: {
              Name = input.ReadString();
              break;
            }
            case 18: {
              global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddField(subBuilder.BuildPartial());
              break;
            }
            case 26: {
              global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddNestedType(subBuilder.BuildPartial());
              break;
            }
            case 34: {
              global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddEnumType(subBuilder.BuildPartial());
              break;
            }
            case 42: {
              global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddExtensionRange(subBuilder.BuildPartial());
              break;
            }
            case 50: {
              global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddExtension(subBuilder.BuildPartial());
              break;
            }
            case 58: {
              global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.CreateBuilder();
              if (HasOptions) {
                subBuilder.MergeFrom(Options);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              Options = subBuilder.BuildPartial();
              break;
            }
          }
        }
      }
      
      
      // optional string name = 1;
      public bool HasName {
        get { return result.HasName; }
      }
      public string Name {
        get { return result.Name; }
        set { SetName(value); }
      }
      public Builder SetName(string value) {
        result.hasName = true;
        result.name_ = value;
        return this;
      }
      public Builder ClearName() {
        result.hasName = false;
        result.name_ = "";
        return this;
      }
      
      // repeated .google.protobuf.FieldDescriptorProto field = 2;
      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> FieldList {
        get { return pbc::Lists.AsReadOnly(result.field_); }
      }
      public int FieldCount {
        get { return result.FieldCount; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetField(int index) {
        return result.GetField(index);
      }
      public Builder SetField(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) {
        result.field_[index] = value;
        return this;
      }
      public Builder SetField(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) {
        result.field_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddField(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) {
        if (result.field_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.field_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
        }
        result.field_.Add(value);
        return this;
      }
      public Builder AddField(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) {
        if (result.field_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.field_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
        }
        result.field_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeField(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> values) {
        if (result.field_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.field_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
        }
        base.AddRange(values, result.field_);
        return this;
      }
      public Builder ClearField() {
        result.field_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty;
        return this;
      }
      
      // repeated .google.protobuf.FieldDescriptorProto extension = 6;
      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> ExtensionList {
        get { return pbc::Lists.AsReadOnly(result.extension_); }
      }
      public int ExtensionCount {
        get { return result.ExtensionCount; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto GetExtension(int index) {
        return result.GetExtension(index);
      }
      public Builder SetExtension(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) {
        result.extension_[index] = value;
        return this;
      }
      public Builder SetExtension(int index, global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) {
        result.extension_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddExtension(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto value) {
        if (result.extension_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.extension_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
        }
        result.extension_.Add(value);
        return this;
      }
      public Builder AddExtension(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Builder builderForValue) {
        if (result.extension_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.extension_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
        }
        result.extension_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeExtension(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto> values) {
        if (result.extension_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty) {
          result.extension_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>();
        }
        base.AddRange(values, result.extension_);
        return this;
      }
      public Builder ClearExtension() {
        result.extension_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto>.Empty;
        return this;
      }
      
      // repeated .google.protobuf.DescriptorProto nested_type = 3;
      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> NestedTypeList {
        get { return pbc::Lists.AsReadOnly(result.nestedType_); }
      }
      public int NestedTypeCount {
        get { return result.NestedTypeCount; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto GetNestedType(int index) {
        return result.GetNestedType(index);
      }
      public Builder SetNestedType(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto value) {
        result.nestedType_[index] = value;
        return this;
      }
      public Builder SetNestedType(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder builderForValue) {
        result.nestedType_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddNestedType(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto value) {
        if (result.nestedType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty) {
          result.nestedType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>();
        }
        result.nestedType_.Add(value);
        return this;
      }
      public Builder AddNestedType(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Builder builderForValue) {
        if (result.nestedType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty) {
          result.nestedType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>();
        }
        result.nestedType_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeNestedType(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto> values) {
        if (result.nestedType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty) {
          result.nestedType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>();
        }
        base.AddRange(values, result.nestedType_);
        return this;
      }
      public Builder ClearNestedType() {
        result.nestedType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto>.Empty;
        return this;
      }
      
      // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> EnumTypeList {
        get { return pbc::Lists.AsReadOnly(result.enumType_); }
      }
      public int EnumTypeCount {
        get { return result.EnumTypeCount; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto GetEnumType(int index) {
        return result.GetEnumType(index);
      }
      public Builder SetEnumType(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto value) {
        result.enumType_[index] = value;
        return this;
      }
      public Builder SetEnumType(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder builderForValue) {
        result.enumType_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddEnumType(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto value) {
        if (result.enumType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty) {
          result.enumType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>();
        }
        result.enumType_.Add(value);
        return this;
      }
      public Builder AddEnumType(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Builder builderForValue) {
        if (result.enumType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty) {
          result.enumType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>();
        }
        result.enumType_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeEnumType(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto> values) {
        if (result.enumType_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty) {
          result.enumType_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>();
        }
        base.AddRange(values, result.enumType_);
        return this;
      }
      public Builder ClearEnumType() {
        result.enumType_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto>.Empty;
        return this;
      }
      
      // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange> ExtensionRangeList {
        get { return pbc::Lists.AsReadOnly(result.extensionRange_); }
      }
      public int ExtensionRangeCount {
        get { return result.ExtensionRangeCount; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange GetExtensionRange(int index) {
        return result.GetExtensionRange(index);
      }
      public Builder SetExtensionRange(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange value) {
        result.extensionRange_[index] = value;
        return this;
      }
      public Builder SetExtensionRange(int index, global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder builderForValue) {
        result.extensionRange_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddExtensionRange(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange value) {
        if (result.extensionRange_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>.Empty) {
          result.extensionRange_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>();
        }
        result.extensionRange_.Add(value);
        return this;
      }
      public Builder AddExtensionRange(global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange.Builder builderForValue) {
        if (result.extensionRange_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>.Empty) {
          result.extensionRange_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>();
        }
        result.extensionRange_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeExtensionRange(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange> values) {
        if (result.extensionRange_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>.Empty) {
          result.extensionRange_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>();
        }
        base.AddRange(values, result.extensionRange_);
        return this;
      }
      public Builder ClearExtensionRange() {
        result.extensionRange_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProto.Types.ExtensionRange>.Empty;
        return this;
      }
      
      // optional .google.protobuf.MessageOptions options = 7;
      public bool HasOptions {
        get { return result.HasOptions; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions Options {
        get { return result.Options; }
        set { SetOptions(value); }
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions value) {
        result.hasOptions = true;
        result.options_ = value;
        return this;
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Builder builderForValue) {
        result.hasOptions = true;
        result.options_ = builderForValue.Build();
        return this;
      }
      public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions value) {
        if (result.HasOptions &&
            result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance) {
          result.options_ =
            global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
        } else {
          result.options_ = value;
        }
        result.hasOptions = true;
        return this;
      }
      public Builder ClearOptions() {
        result.hasOptions = false;
        result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance;
        return this;
      }
    }
  }
  
  public sealed partial class FieldDescriptorProto : pb::GeneratedMessage<FieldDescriptorProto, FieldDescriptorProto.Builder> {
    private static readonly FieldDescriptorProto defaultInstance = new FieldDescriptorProto();
    public static FieldDescriptorProto DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override FieldDescriptorProto DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override FieldDescriptorProto ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FieldDescriptorProto__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<FieldDescriptorProto, FieldDescriptorProto.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FieldDescriptorProto__FieldAccessorTable; }
    }
    
    #region Nested types
    public static class Types {
      public enum Type {
        TYPE_DOUBLE = 1,
        TYPE_FLOAT = 2,
        TYPE_INT64 = 3,
        TYPE_UINT64 = 4,
        TYPE_INT32 = 5,
        TYPE_FIXED64 = 6,
        TYPE_FIXED32 = 7,
        TYPE_BOOL = 8,
        TYPE_STRING = 9,
        TYPE_GROUP = 10,
        TYPE_MESSAGE = 11,
        TYPE_BYTES = 12,
        TYPE_UINT32 = 13,
        TYPE_ENUM = 14,
        TYPE_SFIXED32 = 15,
        TYPE_SFIXED64 = 16,
        TYPE_SINT32 = 17,
        TYPE_SINT64 = 18,
      }
      
      public enum Label {
        LABEL_OPTIONAL = 1,
        LABEL_REQUIRED = 2,
        LABEL_REPEATED = 3,
      }
      
    }
    #endregion
    
    // optional string name = 1;
    private bool hasName;
    private string name_ = "";
    public bool HasName {
      get { return hasName; }
    }
    public string Name {
      get { return name_; }
    }
    
    // optional int32 number = 3;
    private bool hasNumber;
    private int number_ = 0;
    public bool HasNumber {
      get { return hasNumber; }
    }
    public int Number {
      get { return number_; }
    }
    
    // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
    private bool hasLabel;
    private global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label label_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label.LABEL_OPTIONAL;
    public bool HasLabel {
      get { return hasLabel; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label Label {  get { return label_; }}
    
    // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
    private bool hasType;
    private global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type type_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type.TYPE_DOUBLE;
    public bool HasType {
      get { return hasType; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type Type {  get { return type_; }}
    
    // optional string type_name = 6;
    private bool hasTypeName;
    private string typeName_ = "";
    public bool HasTypeName {
      get { return hasTypeName; }
    }
    public string TypeName {
      get { return typeName_; }
    }
    
    // optional string extendee = 2;
    private bool hasExtendee;
    private string extendee_ = "";
    public bool HasExtendee {
      get { return hasExtendee; }
    }
    public string Extendee {
      get { return extendee_; }
    }
    
    // optional string default_value = 7;
    private bool hasDefaultValue;
    private string defaultValue_ = "";
    public bool HasDefaultValue {
      get { return hasDefaultValue; }
    }
    public string DefaultValue {
      get { return defaultValue_; }
    }
    
    // optional .google.protobuf.FieldOptions options = 8;
    private bool hasOptions;
    private global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance;
    public bool HasOptions {
      get { return hasOptions; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions Options {
      get { return options_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasName) {
        output.WriteString(1, Name);
      }
      if (HasExtendee) {
        output.WriteString(2, Extendee);
      }
      if (HasNumber) {
        output.WriteInt32(3, Number);
      }
      if (HasLabel) {
        output.WriteEnum(4, (int) Label);
      }
      if (HasType) {
        output.WriteEnum(5, (int) Type);
      }
      if (HasTypeName) {
        output.WriteString(6, TypeName);
      }
      if (HasDefaultValue) {
        output.WriteString(7, DefaultValue);
      }
      if (HasOptions) {
        output.WriteMessage(8, Options);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasName) {
          size += pb::CodedOutputStream.ComputeStringSize(1, Name);
        }
        if (HasExtendee) {
          size += pb::CodedOutputStream.ComputeStringSize(2, Extendee);
        }
        if (HasNumber) {
          size += pb::CodedOutputStream.ComputeInt32Size(3, Number);
        }
        if (HasLabel) {
          size += pb::CodedOutputStream
            .ComputeEnumSize(4, (int) Label);
        }
        if (HasType) {
          size += pb::CodedOutputStream
            .ComputeEnumSize(5, (int) Type);
        }
        if (HasTypeName) {
          size += pb::CodedOutputStream.ComputeStringSize(6, TypeName);
        }
        if (HasDefaultValue) {
          size += pb::CodedOutputStream.ComputeStringSize(7, DefaultValue);
        }
        if (HasOptions) {
          size += pb::CodedOutputStream.ComputeMessageSize(8, Options);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto BuildPartial() {
        global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.DefaultInstance) return this;
        if (other.HasName) {
          Name = other.Name;
        }
        if (other.HasNumber) {
          Number = other.Number;
        }
        if (other.HasLabel) {
          Label = other.Label;
        }
        if (other.HasType) {
          Type = other.Type;
        }
        if (other.HasTypeName) {
          TypeName = other.TypeName;
        }
        if (other.HasExtendee) {
          Extendee = other.Extendee;
        }
        if (other.HasDefaultValue) {
          DefaultValue = other.DefaultValue;
        }
        if (other.HasOptions) {
          MergeOptions(other.Options);
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
            case 10: {
              Name = input.ReadString();
              break;
            }
            case 18: {
              Extendee = input.ReadString();
              break;
            }
            case 24: {
              Number = input.ReadInt32();
              break;
            }
            case 32: {
              int rawValue = input.ReadEnum();
              if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label), rawValue)) {
                unknownFields.MergeVarintField(4, (ulong) rawValue);
              } else {
                Label = (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label) rawValue;
              }
              break;
            }
            case 40: {
              int rawValue = input.ReadEnum();
              if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type), rawValue)) {
                unknownFields.MergeVarintField(5, (ulong) rawValue);
              } else {
                Type = (global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type) rawValue;
              }
              break;
            }
            case 50: {
              TypeName = input.ReadString();
              break;
            }
            case 58: {
              DefaultValue = input.ReadString();
              break;
            }
            case 66: {
              global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.CreateBuilder();
              if (HasOptions) {
                subBuilder.MergeFrom(Options);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              Options = subBuilder.BuildPartial();
              break;
            }
          }
        }
      }
      
      
      // optional string name = 1;
      public bool HasName {
        get { return result.HasName; }
      }
      public string Name {
        get { return result.Name; }
        set { SetName(value); }
      }
      public Builder SetName(string value) {
        result.hasName = true;
        result.name_ = value;
        return this;
      }
      public Builder ClearName() {
        result.hasName = false;
        result.name_ = "";
        return this;
      }
      
      // optional int32 number = 3;
      public bool HasNumber {
        get { return result.HasNumber; }
      }
      public int Number {
        get { return result.Number; }
        set { SetNumber(value); }
      }
      public Builder SetNumber(int value) {
        result.hasNumber = true;
        result.number_ = value;
        return this;
      }
      public Builder ClearNumber() {
        result.hasNumber = false;
        result.number_ = 0;
        return this;
      }
      
      // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
      public bool HasLabel {
        get { return result.HasLabel; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label Label {
        get { return result.Label; }
        set { SetLabel(value); }
      }
      public Builder SetLabel(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label value) {
        result.hasLabel = true;
        result.label_ = value;
        return this;
      }
      public Builder ClearLabel() {
        result.hasLabel = false;
        result.label_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Label.LABEL_OPTIONAL;
        return this;
      }
      
      // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
      public bool HasType {
        get { return result.HasType; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type Type {
        get { return result.Type; }
        set { SetType(value); }
      }
      public Builder SetType(global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type value) {
        result.hasType = true;
        result.type_ = value;
        return this;
      }
      public Builder ClearType() {
        result.hasType = false;
        result.type_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldDescriptorProto.Types.Type.TYPE_DOUBLE;
        return this;
      }
      
      // optional string type_name = 6;
      public bool HasTypeName {
        get { return result.HasTypeName; }
      }
      public string TypeName {
        get { return result.TypeName; }
        set { SetTypeName(value); }
      }
      public Builder SetTypeName(string value) {
        result.hasTypeName = true;
        result.typeName_ = value;
        return this;
      }
      public Builder ClearTypeName() {
        result.hasTypeName = false;
        result.typeName_ = "";
        return this;
      }
      
      // optional string extendee = 2;
      public bool HasExtendee {
        get { return result.HasExtendee; }
      }
      public string Extendee {
        get { return result.Extendee; }
        set { SetExtendee(value); }
      }
      public Builder SetExtendee(string value) {
        result.hasExtendee = true;
        result.extendee_ = value;
        return this;
      }
      public Builder ClearExtendee() {
        result.hasExtendee = false;
        result.extendee_ = "";
        return this;
      }
      
      // optional string default_value = 7;
      public bool HasDefaultValue {
        get { return result.HasDefaultValue; }
      }
      public string DefaultValue {
        get { return result.DefaultValue; }
        set { SetDefaultValue(value); }
      }
      public Builder SetDefaultValue(string value) {
        result.hasDefaultValue = true;
        result.defaultValue_ = value;
        return this;
      }
      public Builder ClearDefaultValue() {
        result.hasDefaultValue = false;
        result.defaultValue_ = "";
        return this;
      }
      
      // optional .google.protobuf.FieldOptions options = 8;
      public bool HasOptions {
        get { return result.HasOptions; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions Options {
        get { return result.Options; }
        set { SetOptions(value); }
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions value) {
        result.hasOptions = true;
        result.options_ = value;
        return this;
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Builder builderForValue) {
        result.hasOptions = true;
        result.options_ = builderForValue.Build();
        return this;
      }
      public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions value) {
        if (result.HasOptions &&
            result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance) {
          result.options_ =
            global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
        } else {
          result.options_ = value;
        }
        result.hasOptions = true;
        return this;
      }
      public Builder ClearOptions() {
        result.hasOptions = false;
        result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance;
        return this;
      }
    }
  }
  
  public sealed partial class EnumDescriptorProto : pb::GeneratedMessage<EnumDescriptorProto, EnumDescriptorProto.Builder> {
    private static readonly EnumDescriptorProto defaultInstance = new EnumDescriptorProto();
    public static EnumDescriptorProto DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override EnumDescriptorProto DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override EnumDescriptorProto ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumDescriptorProto__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<EnumDescriptorProto, EnumDescriptorProto.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumDescriptorProto__FieldAccessorTable; }
    }
    
    // optional string name = 1;
    private bool hasName;
    private string name_ = "";
    public bool HasName {
      get { return hasName; }
    }
    public string Name {
      get { return name_; }
    }
    
    // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
    private scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto> value_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>.Empty;
    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto> ValueList {
      get { return value_; } 
    }
    public int ValueCount
      { get { return value_.Count; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto GetValue(int index) {
      return value_ [index];
    }
    
    // optional .google.protobuf.EnumOptions options = 3;
    private bool hasOptions;
    private global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance;
    public bool HasOptions {
      get { return hasOptions; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions Options {
      get { return options_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasName) {
        output.WriteString(1, Name);
      }
      foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto element in ValueList) {
        output.WriteMessage(2, element);
      }
      if (HasOptions) {
        output.WriteMessage(3, Options);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasName) {
          size += pb::CodedOutputStream.ComputeStringSize(1, Name);
        }
        foreach (global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto element in ValueList) {
          size += pb::CodedOutputStream.ComputeMessageSize(2, element);
        }
        if (HasOptions) {
          size += pb::CodedOutputStream.ComputeMessageSize(3, Options);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto BuildPartial() {
        if (result.value_ != pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>.Empty) {
          result.value_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>.AsReadOnly(result.value_);
        }
        global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.EnumDescriptorProto.DefaultInstance) return this;
        if (other.HasName) {
          Name = other.Name;
        }
        if (other.value_.Count != 0) {
          if (result.value_.Count == 0) {
            result.value_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>();
          }
          base.AddRange(other.value_, result.value_);
        }
        if (other.HasOptions) {
          MergeOptions(other.Options);
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
            case 10: {
              Name = input.ReadString();
              break;
            }
            case 18: {
              global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddValue(subBuilder.BuildPartial());
              break;
            }
            case 26: {
              global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.CreateBuilder();
              if (HasOptions) {
                subBuilder.MergeFrom(Options);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              Options = subBuilder.BuildPartial();
              break;
            }
          }
        }
      }
      
      
      // optional string name = 1;
      public bool HasName {
        get { return result.HasName; }
      }
      public string Name {
        get { return result.Name; }
        set { SetName(value); }
      }
      public Builder SetName(string value) {
        result.hasName = true;
        result.name_ = value;
        return this;
      }
      public Builder ClearName() {
        result.hasName = false;
        result.name_ = "";
        return this;
      }
      
      // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto> ValueList {
        get { return pbc::Lists.AsReadOnly(result.value_); }
      }
      public int ValueCount {
        get { return result.ValueCount; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto GetValue(int index) {
        return result.GetValue(index);
      }
      public Builder SetValue(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto value) {
        result.value_[index] = value;
        return this;
      }
      public Builder SetValue(int index, global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder builderForValue) {
        result.value_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddValue(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto value) {
        if (result.value_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>.Empty) {
          result.value_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>();
        }
        result.value_.Add(value);
        return this;
      }
      public Builder AddValue(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Builder builderForValue) {
        if (result.value_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>.Empty) {
          result.value_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>();
        }
        result.value_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeValue(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto> values) {
        if (result.value_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>.Empty) {
          result.value_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>();
        }
        base.AddRange(values, result.value_);
        return this;
      }
      public Builder ClearValue() {
        result.value_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto>.Empty;
        return this;
      }
      
      // optional .google.protobuf.EnumOptions options = 3;
      public bool HasOptions {
        get { return result.HasOptions; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions Options {
        get { return result.Options; }
        set { SetOptions(value); }
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions value) {
        result.hasOptions = true;
        result.options_ = value;
        return this;
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Builder builderForValue) {
        result.hasOptions = true;
        result.options_ = builderForValue.Build();
        return this;
      }
      public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions value) {
        if (result.HasOptions &&
            result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance) {
          result.options_ =
            global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
        } else {
          result.options_ = value;
        }
        result.hasOptions = true;
        return this;
      }
      public Builder ClearOptions() {
        result.hasOptions = false;
        result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance;
        return this;
      }
    }
  }
  
  public sealed partial class EnumValueDescriptorProto : pb::GeneratedMessage<EnumValueDescriptorProto, EnumValueDescriptorProto.Builder> {
    private static readonly EnumValueDescriptorProto defaultInstance = new EnumValueDescriptorProto();
    public static EnumValueDescriptorProto DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override EnumValueDescriptorProto DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override EnumValueDescriptorProto ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumValueDescriptorProto__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<EnumValueDescriptorProto, EnumValueDescriptorProto.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumValueDescriptorProto__FieldAccessorTable; }
    }
    
    // optional string name = 1;
    private bool hasName;
    private string name_ = "";
    public bool HasName {
      get { return hasName; }
    }
    public string Name {
      get { return name_; }
    }
    
    // optional int32 number = 2;
    private bool hasNumber;
    private int number_ = 0;
    public bool HasNumber {
      get { return hasNumber; }
    }
    public int Number {
      get { return number_; }
    }
    
    // optional .google.protobuf.EnumValueOptions options = 3;
    private bool hasOptions;
    private global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance;
    public bool HasOptions {
      get { return hasOptions; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions Options {
      get { return options_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasName) {
        output.WriteString(1, Name);
      }
      if (HasNumber) {
        output.WriteInt32(2, Number);
      }
      if (HasOptions) {
        output.WriteMessage(3, Options);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasName) {
          size += pb::CodedOutputStream.ComputeStringSize(1, Name);
        }
        if (HasNumber) {
          size += pb::CodedOutputStream.ComputeInt32Size(2, Number);
        }
        if (HasOptions) {
          size += pb::CodedOutputStream.ComputeMessageSize(3, Options);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto BuildPartial() {
        global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.EnumValueDescriptorProto.DefaultInstance) return this;
        if (other.HasName) {
          Name = other.Name;
        }
        if (other.HasNumber) {
          Number = other.Number;
        }
        if (other.HasOptions) {
          MergeOptions(other.Options);
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
            case 10: {
              Name = input.ReadString();
              break;
            }
            case 16: {
              Number = input.ReadInt32();
              break;
            }
            case 26: {
              global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.CreateBuilder();
              if (HasOptions) {
                subBuilder.MergeFrom(Options);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              Options = subBuilder.BuildPartial();
              break;
            }
          }
        }
      }
      
      
      // optional string name = 1;
      public bool HasName {
        get { return result.HasName; }
      }
      public string Name {
        get { return result.Name; }
        set { SetName(value); }
      }
      public Builder SetName(string value) {
        result.hasName = true;
        result.name_ = value;
        return this;
      }
      public Builder ClearName() {
        result.hasName = false;
        result.name_ = "";
        return this;
      }
      
      // optional int32 number = 2;
      public bool HasNumber {
        get { return result.HasNumber; }
      }
      public int Number {
        get { return result.Number; }
        set { SetNumber(value); }
      }
      public Builder SetNumber(int value) {
        result.hasNumber = true;
        result.number_ = value;
        return this;
      }
      public Builder ClearNumber() {
        result.hasNumber = false;
        result.number_ = 0;
        return this;
      }
      
      // optional .google.protobuf.EnumValueOptions options = 3;
      public bool HasOptions {
        get { return result.HasOptions; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions Options {
        get { return result.Options; }
        set { SetOptions(value); }
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions value) {
        result.hasOptions = true;
        result.options_ = value;
        return this;
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Builder builderForValue) {
        result.hasOptions = true;
        result.options_ = builderForValue.Build();
        return this;
      }
      public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions value) {
        if (result.HasOptions &&
            result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance) {
          result.options_ =
            global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
        } else {
          result.options_ = value;
        }
        result.hasOptions = true;
        return this;
      }
      public Builder ClearOptions() {
        result.hasOptions = false;
        result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance;
        return this;
      }
    }
  }
  
  public sealed partial class ServiceDescriptorProto : pb::GeneratedMessage<ServiceDescriptorProto, ServiceDescriptorProto.Builder> {
    private static readonly ServiceDescriptorProto defaultInstance = new ServiceDescriptorProto();
    public static ServiceDescriptorProto DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override ServiceDescriptorProto DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override ServiceDescriptorProto ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_ServiceDescriptorProto__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<ServiceDescriptorProto, ServiceDescriptorProto.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_ServiceDescriptorProto__FieldAccessorTable; }
    }
    
    // optional string name = 1;
    private bool hasName;
    private string name_ = "";
    public bool HasName {
      get { return hasName; }
    }
    public string Name {
      get { return name_; }
    }
    
    // repeated .google.protobuf.MethodDescriptorProto method = 2;
    private scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto> method_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>.Empty;
    public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto> MethodList {
      get { return method_; } 
    }
    public int MethodCount
      { get { return method_.Count; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto GetMethod(int index) {
      return method_ [index];
    }
    
    // optional .google.protobuf.ServiceOptions options = 3;
    private bool hasOptions;
    private global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance;
    public bool HasOptions {
      get { return hasOptions; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions Options {
      get { return options_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasName) {
        output.WriteString(1, Name);
      }
      foreach (global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto element in MethodList) {
        output.WriteMessage(2, element);
      }
      if (HasOptions) {
        output.WriteMessage(3, Options);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasName) {
          size += pb::CodedOutputStream.ComputeStringSize(1, Name);
        }
        foreach (global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto element in MethodList) {
          size += pb::CodedOutputStream.ComputeMessageSize(2, element);
        }
        if (HasOptions) {
          size += pb::CodedOutputStream.ComputeMessageSize(3, Options);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto BuildPartial() {
        if (result.method_ != pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>.Empty) {
          result.method_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>.AsReadOnly(result.method_);
        }
        global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.ServiceDescriptorProto.DefaultInstance) return this;
        if (other.HasName) {
          Name = other.Name;
        }
        if (other.method_.Count != 0) {
          if (result.method_.Count == 0) {
            result.method_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>();
          }
          base.AddRange(other.method_, result.method_);
        }
        if (other.HasOptions) {
          MergeOptions(other.Options);
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
            case 10: {
              Name = input.ReadString();
              break;
            }
            case 18: {
              global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.CreateBuilder();
              input.ReadMessage(subBuilder, extensionRegistry);
              AddMethod(subBuilder.BuildPartial());
              break;
            }
            case 26: {
              global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.CreateBuilder();
              if (HasOptions) {
                subBuilder.MergeFrom(Options);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              Options = subBuilder.BuildPartial();
              break;
            }
          }
        }
      }
      
      
      // optional string name = 1;
      public bool HasName {
        get { return result.HasName; }
      }
      public string Name {
        get { return result.Name; }
        set { SetName(value); }
      }
      public Builder SetName(string value) {
        result.hasName = true;
        result.name_ = value;
        return this;
      }
      public Builder ClearName() {
        result.hasName = false;
        result.name_ = "";
        return this;
      }
      
      // repeated .google.protobuf.MethodDescriptorProto method = 2;
      public scg::IList<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto> MethodList {
        get { return pbc::Lists.AsReadOnly(result.method_); }
      }
      public int MethodCount {
        get { return result.MethodCount; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto GetMethod(int index) {
        return result.GetMethod(index);
      }
      public Builder SetMethod(int index, global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto value) {
        result.method_[index] = value;
        return this;
      }
      public Builder SetMethod(int index, global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder builderForValue) {
        result.method_[index] = builderForValue.Build();
        return this;
      }
      public Builder AddMethod(global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto value) {
        if (result.method_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>.Empty) {
          result.method_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>();
        }
        result.method_.Add(value);
        return this;
      }
      public Builder AddMethod(global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Builder builderForValue) {
        if (result.method_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>.Empty) {
          result.method_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>();
        }
        result.method_.Add(builderForValue.Build());
        return this;
      }
      public Builder AddRangeMethod(scg::IEnumerable<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto> values) {
        if (result.method_ == pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>.Empty) {
          result.method_ = new scg::List<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>();
        }
        base.AddRange(values, result.method_);
        return this;
      }
      public Builder ClearMethod() {
        result.method_ = pbc::Lists<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto>.Empty;
        return this;
      }
      
      // optional .google.protobuf.ServiceOptions options = 3;
      public bool HasOptions {
        get { return result.HasOptions; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions Options {
        get { return result.Options; }
        set { SetOptions(value); }
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions value) {
        result.hasOptions = true;
        result.options_ = value;
        return this;
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Builder builderForValue) {
        result.hasOptions = true;
        result.options_ = builderForValue.Build();
        return this;
      }
      public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions value) {
        if (result.HasOptions &&
            result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance) {
          result.options_ =
            global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
        } else {
          result.options_ = value;
        }
        result.hasOptions = true;
        return this;
      }
      public Builder ClearOptions() {
        result.hasOptions = false;
        result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance;
        return this;
      }
    }
  }
  
  public sealed partial class MethodDescriptorProto : pb::GeneratedMessage<MethodDescriptorProto, MethodDescriptorProto.Builder> {
    private static readonly MethodDescriptorProto defaultInstance = new MethodDescriptorProto();
    public static MethodDescriptorProto DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override MethodDescriptorProto DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override MethodDescriptorProto ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MethodDescriptorProto__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<MethodDescriptorProto, MethodDescriptorProto.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MethodDescriptorProto__FieldAccessorTable; }
    }
    
    // optional string name = 1;
    private bool hasName;
    private string name_ = "";
    public bool HasName {
      get { return hasName; }
    }
    public string Name {
      get { return name_; }
    }
    
    // optional string input_type = 2;
    private bool hasInputType;
    private string inputType_ = "";
    public bool HasInputType {
      get { return hasInputType; }
    }
    public string InputType {
      get { return inputType_; }
    }
    
    // optional string output_type = 3;
    private bool hasOutputType;
    private string outputType_ = "";
    public bool HasOutputType {
      get { return hasOutputType; }
    }
    public string OutputType {
      get { return outputType_; }
    }
    
    // optional .google.protobuf.MethodOptions options = 4;
    private bool hasOptions;
    private global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions options_ = global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance;
    public bool HasOptions {
      get { return hasOptions; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions Options {
      get { return options_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasName) {
        output.WriteString(1, Name);
      }
      if (HasInputType) {
        output.WriteString(2, InputType);
      }
      if (HasOutputType) {
        output.WriteString(3, OutputType);
      }
      if (HasOptions) {
        output.WriteMessage(4, Options);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasName) {
          size += pb::CodedOutputStream.ComputeStringSize(1, Name);
        }
        if (HasInputType) {
          size += pb::CodedOutputStream.ComputeStringSize(2, InputType);
        }
        if (HasOutputType) {
          size += pb::CodedOutputStream.ComputeStringSize(3, OutputType);
        }
        if (HasOptions) {
          size += pb::CodedOutputStream.ComputeMessageSize(4, Options);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto result = new global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto BuildPartial() {
        global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.MethodDescriptorProto.DefaultInstance) return this;
        if (other.HasName) {
          Name = other.Name;
        }
        if (other.HasInputType) {
          InputType = other.InputType;
        }
        if (other.HasOutputType) {
          OutputType = other.OutputType;
        }
        if (other.HasOptions) {
          MergeOptions(other.Options);
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
            case 10: {
              Name = input.ReadString();
              break;
            }
            case 18: {
              InputType = input.ReadString();
              break;
            }
            case 26: {
              OutputType = input.ReadString();
              break;
            }
            case 34: {
              global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Builder subBuilder = global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.CreateBuilder();
              if (HasOptions) {
                subBuilder.MergeFrom(Options);
              }
              input.ReadMessage(subBuilder, extensionRegistry);
              Options = subBuilder.BuildPartial();
              break;
            }
          }
        }
      }
      
      
      // optional string name = 1;
      public bool HasName {
        get { return result.HasName; }
      }
      public string Name {
        get { return result.Name; }
        set { SetName(value); }
      }
      public Builder SetName(string value) {
        result.hasName = true;
        result.name_ = value;
        return this;
      }
      public Builder ClearName() {
        result.hasName = false;
        result.name_ = "";
        return this;
      }
      
      // optional string input_type = 2;
      public bool HasInputType {
        get { return result.HasInputType; }
      }
      public string InputType {
        get { return result.InputType; }
        set { SetInputType(value); }
      }
      public Builder SetInputType(string value) {
        result.hasInputType = true;
        result.inputType_ = value;
        return this;
      }
      public Builder ClearInputType() {
        result.hasInputType = false;
        result.inputType_ = "";
        return this;
      }
      
      // optional string output_type = 3;
      public bool HasOutputType {
        get { return result.HasOutputType; }
      }
      public string OutputType {
        get { return result.OutputType; }
        set { SetOutputType(value); }
      }
      public Builder SetOutputType(string value) {
        result.hasOutputType = true;
        result.outputType_ = value;
        return this;
      }
      public Builder ClearOutputType() {
        result.hasOutputType = false;
        result.outputType_ = "";
        return this;
      }
      
      // optional .google.protobuf.MethodOptions options = 4;
      public bool HasOptions {
        get { return result.HasOptions; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions Options {
        get { return result.Options; }
        set { SetOptions(value); }
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions value) {
        result.hasOptions = true;
        result.options_ = value;
        return this;
      }
      public Builder SetOptions(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Builder builderForValue) {
        result.hasOptions = true;
        result.options_ = builderForValue.Build();
        return this;
      }
      public Builder MergeOptions(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions value) {
        if (result.HasOptions &&
            result.options_ != global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance) {
          result.options_ =
            global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.CreateBuilder(result.options_).MergeFrom(value).BuildPartial();
        } else {
          result.options_ = value;
        }
        result.hasOptions = true;
        return this;
      }
      public Builder ClearOptions() {
        result.hasOptions = false;
        result.options_ = global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance;
        return this;
      }
    }
  }
  
  public sealed partial class FileOptions : pb::GeneratedMessage<FileOptions, FileOptions.Builder> {
    private static readonly FileOptions defaultInstance = new FileOptions();
    public static FileOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override FileOptions DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override FileOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<FileOptions, FileOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FileOptions__FieldAccessorTable; }
    }
    
    #region Nested types
    public static class Types {
      public enum OptimizeMode {
        SPEED = 1,
        CODE_SIZE = 2,
      }
      
    }
    #endregion
    
    // optional string java_package = 1;
    private bool hasJavaPackage;
    private string javaPackage_ = "";
    public bool HasJavaPackage {
      get { return hasJavaPackage; }
    }
    public string JavaPackage {
      get { return javaPackage_; }
    }
    
    // optional string java_outer_classname = 8;
    private bool hasJavaOuterClassname;
    private string javaOuterClassname_ = "";
    public bool HasJavaOuterClassname {
      get { return hasJavaOuterClassname; }
    }
    public string JavaOuterClassname {
      get { return javaOuterClassname_; }
    }
    
    // optional bool java_multiple_files = 10 [default = false];
    private bool hasJavaMultipleFiles;
    private bool javaMultipleFiles_ = false;
    public bool HasJavaMultipleFiles {
      get { return hasJavaMultipleFiles; }
    }
    public bool JavaMultipleFiles {
      get { return javaMultipleFiles_; }
    }
    
    // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = CODE_SIZE];
    private bool hasOptimizeFor;
    private global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode optimizeFor_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode.CODE_SIZE;
    public bool HasOptimizeFor {
      get { return hasOptimizeFor; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode OptimizeFor {  get { return optimizeFor_; }}
    
    // optional string csharp_namespace = 1000;
    private bool hasCsharpNamespace;
    private string csharpNamespace_ = "";
    public bool HasCsharpNamespace {
      get { return hasCsharpNamespace; }
    }
    public string CsharpNamespace {
      get { return csharpNamespace_; }
    }
    
    // optional string csharp_file_classname = 1001;
    private bool hasCsharpFileClassname;
    private string csharpFileClassname_ = "";
    public bool HasCsharpFileClassname {
      get { return hasCsharpFileClassname; }
    }
    public string CsharpFileClassname {
      get { return csharpFileClassname_; }
    }
    
    // optional bool csharp_multiple_files = 1002 [default = false];
    private bool hasCsharpMultipleFiles;
    private bool csharpMultipleFiles_ = false;
    public bool HasCsharpMultipleFiles {
      get { return hasCsharpMultipleFiles; }
    }
    public bool CsharpMultipleFiles {
      get { return csharpMultipleFiles_; }
    }
    
    // optional bool csharp_nest_classes = 1003 [default = false];
    private bool hasCsharpNestClasses;
    private bool csharpNestClasses_ = false;
    public bool HasCsharpNestClasses {
      get { return hasCsharpNestClasses; }
    }
    public bool CsharpNestClasses {
      get { return csharpNestClasses_; }
    }
    
    // optional bool csharp_public_classes = 1004 [default = true];
    private bool hasCsharpPublicClasses;
    private bool csharpPublicClasses_ = true;
    public bool HasCsharpPublicClasses {
      get { return hasCsharpPublicClasses; }
    }
    public bool CsharpPublicClasses {
      get { return csharpPublicClasses_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasJavaPackage) {
        output.WriteString(1, JavaPackage);
      }
      if (HasJavaOuterClassname) {
        output.WriteString(8, JavaOuterClassname);
      }
      if (HasOptimizeFor) {
        output.WriteEnum(9, (int) OptimizeFor);
      }
      if (HasJavaMultipleFiles) {
        output.WriteBool(10, JavaMultipleFiles);
      }
      if (HasCsharpNamespace) {
        output.WriteString(1000, CsharpNamespace);
      }
      if (HasCsharpFileClassname) {
        output.WriteString(1001, CsharpFileClassname);
      }
      if (HasCsharpMultipleFiles) {
        output.WriteBool(1002, CsharpMultipleFiles);
      }
      if (HasCsharpNestClasses) {
        output.WriteBool(1003, CsharpNestClasses);
      }
      if (HasCsharpPublicClasses) {
        output.WriteBool(1004, CsharpPublicClasses);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasJavaPackage) {
          size += pb::CodedOutputStream.ComputeStringSize(1, JavaPackage);
        }
        if (HasJavaOuterClassname) {
          size += pb::CodedOutputStream.ComputeStringSize(8, JavaOuterClassname);
        }
        if (HasOptimizeFor) {
          size += pb::CodedOutputStream
            .ComputeEnumSize(9, (int) OptimizeFor);
        }
        if (HasJavaMultipleFiles) {
          size += pb::CodedOutputStream.ComputeBoolSize(10, JavaMultipleFiles);
        }
        if (HasCsharpNamespace) {
          size += pb::CodedOutputStream.ComputeStringSize(1000, CsharpNamespace);
        }
        if (HasCsharpFileClassname) {
          size += pb::CodedOutputStream.ComputeStringSize(1001, CsharpFileClassname);
        }
        if (HasCsharpMultipleFiles) {
          size += pb::CodedOutputStream.ComputeBoolSize(1002, CsharpMultipleFiles);
        }
        if (HasCsharpNestClasses) {
          size += pb::CodedOutputStream.ComputeBoolSize(1003, CsharpNestClasses);
        }
        if (HasCsharpPublicClasses) {
          size += pb::CodedOutputStream.ComputeBoolSize(1004, CsharpPublicClasses);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FileOptions ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.FileOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.FileOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.FileOptions();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.FileOptions MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.FileOptions();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.FileOptions DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.FileOptions BuildPartial() {
        global::Google.ProtocolBuffers.DescriptorProtos.FileOptions returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.FileOptions) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.FileOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.DefaultInstance) return this;
        if (other.HasJavaPackage) {
          JavaPackage = other.JavaPackage;
        }
        if (other.HasJavaOuterClassname) {
          JavaOuterClassname = other.JavaOuterClassname;
        }
        if (other.HasJavaMultipleFiles) {
          JavaMultipleFiles = other.JavaMultipleFiles;
        }
        if (other.HasOptimizeFor) {
          OptimizeFor = other.OptimizeFor;
        }
        if (other.HasCsharpNamespace) {
          CsharpNamespace = other.CsharpNamespace;
        }
        if (other.HasCsharpFileClassname) {
          CsharpFileClassname = other.CsharpFileClassname;
        }
        if (other.HasCsharpMultipleFiles) {
          CsharpMultipleFiles = other.CsharpMultipleFiles;
        }
        if (other.HasCsharpNestClasses) {
          CsharpNestClasses = other.CsharpNestClasses;
        }
        if (other.HasCsharpPublicClasses) {
          CsharpPublicClasses = other.CsharpPublicClasses;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
            case 10: {
              JavaPackage = input.ReadString();
              break;
            }
            case 66: {
              JavaOuterClassname = input.ReadString();
              break;
            }
            case 72: {
              int rawValue = input.ReadEnum();
              if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode), rawValue)) {
                unknownFields.MergeVarintField(9, (ulong) rawValue);
              } else {
                OptimizeFor = (global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode) rawValue;
              }
              break;
            }
            case 80: {
              JavaMultipleFiles = input.ReadBool();
              break;
            }
            case 8002: {
              CsharpNamespace = input.ReadString();
              break;
            }
            case 8010: {
              CsharpFileClassname = input.ReadString();
              break;
            }
            case 8016: {
              CsharpMultipleFiles = input.ReadBool();
              break;
            }
            case 8024: {
              CsharpNestClasses = input.ReadBool();
              break;
            }
            case 8032: {
              CsharpPublicClasses = input.ReadBool();
              break;
            }
          }
        }
      }
      
      
      // optional string java_package = 1;
      public bool HasJavaPackage {
        get { return result.HasJavaPackage; }
      }
      public string JavaPackage {
        get { return result.JavaPackage; }
        set { SetJavaPackage(value); }
      }
      public Builder SetJavaPackage(string value) {
        result.hasJavaPackage = true;
        result.javaPackage_ = value;
        return this;
      }
      public Builder ClearJavaPackage() {
        result.hasJavaPackage = false;
        result.javaPackage_ = "";
        return this;
      }
      
      // optional string java_outer_classname = 8;
      public bool HasJavaOuterClassname {
        get { return result.HasJavaOuterClassname; }
      }
      public string JavaOuterClassname {
        get { return result.JavaOuterClassname; }
        set { SetJavaOuterClassname(value); }
      }
      public Builder SetJavaOuterClassname(string value) {
        result.hasJavaOuterClassname = true;
        result.javaOuterClassname_ = value;
        return this;
      }
      public Builder ClearJavaOuterClassname() {
        result.hasJavaOuterClassname = false;
        result.javaOuterClassname_ = "";
        return this;
      }
      
      // optional bool java_multiple_files = 10 [default = false];
      public bool HasJavaMultipleFiles {
        get { return result.HasJavaMultipleFiles; }
      }
      public bool JavaMultipleFiles {
        get { return result.JavaMultipleFiles; }
        set { SetJavaMultipleFiles(value); }
      }
      public Builder SetJavaMultipleFiles(bool value) {
        result.hasJavaMultipleFiles = true;
        result.javaMultipleFiles_ = value;
        return this;
      }
      public Builder ClearJavaMultipleFiles() {
        result.hasJavaMultipleFiles = false;
        result.javaMultipleFiles_ = false;
        return this;
      }
      
      // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = CODE_SIZE];
      public bool HasOptimizeFor {
        get { return result.HasOptimizeFor; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode OptimizeFor {
        get { return result.OptimizeFor; }
        set { SetOptimizeFor(value); }
      }
      public Builder SetOptimizeFor(global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode value) {
        result.hasOptimizeFor = true;
        result.optimizeFor_ = value;
        return this;
      }
      public Builder ClearOptimizeFor() {
        result.hasOptimizeFor = false;
        result.optimizeFor_ = global::Google.ProtocolBuffers.DescriptorProtos.FileOptions.Types.OptimizeMode.CODE_SIZE;
        return this;
      }
      
      // optional string csharp_namespace = 1000;
      public bool HasCsharpNamespace {
        get { return result.HasCsharpNamespace; }
      }
      public string CsharpNamespace {
        get { return result.CsharpNamespace; }
        set { SetCsharpNamespace(value); }
      }
      public Builder SetCsharpNamespace(string value) {
        result.hasCsharpNamespace = true;
        result.csharpNamespace_ = value;
        return this;
      }
      public Builder ClearCsharpNamespace() {
        result.hasCsharpNamespace = false;
        result.csharpNamespace_ = "";
        return this;
      }
      
      // optional string csharp_file_classname = 1001;
      public bool HasCsharpFileClassname {
        get { return result.HasCsharpFileClassname; }
      }
      public string CsharpFileClassname {
        get { return result.CsharpFileClassname; }
        set { SetCsharpFileClassname(value); }
      }
      public Builder SetCsharpFileClassname(string value) {
        result.hasCsharpFileClassname = true;
        result.csharpFileClassname_ = value;
        return this;
      }
      public Builder ClearCsharpFileClassname() {
        result.hasCsharpFileClassname = false;
        result.csharpFileClassname_ = "";
        return this;
      }
      
      // optional bool csharp_multiple_files = 1002 [default = false];
      public bool HasCsharpMultipleFiles {
        get { return result.HasCsharpMultipleFiles; }
      }
      public bool CsharpMultipleFiles {
        get { return result.CsharpMultipleFiles; }
        set { SetCsharpMultipleFiles(value); }
      }
      public Builder SetCsharpMultipleFiles(bool value) {
        result.hasCsharpMultipleFiles = true;
        result.csharpMultipleFiles_ = value;
        return this;
      }
      public Builder ClearCsharpMultipleFiles() {
        result.hasCsharpMultipleFiles = false;
        result.csharpMultipleFiles_ = false;
        return this;
      }
      
      // optional bool csharp_nest_classes = 1003 [default = false];
      public bool HasCsharpNestClasses {
        get { return result.HasCsharpNestClasses; }
      }
      public bool CsharpNestClasses {
        get { return result.CsharpNestClasses; }
        set { SetCsharpNestClasses(value); }
      }
      public Builder SetCsharpNestClasses(bool value) {
        result.hasCsharpNestClasses = true;
        result.csharpNestClasses_ = value;
        return this;
      }
      public Builder ClearCsharpNestClasses() {
        result.hasCsharpNestClasses = false;
        result.csharpNestClasses_ = false;
        return this;
      }
      
      // optional bool csharp_public_classes = 1004 [default = true];
      public bool HasCsharpPublicClasses {
        get { return result.HasCsharpPublicClasses; }
      }
      public bool CsharpPublicClasses {
        get { return result.CsharpPublicClasses; }
        set { SetCsharpPublicClasses(value); }
      }
      public Builder SetCsharpPublicClasses(bool value) {
        result.hasCsharpPublicClasses = true;
        result.csharpPublicClasses_ = value;
        return this;
      }
      public Builder ClearCsharpPublicClasses() {
        result.hasCsharpPublicClasses = false;
        result.csharpPublicClasses_ = true;
        return this;
      }
    }
  }
  
  public sealed partial class MessageOptions : pb::GeneratedMessage<MessageOptions, MessageOptions.Builder> {
    private static readonly MessageOptions defaultInstance = new MessageOptions();
    public static MessageOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override MessageOptions DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override MessageOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MessageOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<MessageOptions, MessageOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MessageOptions__FieldAccessorTable; }
    }
    
    // optional bool message_set_wire_format = 1 [default = false];
    private bool hasMessageSetWireFormat;
    private bool messageSetWireFormat_ = false;
    public bool HasMessageSetWireFormat {
      get { return hasMessageSetWireFormat; }
    }
    public bool MessageSetWireFormat {
      get { return messageSetWireFormat_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasMessageSetWireFormat) {
        output.WriteBool(1, MessageSetWireFormat);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasMessageSetWireFormat) {
          size += pb::CodedOutputStream.ComputeBoolSize(1, MessageSetWireFormat);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions BuildPartial() {
        global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.MessageOptions.DefaultInstance) return this;
        if (other.HasMessageSetWireFormat) {
          MessageSetWireFormat = other.MessageSetWireFormat;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
            case 8: {
              MessageSetWireFormat = input.ReadBool();
              break;
            }
          }
        }
      }
      
      
      // optional bool message_set_wire_format = 1 [default = false];
      public bool HasMessageSetWireFormat {
        get { return result.HasMessageSetWireFormat; }
      }
      public bool MessageSetWireFormat {
        get { return result.MessageSetWireFormat; }
        set { SetMessageSetWireFormat(value); }
      }
      public Builder SetMessageSetWireFormat(bool value) {
        result.hasMessageSetWireFormat = true;
        result.messageSetWireFormat_ = value;
        return this;
      }
      public Builder ClearMessageSetWireFormat() {
        result.hasMessageSetWireFormat = false;
        result.messageSetWireFormat_ = false;
        return this;
      }
    }
  }
  
  public sealed partial class FieldOptions : pb::GeneratedMessage<FieldOptions, FieldOptions.Builder> {
    private static readonly FieldOptions defaultInstance = new FieldOptions();
    public static FieldOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override FieldOptions DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override FieldOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FieldOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<FieldOptions, FieldOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_FieldOptions__FieldAccessorTable; }
    }
    
    #region Nested types
    public static class Types {
      public enum CType {
        CORD = 1,
        STRING_PIECE = 2,
      }
      
    }
    #endregion
    
    // optional .google.protobuf.FieldOptions.CType ctype = 1;
    private bool hasCtype;
    private global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType ctype_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType.CORD;
    public bool HasCtype {
      get { return hasCtype; }
    }
    public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType Ctype {  get { return ctype_; }}
    
    // optional string experimental_map_key = 9;
    private bool hasExperimentalMapKey;
    private string experimentalMapKey_ = "";
    public bool HasExperimentalMapKey {
      get { return hasExperimentalMapKey; }
    }
    public string ExperimentalMapKey {
      get { return experimentalMapKey_; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      if (HasCtype) {
        output.WriteEnum(1, (int) Ctype);
      }
      if (HasExperimentalMapKey) {
        output.WriteString(9, ExperimentalMapKey);
      }
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        if (HasCtype) {
          size += pb::CodedOutputStream
            .ComputeEnumSize(1, (int) Ctype);
        }
        if (HasExperimentalMapKey) {
          size += pb::CodedOutputStream.ComputeStringSize(9, ExperimentalMapKey);
        }
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions BuildPartial() {
        global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.DefaultInstance) return this;
        if (other.HasCtype) {
          Ctype = other.Ctype;
        }
        if (other.HasExperimentalMapKey) {
          ExperimentalMapKey = other.ExperimentalMapKey;
        }
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
            case 8: {
              int rawValue = input.ReadEnum();
              if (!global::System.Enum.IsDefined(typeof(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType), rawValue)) {
                unknownFields.MergeVarintField(1, (ulong) rawValue);
              } else {
                Ctype = (global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType) rawValue;
              }
              break;
            }
            case 74: {
              ExperimentalMapKey = input.ReadString();
              break;
            }
          }
        }
      }
      
      
      // optional .google.protobuf.FieldOptions.CType ctype = 1;
      public bool HasCtype {
        get { return result.HasCtype; }
      }
      public global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType Ctype {
        get { return result.Ctype; }
        set { SetCtype(value); }
      }
      public Builder SetCtype(global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType value) {
        result.hasCtype = true;
        result.ctype_ = value;
        return this;
      }
      public Builder ClearCtype() {
        result.hasCtype = false;
        result.ctype_ = global::Google.ProtocolBuffers.DescriptorProtos.FieldOptions.Types.CType.CORD;
        return this;
      }
      
      // optional string experimental_map_key = 9;
      public bool HasExperimentalMapKey {
        get { return result.HasExperimentalMapKey; }
      }
      public string ExperimentalMapKey {
        get { return result.ExperimentalMapKey; }
        set { SetExperimentalMapKey(value); }
      }
      public Builder SetExperimentalMapKey(string value) {
        result.hasExperimentalMapKey = true;
        result.experimentalMapKey_ = value;
        return this;
      }
      public Builder ClearExperimentalMapKey() {
        result.hasExperimentalMapKey = false;
        result.experimentalMapKey_ = "";
        return this;
      }
    }
  }
  
  public sealed partial class EnumOptions : pb::GeneratedMessage<EnumOptions, EnumOptions.Builder> {
    private static readonly EnumOptions defaultInstance = new EnumOptions();
    public static EnumOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override EnumOptions DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override EnumOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<EnumOptions, EnumOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumOptions__FieldAccessorTable; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions BuildPartial() {
        global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.EnumOptions.DefaultInstance) return this;
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
          }
        }
      }
      
    }
  }
  
  public sealed partial class EnumValueOptions : pb::GeneratedMessage<EnumValueOptions, EnumValueOptions.Builder> {
    private static readonly EnumValueOptions defaultInstance = new EnumValueOptions();
    public static EnumValueOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override EnumValueOptions DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override EnumValueOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumValueOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<EnumValueOptions, EnumValueOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_EnumValueOptions__FieldAccessorTable; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions BuildPartial() {
        global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.EnumValueOptions.DefaultInstance) return this;
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
          }
        }
      }
      
    }
  }
  
  public sealed partial class ServiceOptions : pb::GeneratedMessage<ServiceOptions, ServiceOptions.Builder> {
    private static readonly ServiceOptions defaultInstance = new ServiceOptions();
    public static ServiceOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override ServiceOptions DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override ServiceOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_ServiceOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<ServiceOptions, ServiceOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_ServiceOptions__FieldAccessorTable; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions BuildPartial() {
        global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.ServiceOptions.DefaultInstance) return this;
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
          }
        }
      }
      
    }
  }
  
  public sealed partial class MethodOptions : pb::GeneratedMessage<MethodOptions, MethodOptions.Builder> {
    private static readonly MethodOptions defaultInstance = new MethodOptions();
    public static MethodOptions DefaultInstance {
      get { return defaultInstance; }
    }
    
    public override MethodOptions DefaultInstanceForType {
      get { return defaultInstance; }
    }
    
    protected override MethodOptions ThisMessage {
      get { return this; }
    }
    
    public static pbd::MessageDescriptor Descriptor {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MethodOptions__Descriptor; }
    }
    
    protected override pb::FieldAccess.FieldAccessorTable<MethodOptions, MethodOptions.Builder> InternalFieldAccessors {
      get { return global::Google.ProtocolBuffers.DescriptorProtos.DescriptorProtoFile.internal__static_google_protobuf_MethodOptions__FieldAccessorTable; }
    }
    
    public override bool IsInitialized {
      get {
        return true;
      }
    }
    
    public override void WriteTo(pb::CodedOutputStream output) {
      UnknownFields.WriteTo(output);
    }
    
    private int memoizedSerializedSize = -1;
    public override int SerializedSize {
      get {
        int size = memoizedSerializedSize;
        if (size != -1) return size;
        
        size = 0;
        size += UnknownFields.SerializedSize;
        memoizedSerializedSize = size;
        return size;
      }
    }
    
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(pb::ByteString data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(pb::ByteString data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(byte[] data) {
      return ((Builder) CreateBuilder().MergeFrom(data)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(byte[] data,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(data, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(global::System.IO.Stream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(
        global::System.IO.Stream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(pb::CodedInputStream input) {
      return ((Builder) CreateBuilder().MergeFrom(input)).BuildParsed();
    }
    public static global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions ParseFrom(pb::CodedInputStream input,
        pb::ExtensionRegistry extensionRegistry) {
      return ((Builder) CreateBuilder().MergeFrom(input, extensionRegistry))
               .BuildParsed();
    }
    
    public static Builder CreateBuilder() { return new Builder(); }
    public override Builder CreateBuilderForType() { return new Builder(); }
    public static Builder CreateBuilder(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions prototype) {
      return (Builder) new Builder().MergeFrom(prototype);
    }
    
    public sealed partial class Builder : pb::GeneratedBuilder<global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions, Builder> {
      protected override Builder ThisBuilder {
        get { return this; }
      }
      
      // Construct using global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.CreateBuilder()
      internal Builder() {}
      
      global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions result = new global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions();
      
      protected override global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions MessageBeingBuilt {
        get { return result; }
      }
      
      public override Builder Clear() {
        result = new global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions();
        return this;
      }
      
      public override Builder Clone() {
        return new Builder().MergeFrom(result);
      }
      
      public override pbd::MessageDescriptor DescriptorForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.Descriptor; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions DefaultInstanceForType {
        get { return global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance; }
      }
      
      public override global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions BuildPartial() {
        global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions returnMe = result;
        result = null;
        return returnMe;
      }
      
      public override Builder MergeFrom(pb::IMessage other) {
        if (other is global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions) {
          return MergeFrom((global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions) other);
        } else {
          base.MergeFrom(other);
          return this;
        }
      }
      
      public override Builder MergeFrom(global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions other) {
        if (other == global::Google.ProtocolBuffers.DescriptorProtos.MethodOptions.DefaultInstance) return this;
        this.MergeUnknownFields(other.UnknownFields);
        return this;
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input) {
        return MergeFrom(input, pb::ExtensionRegistry.Empty);
      }
      
      public override Builder MergeFrom(pb::CodedInputStream input, pb::ExtensionRegistry extensionRegistry) {
        pb::UnknownFieldSet.Builder unknownFields =
          pb::UnknownFieldSet.CreateBuilder(this.UnknownFields);
        while (true) {
          uint tag = input.ReadTag();
          switch (tag) {
            case 0:
              this.UnknownFields = unknownFields.Build();
              return this;
            default: {
              if (!ParseUnknownField(input, unknownFields,
                                     extensionRegistry, tag)) {
                this.UnknownFields = unknownFields.Build();
                return this;
              }
              break;
            }
          }
        }
      }
      
    }
  }
  
  #endregion
  
  #region Services
  #endregion
}